fuzzy-regex 0.1.0

High-performance fuzzy regular expression engine combining regex with Damerau-Levenshtein distance
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

# Partial Matching

Match incomplete or streaming input.

## Enabling Partial Matching

```rust
use fuzzy_regex::FuzzyRegexBuilder;

let re = FuzzyRegexBuilder::new("(?:hello){e<=1}")
    .partial(true)
    .build()
    .unwrap();
```

## How It Works

When enabled, matches that reach the end of the input are marked as "partial":

```rust
let re = FuzzyRegexBuilder::new("(?:hello){e<=1}")
    .partial(true)
    .build()
    .unwrap();

// Match at end of text - partial
let m1 = re.find("hello").unwrap();
assert!(m1.partial());

// Match not at end - not partial
let m2 = re.find("say hello").unwrap();
assert!(!m2.partial());

// Fuzzy match reaching end - also partial
let m3 = re.find("hallo").unwrap();
assert!(m3.partial());
```

## Use Cases

### Streaming Input

```rust
use fuzzy_regex::FuzzyRegexBuilder;

let re = FuzzyRegexBuilder::new("(?:command){e<=1}")
    .partial(true)
    .build()
    .unwrap();

let mut stream = re.stream();

// Feed incomplete data
for m in stream.feed(b"cmd") {
    if m.partial() {
        println!("Partial match: might be complete when more data arrives");
    }
}
```

### Progressive Matching

```rust
// Check if more input needed
let m = re.find("incomplete");
if m.map(|m| m.partial()).unwrap_or(false) {
    // Get more input
}
```

## Without Partial

By default (`partial(false)`), partial matches behave the same as full matches:

```rust
let re = FuzzyRegexBuilder::new("(?:hello){e<=1}")
    .partial(false) // default
    .build()
    .unwrap();

let m = re.find("hello").unwrap();
assert!(!m.partial()); // Always false
```