tre-regex 0.6.0

Rust safe bindings to the TRE regex module
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

tre-regex
---------

[![CI](https://github.com/Elizafox/tre-regex/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/Elizafox/tre-regex/actions/workflows/ci.yml)

Safe API bindings to the [TRE regex engine](https://laurikari.net/tre).

Documentation is available at [docs.rs](https://docs.rs/crate/tre-regex/latest).

Requires Rust 1.85.1 or newer.

```rust
use tre_regex::{Regex, RegcompFlags, RegexecFlags};

fn main() -> tre_regex::Result<()> {
    let regex = Regex::new(
        "^([[:alpha:]]+) ([[:alpha:]]+)$",
        RegcompFlags::EXTENDED | RegcompFlags::ICASE,
    )?;

    assert!(regex.is_match("hello world", RegexecFlags::NONE)?);
    let captures = regex.captures("hello world", 3, RegexecFlags::NONE)?;
    assert_eq!(captures[1], Some("hello"));
    Ok(())
}
```

Approximate matching
====================

Approximate matching allows insertions, deletions, and substitutions with configurable costs and
limits. It requires the `approx` feature, which is enabled by default.

```rust
use tre_regex::{Regex, RegApproxParams, RegcompFlags, RegexecFlags};

fn main() -> tre_regex::Result<()> {
    let regex = Regex::new("^(hello).*(world)$", RegcompFlags::EXTENDED)?;
    let params = RegApproxParams::new()
        .cost_ins(1)
        .cost_del(1)
        .cost_subst(1)
        .max_cost(2)
        .max_ins(2)
        .max_del(2)
        .max_subst(2)
        .max_err(2);

    let result = regex.regaexec("hullo warld", &params, 3, RegexecFlags::NONE)?;
    assert_eq!(result.cost(), 2);
    assert_eq!(result.get_matches()[0], Some("hullo warld"));
    assert_eq!(result.get_matches()[1], Some("hullo"));
    assert_eq!(result.get_matches()[2], Some("warld"));
    Ok(())
}
```

Wide-character matching
=======================

Wide-character support requires the default `wchar` feature and a dependency on the
[`widestring`](https://crates.io/crates/widestring) crate.

```rust
use tre_regex::{Regex, RegcompFlags, RegexecFlags};
use widestring::widestr;

fn main() -> tre_regex::Result<()> {
    let regex = Regex::new_wide(
        widestr!("^(hello).*(world)$"),
        RegcompFlags::EXTENDED | RegcompFlags::ICASE,
    )?;
    let captures = regex.regwexec(widestr!("hello wide world"), 3, RegexecFlags::NONE)?;

    assert_eq!(captures[1], Some(widestr!("hello")));
    assert_eq!(captures[2], Some(widestr!("world")));
    Ok(())
}
```

Features
========

- `wchar`: enable wide-character regex support. **Enabled by default.**
- `approx`: enable approximate matching support. **Enabled by default.**
- `vendored`: use the vendored copy of TRE with [tre-regex-sys](https://crates.io/crates/tre-regex-sys); otherwise use the system TRE. **Enabled by default.**