Struct LiteralParser 

pub struct LiteralParser<'a, 'b> { /* private fields */ }

Regular expression parser for /literal/ usage.

• pattern_text: the text between / and /
• flags_text: the text after the second /

Implementations

impl<'a, 'b> LiteralParser<'a, 'b>

pub fn new( allocator: &'a Allocator, pattern_text: &'a str, flags_text: Option<&'b str>, options: Options, ) -> Self

Examples found in repository

examples/regex_visitor.rs (line 38)

fn main() {
    let source_text = r"(https?:\/\/github\.com\/(([^\s]+)\/([^\s]+))\/([^\s]+\/)?(issues|pull)\/([0-9]+))|(([^\s]+)\/([^\s]+))?#([1-9][0-9]*)($|[\s\:\;\-\(\=])";

    let allocator = Allocator::default();
    let parser = LiteralParser::new(&allocator, source_text, None, Options::default());
    let pattern = parser.parse().unwrap();

    // Visit the regex AST and log each node
    let mut visitor = TestVisitor;
    visitor.visit_pattern(&pattern);
}

examples/parse_literal.rs (lines 57-63)

fn main() {
    let allocator = Allocator::default();

    for (pattern_text, flags_text) in [
        (r"ab", ""),
        (r"abc", "i"),
        (r"abcd", "igv"),
        (r"emo👈🏻ji", "u"),
        (r"ab|c", "i"),
        (r"a|b+|c", "i"),
        (r"a{0}|b{1,2}|c{3,}", "i"),
        (r"(?=a)|(?<=b)|(?!c)|(?<!d)", "i"),
        (r"\n\cM\0\x41\.", ""),
        (r"\n\cM\0\x41\u1234\.", "u"),
        (r"\n\cM\0\x41\u{1f600}\.", "u"),
        (r"a\k<f>x\1c", "u"),
        (r"(cg)(?<n>cg)(?:g)", ""),
        (r"{3}", ""), // Error
        (r"Em🥹j", ""),
        (r"^(?=ab)\b(?!cd)(?<=ef)\B(?<!gh)$", ""),
        (r"^(?<!ab)$", ""),
        (r"a)", ""), // Error
        (r"c]", ""),
        (r"[abc]", ""),
        (r"[|\]]", ""),
        (r"[a&&b]", "v"),
        (r"[a--b]", "v"),
        (r"[a&&&]", "v"), // Error
        (r"[a---]", "v"), // Error
        (r"[^a--b--c]", "v"),
        (r"[a[b[c[d[e[f[g[h[i[j[k[l]]]]]]]]]]]]", "v"),
        (r"[\q{abc|d|e|}]", "v"),
        (r"\p{Basic_Emoji}", "v"),
        (r"\p{Basic_Emoji}", "u"), // Error
        (r"[[^\q{}]]", "v"),       // Error
        (r"(?<a>)(?<a>)", ""),     // Error
        (r"(?noname)", "v"),       // Error
        (r"[\bb]", ""),
        (r"a{2,1}", "v"), // Error
    ] {
        let parser = LiteralParser::new(
            &allocator,
            pattern_text,
            Some(flags_text),
            // +1 for added `/` in error reports
            Options { pattern_span_offset: 1, ..Options::default() },
        );
        let ret = parser.parse();

        let literal = format!("/{pattern_text}/{flags_text}");
        println!("Parse: {literal}");
        match ret {
            Ok(pattern) => {
                println!("✨ {pattern:#?}");
            }
            Err(error) => {
                let error = error.with_source_code(literal);
                println!("💥 {error:?}");
            }
        }
        println!();
    }
}

pub fn parse(self) -> Result<Pattern<'a>>

Examples found in repository

examples/regex_visitor.rs (line 39)

fn main() {
    let source_text = r"(https?:\/\/github\.com\/(([^\s]+)\/([^\s]+))\/([^\s]+\/)?(issues|pull)\/([0-9]+))|(([^\s]+)\/([^\s]+))?#([1-9][0-9]*)($|[\s\:\;\-\(\=])";

    let allocator = Allocator::default();
    let parser = LiteralParser::new(&allocator, source_text, None, Options::default());
    let pattern = parser.parse().unwrap();

    // Visit the regex AST and log each node
    let mut visitor = TestVisitor;
    visitor.visit_pattern(&pattern);
}

examples/parse_literal.rs (line 64)

fn main() {
    let allocator = Allocator::default();

    for (pattern_text, flags_text) in [
        (r"ab", ""),
        (r"abc", "i"),
        (r"abcd", "igv"),
        (r"emo👈🏻ji", "u"),
        (r"ab|c", "i"),
        (r"a|b+|c", "i"),
        (r"a{0}|b{1,2}|c{3,}", "i"),
        (r"(?=a)|(?<=b)|(?!c)|(?<!d)", "i"),
        (r"\n\cM\0\x41\.", ""),
        (r"\n\cM\0\x41\u1234\.", "u"),
        (r"\n\cM\0\x41\u{1f600}\.", "u"),
        (r"a\k<f>x\1c", "u"),
        (r"(cg)(?<n>cg)(?:g)", ""),
        (r"{3}", ""), // Error
        (r"Em🥹j", ""),
        (r"^(?=ab)\b(?!cd)(?<=ef)\B(?<!gh)$", ""),
        (r"^(?<!ab)$", ""),
        (r"a)", ""), // Error
        (r"c]", ""),
        (r"[abc]", ""),
        (r"[|\]]", ""),
        (r"[a&&b]", "v"),
        (r"[a--b]", "v"),
        (r"[a&&&]", "v"), // Error
        (r"[a---]", "v"), // Error
        (r"[^a--b--c]", "v"),
        (r"[a[b[c[d[e[f[g[h[i[j[k[l]]]]]]]]]]]]", "v"),
        (r"[\q{abc|d|e|}]", "v"),
        (r"\p{Basic_Emoji}", "v"),
        (r"\p{Basic_Emoji}", "u"), // Error
        (r"[[^\q{}]]", "v"),       // Error
        (r"(?<a>)(?<a>)", ""),     // Error
        (r"(?noname)", "v"),       // Error
        (r"[\bb]", ""),
        (r"a{2,1}", "v"), // Error
    ] {
        let parser = LiteralParser::new(
            &allocator,
            pattern_text,
            Some(flags_text),
            // +1 for added `/` in error reports
            Options { pattern_span_offset: 1, ..Options::default() },
        );
        let ret = parser.parse();

        let literal = format!("/{pattern_text}/{flags_text}");
        println!("Parse: {literal}");
        match ret {
            Ok(pattern) => {
                println!("✨ {pattern:#?}");
            }
            Err(error) => {
                let error = error.with_source_code(literal);
                println!("💥 {error:?}");
            }
        }
        println!();
    }
}