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

# Algorithm Selection

How fuzzy-regex chooses the matching algorithm.

## Decision Tree

```
Pattern Analysis
      │
      ▼
┌──────────────────┐
│ Is exact match?  │
└────────┬─────────┘
         │
    ┌────┴────┐
    ▼         ▼
   Yes       No
    │         │
    ▼         ▼
  DFA    ┌────────────────┐
         │ Pattern ≤64?   │
         └────────┬────────┘
                  │
             ┌────┴────┐
             ▼         ▼
            Yes       No
             │         │
             ▼         ▼
          Bitap    Levenshtein
                     NFA
```

## Algorithm Comparison

| Algorithm | Use Case | Complexity | Features |
|-----------|----------|------------|----------|
| DFA | Exact patterns | O(n) | Limited |
| Bitap | Short fuzzy (≤64 chars) | O(n×k) | Most |
| Levenshtein NFA | Long fuzzy patterns | O(n×k×m) | Full |

## Automatic Selection

The library automatically selects based on:

1. **Pattern length**: Bitap for ≤64 chars
2. **Fuzzy complexity**: Cost-based vs simple
3. **Regex features**: DFA can't do lookahead
4. **Streaming**: Different code path

## Manual Override

Not currently exposed, but internal selection can be inspected:

```rust
// Check which engine was used
let re = FuzzyRegex::new("(?:hello){e<=1}").unwrap();
if re.supports_streaming() {
    // Using Bitap
}
```