simple-string-patterns 0.4.0

Makes it easier to match, split and extract strings in Rust without regular expressions. The parallel string-patterns crate provides extensions to work with regular expressions via the Regex library
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390

use crate::SimpleMatch;

/// A lazily-combined boolean match expression over a single string.
/// Lets you compose several simple pattern checks in one fluent, left-to-right
/// readable chain instead of nesting boolean expressions, e.g.
/// ```
/// use simple_string_patterns::*;
///
/// let subject = "Floating-point error at line 667";
/// let is_float_error = subject.match_contains_ci("error")
///   .and_starts_with_ci_alphanum("float")
///   .result();
/// assert!(is_float_error);
/// ```
/// Each `and_*`/`or_*` method re-tests the same subject string, so there is no need to repeat it.
#[derive(Debug, Clone, Copy)]
pub struct StringMatch<'a> {
    subject: &'a str,
    matched: bool,
}

impl<'a> StringMatch<'a> {
    fn new(subject: &'a str, matched: bool) -> Self {
        StringMatch { subject, matched }
    }

    /// Returns the accumulated boolean result of the chain so far
    pub fn result(&self) -> bool {
        self.matched
    }

    /// The subject string this match chain was built from
    pub fn subject(&self) -> &'a str {
        self.subject
    }

    // ---- and_* (all conditions so far and this one must match) ----

    pub fn and_contains_ci(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.contains_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_contains_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.contains_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_contains_cs(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.contains(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_starts_with_ci(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.starts_with_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_starts_with_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.starts_with_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_starts_with_cs(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.starts_with(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_ends_with_ci(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.ends_with_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_ends_with_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.ends_with_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_ends_with_cs(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.ends_with(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_equals_ci(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.equals_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_equals_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject.equals_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_equals_cs(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject == pattern;
        Self::new(self.subject, matched)
    }

    // ---- and_not_* (all conditions so far must match and this one must not) ----

    pub fn and_not_contains_ci(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.contains_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_contains_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.contains_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_contains_cs(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.contains(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_starts_with_ci(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.starts_with_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_starts_with_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.starts_with_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_starts_with_cs(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.starts_with(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_ends_with_ci(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.ends_with_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_ends_with_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.ends_with_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_ends_with_cs(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.ends_with(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_equals_ci(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.equals_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_equals_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched && !self.subject.equals_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn and_not_equals_cs(self, pattern: &str) -> Self {
        let matched = self.matched && self.subject != pattern;
        Self::new(self.subject, matched)
    }

    // ---- or_* (either the conditions so far or this one may match) ----

    pub fn or_contains_ci(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.contains_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_contains_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.contains_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_contains_cs(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.contains(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_starts_with_ci(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.starts_with_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_starts_with_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.starts_with_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_starts_with_cs(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.starts_with(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_ends_with_ci(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.ends_with_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_ends_with_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.ends_with_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_ends_with_cs(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.ends_with(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_equals_ci(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.equals_ci(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_equals_ci_alphanum(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject.equals_ci_alphanum(pattern);
        Self::new(self.subject, matched)
    }

    pub fn or_equals_cs(self, pattern: &str) -> Self {
        let matched = self.matched || self.subject == pattern;
        Self::new(self.subject, matched)
    }
}

impl<'a> From<StringMatch<'a>> for bool {
    fn from(m: StringMatch<'a>) -> bool {
        m.matched
    }
}

impl<'a> PartialEq<bool> for StringMatch<'a> {
    fn eq(&self, other: &bool) -> bool {
        self.matched == *other
    }
}

/// Entry points that start a fluent [`StringMatch`] chain from a single simple pattern check
pub trait ToStringMatch {
    /// Start a chain testing if the string contains a pattern in case-insensitive mode
    fn match_contains_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string contains a case-insensitive alphanumeric sequence
    fn match_contains_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string contains a pattern in case-sensitive mode
    fn match_contains_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string starts with a pattern in case-insensitive mode
    fn match_starts_with_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string starts with a case-insensitive alphanumeric sequence
    fn match_starts_with_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string starts with a pattern in case-sensitive mode
    fn match_starts_with_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string ends with a pattern in case-insensitive mode
    fn match_ends_with_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string ends with a case-insensitive alphanumeric sequence
    fn match_ends_with_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the string ends with a pattern in case-sensitive mode
    fn match_ends_with_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the whole string matches a pattern in case-insensitive mode
    fn match_equals_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the whole string matches a case-insensitive alphanumeric sequence
    fn match_equals_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
    /// Start a chain testing if the whole string matches a pattern in case-sensitive mode
    fn match_equals_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a>;
}

impl<T: AsRef<str>> ToStringMatch for T {
    fn match_contains_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.contains_ci(pattern))
    }

    fn match_contains_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.contains_ci_alphanum(pattern))
    }

    fn match_contains_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.contains(pattern))
    }

    fn match_starts_with_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.starts_with_ci(pattern))
    }

    fn match_starts_with_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.starts_with_ci_alphanum(pattern))
    }

    fn match_starts_with_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.starts_with(pattern))
    }

    fn match_ends_with_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.ends_with_ci(pattern))
    }

    fn match_ends_with_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.ends_with_ci_alphanum(pattern))
    }

    fn match_ends_with_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.ends_with(pattern))
    }

    fn match_equals_ci<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.equals_ci(pattern))
    }

    fn match_equals_ci_alphanum<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s.equals_ci_alphanum(pattern))
    }

    fn match_equals_cs<'a>(&'a self, pattern: &str) -> StringMatch<'a> {
        let s = self.as_ref();
        StringMatch::new(s, s == pattern)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_and_chain() {
        let sample_1 = "Floating-point error at line 667";
        let sample_2 = "[floating-point] error in line 999";
        let sample_3 = "Rounding error at line 12";

        assert!(sample_1
            .match_contains_ci("error")
            .and_starts_with_ci_alphanum("float")
            .result());
        assert!(sample_2
            .match_contains_ci("error")
            .and_starts_with_ci_alphanum("float")
            .result());
        assert!(!sample_3
            .match_contains_ci("error")
            .and_starts_with_ci_alphanum("float")
            .result());
    }

    #[test]
    fn test_and_not_chain() {
        let sample_1 = "cat-picture.jpg";
        let sample_2 = "cat-picture.psd";

        assert!(sample_1
            .match_starts_with_ci("cat")
            .and_not_ends_with_ci(".psd")
            .result());
        assert!(!sample_2
            .match_starts_with_ci("cat")
            .and_not_ends_with_ci(".psd")
            .result());
    }

    #[test]
    fn test_or_chain() {
        let sample_1 = "cat-picture.jpg";
        let sample_2 = "dog-picture.jpg";
        let sample_3 = "rabbit-picture.jpg";

        let is_cat_or_dog = |s: &str| {
            s.match_starts_with_ci("cat")
                .or_starts_with_ci("dog")
                .result()
        };
        assert!(is_cat_or_dog(sample_1));
        assert!(is_cat_or_dog(sample_2));
        assert!(!is_cat_or_dog(sample_3));
    }

    #[test]
    fn test_result_conversions() {
        let sample = "Start-up";
        let chain = sample.match_equals_ci_alphanum("startup");
        assert!(chain.result());
        assert_eq!(chain, true);
        let as_bool: bool = chain.into();
        assert!(as_bool);
    }
}