rreplace 0.1.2

rreplace is a rust library designed to streamline string replacements. It can handle multiple unique replacements and iterates the string only once.
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
87
88
89
90
91
92
93

rreplace 
========
rreplace is a rust library designed to streamline string replacements.
It can handle multiple unique replacements and iterates the string only
once. Multiple unique repacements may eclipse one another, therefore
rreplace follows this replacement priority.

1.   First match

2.   Longest match

rreplace in action 
==================

**run(&str, Hashmap<&str,&str>) → String**

    `run` takes a string argument to search and a Hashmap of
    replacements. The Key of the hashmap is the sequence to match, the
    Value is the sequence to replace.

``` {.rust}
// Create HashMap to define replacements
let replace: Hashmap<&str, &str> = Hashmap::new();
replace.insert("This", "xxxx");
replace.insert("foo", "foobar");

rreplace::run("This string is foo", r);
// Returns:   "xxxx string is foobar"
```

Complex examples 
================

The priority with which rreplace updates strings is shown in several
examples below.

Replace First 
-------------

``` {.rust}
replace.insert("This string", "xxx");
replace.insert("string", "yyy");

rreplace::run("This string is foo", r);
// Returns:   "xxx is foo"
```

`"This string"` begins matching before `"string"` and therefore takes
replacement priority.

Replace Longest 
---------------

``` {.rust}
replace.insert("This string", "yyy");
replace.insert("This", "xxx");

rreplace::run("This string is foo", replace);
// Returns:   "xxx is foo"
```

Both seqences begin matching on the same index, therefore the longer
replacement takes priority.

More Replacemets and Failing 
----------------------------

### Eclipsing 

``` {.rust}
replace.insert("string is foo", "yyy");
replace.insert("i", "I");

rreplace::run("This string is foo", replace);
// Returns:   "ThIs xxx"
```

`"i"` cannot be replaced within `"string is foo"`. This is because
`"string is foo"` begins matching earlier than the individual `"i"`
within.

### Failing 

``` {.rust}
replace.insert("string is X", "yyy");
replace.insert("i", "I");

rreplace::run("This string is foo", replace);
// Returns:   "ThIs strIng Is foo"
```

`"string is X"` is unable to find a complete match and therefore `"i"`
matches with every `i` within the string.