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

# Edit Distance

The edit distance (Levenshtein distance) measures how many operations it takes to transform the pattern into the matched text.

## Edit Types

### Insertion

Adding a character to the text:

```
Pattern: "cat"
Text:    "cart" 
Edit:    Insert 'r' after 'c'
Cost:    1
```

### Deletion

Removing a character from the text:

```
Pattern: "cat"  
Text:    "ct"
Edit:    Delete 'a'
Cost:    1
```

### Substitution

Replacing one character with another:

```
Pattern: "cat"
Text:    "bat"
Edit:    Replace 'c' with 'b'
Cost:    1
```

### Transposition

Swapping two adjacent characters:

```
Pattern: "cat"
Text:    "act"
Edit:    Swap 'c' and 'a'
Cost:    1
```

## Accessing Edit Information

```rust
use fuzzy_regex::FuzzyRegex;

let re = FuzzyRegex::new("(?:hello){e<=2}").unwrap();
let m = re.find("hallo").unwrap();

println!("Similarity: {:.2}", m.similarity());
println!("Edits: {}", m.len()); // Match length

// Edit counts available in the engine
// Use engine::EditCounts for detailed info
```

## Similarity Score

The similarity score ranges from 0.0 to 1.0, where 1.0 is an exact match:

```rust
use fuzzy_regex::FuzzyRegexBuilder;

let re = FuzzyRegexBuilder::new("(?:hello){e<=2}")
    .similarity(0.8) // Minimum similarity threshold
    .build()
    .unwrap();

// Exact match: similarity = 1.0
// 1 edit: similarity around 0.8-0.9
// 2 edits: similarity around 0.6-0.8
```