regexml 0.2.2

XPath compatible regex engine
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

#[cfg(test)]
use crate::operation::Operation;
use crate::re_compiler::ReCompiler;
use crate::re_flags::Language;
use crate::re_flags::ReFlags;
use crate::re_matcher::ReMatcher;
use crate::re_program::ReProgram;

pub use crate::analyze_string::AnalyzeIter;
pub use crate::re_compiler::Error;

/// A XML-style regular expression.
#[derive(Debug)]
pub struct Regex {
    re_program: ReProgram,
    matches_empty_string: bool,
}

impl Regex {
    fn new(re: &str, flags: &str, language: Language) -> Result<Self, Error> {
        let re_flags = ReFlags::new(flags, language)?;
        let pattern = re.chars().collect();
        let re_compiler = ReCompiler::new(pattern, re_flags);
        let re_program = re_compiler.compile()?;
        // we need to check if the regex matches the empty string
        let mut matcher = ReMatcher::new(&re_program, "");
        let matches_empty_string = matcher.is_match();
        Ok(Self {
            re_program,
            matches_empty_string,
        })
    }

    /// Create a regular expression from a string, using XPath 3.1 rules.
    pub fn xpath(re: &str, flags: &str) -> Result<Self, Error> {
        Self::new(re, flags, Language::XPath)
    }

    /// Create a regular expression from a string, using XML Schema 1.1 rules.
    pub fn xsd(re: &str, flags: &str) -> Result<Self, Error> {
        Self::new(re, flags, Language::XSD)
    }

    /// Returns `true` if the argument matches this regular expression.
    pub fn is_match(&self, haystack: &str) -> bool {
        let mut matcher = self.matcher(haystack);
        matcher.is_match()
    }

    // returns an error if this regex is known to match an empty string.
    // caches the last result so it doesn't have to do the match again.
    fn check_matches_empty_string(&self) -> Result<(), Error> {
        if !self.matches_empty_string {
            Ok(())
        } else {
            Err(Error::MatchesEmptyString)
        }
    }

    /// Returns a string with all pieces matching this regular expression replaced
    /// by the replacement.
    pub fn replace_all(&self, haystack: &str, replacement: &str) -> Result<String, Error> {
        self.check_matches_empty_string()?;

        let mut matcher = self.matcher(haystack);
        let replacement: Vec<char> = replacement.chars().collect();
        matcher
            .replace(&replacement)
            .map(|chars| chars.into_iter().collect())
    }

    /// Returns an iterator of the input string tokenized by the regular expression.
    pub fn tokenize<'a>(&'a self, haystack: &str) -> Result<TokenIter<'a>, Error> {
        // if we input the empty string, we should return no tokens
        if haystack.is_empty() {
            return Ok(TokenIter {
                matcher: self.matcher(haystack),
                prev_end: None,
            });
        }
        self.check_matches_empty_string()?;

        Ok(TokenIter {
            matcher: self.matcher(haystack),
            prev_end: Some(0),
        })
    }

    pub(crate) fn matcher(&self, search: &str) -> ReMatcher {
        ReMatcher::new(&self.re_program, search)
    }

    #[cfg(test)]
    pub(crate) fn path(&self, s: &str) -> Operation {
        self.re_program.path(s)
    }

    /// Use this regular expression to analyze an input string, The resulting
    /// vector provides both the matching and non-matching substrings. It also
    /// provides access to matched subgroups.
    pub fn analyze<'a>(&'a self, haystack: &str) -> Result<AnalyzeIter<'a>, Error> {
        self.check_matches_empty_string()?;
        Ok(AnalyzeIter::new(
            &self.re_program.pattern,
            self.matcher(haystack),
        ))
    }

    // TODO: continue translating ARegexIterator
    // this also has an isMatching protocol, and a processMatchingSubstring story
    // and a computeNestingTable story too. Need to read more into how this is
    // actually used. - it seems vastly complicated.
}

#[derive(Debug)]
pub struct TokenIter<'a> {
    matcher: ReMatcher<'a>,
    prev_end: Option<usize>,
}

impl Iterator for TokenIter<'_> {
    type Item = String;

    fn next(&mut self) -> Option<Self::Item> {
        if let Some(prev_end) = self.prev_end {
            if self.matcher.matches(prev_end) {
                let start = self.matcher.get_paren_start(0).unwrap();
                let current = self.matcher.search[prev_end..start].iter().collect();
                self.prev_end = self.matcher.get_paren_end(0);
                Some(current)
            } else {
                let current = self.matcher.search[prev_end..].iter().collect();
                self.prev_end = None;
                Some(current)
            }
        } else {
            None
        }
    }
}