Crate verex [] [src]

This crate provides a Rust implementation of VerbalExpressions in order to build regex strings without knowing the minutiae of regex syntax.

It uses the Regex crate to compile the created regex strings.

Examples

A simple example to show the usage:

use verex::Verex;
use verex::find;

    // You can either use a mutable Verex to define different regexes
    let mut verex = Verex::new();
    let regex1 = verex.find("a")
                      .compile()
                      .unwrap();

    let regex2 = verex.or_find("b")
                      .compile()
                      .unwrap();

    // Or just use it for building one (you can use the funcitons directly as constructors)
    let regex3 = find("a") // or: Verex::new().find("a")
                 .or_find("b")
                 .compile()
                 .unwrap();

    // Test whether the regexes match correctly
    assert!(!regex1.is_match("b"));
    assert!(regex2.is_match("b"));
    assert!(regex3.is_match("b"));

    // Test the generated regex strings
    assert_eq!(regex1.as_str(), r"(?:(?:a))");
    assert_eq!(regex2.as_str(), r"(?:(?:a)|(?:b))");
    assert_eq!(regex3.as_str(), r"(?:(?:a)|(?:b))");

Here's a URL testing example shamelessly stolen from the python Verex readme:

use verex::start_of_line;

    // Create an example of how to test for correctly formed URLs
    let verex = start_of_line()
                .find("http")
                .maybe("s")
                .find("://")
                .maybe("www.")
                .anything_but(" ")
                .end_of_line()
                .clone();
    let regex = verex.compile().unwrap();

    // Create an example URL
    let test_url = r"https://www.google.com";

    // Test if the URL is valid
    assert!(regex.is_match(test_url));

    // Test the generated regex string
    assert_eq!(verex.source(), r"(?:^(?:http)(?:s)?(?:://)(?:www\.)?(?:[^ ]*)$)");

Example usage of the or! macro:

#[macro_use(or)]
extern crate verex;

    let regex = or!("foo", "bar", "baz")
                .compile()
                .unwrap();

    // Test if the regex matches correctly
    assert!(regex.is_match("foo"));
    assert!(regex.is_match("bar"));
    assert!(regex.is_match("baz"));
    assert!(!regex.is_match("bum"));

    // Test the generated regex string
    assert_eq!(regex.as_str(), r"(?:(?:foo)|(?:bar)|(?:baz))");

Example usage of the or_expr! macro:

#[macro_use(or_expr)]
extern crate verex;
extern crate regex;
use verex::Expression as E;
use verex::Verex;
use regex::Regex;

    let sub_verex = Verex::from_str("Darth(Vader)*?");
    let sub_regex = Regex::new("(?P<robot>C3PO)").unwrap();
    let regex = or_expr!(
                    E::String("([RD]2){2}"),
                    E::Verex(&sub_verex),
                    E::Regex(&sub_regex))
                .compile()
                .unwrap();

    // Test if the regex matches correctly
    assert!(regex.is_match("R2D2"));
    assert!(regex.is_match("Darth"));
    assert!(regex.is_match("C3PO"));
    assert!(!regex.is_match("Anakin"));

    // Test the generated regex string
    assert_eq!(regex.as_str(), r"(?:(?:([RD]2){2})|(?:(?:Darth(Vader)*?))|(?:(?P<robot>C3PO)))");

Macros

or!

Match any of the given values

or_expr!

Match any of the given sub-expressions

Structs

Verex

The struct used for building verbal expression objects

Enums

Expression

The enum used to have common functions for different Types

Functions

any

Any of the given characters

any_of

See any()

anything

Any character zero or more times

anything_but

Any character zero or more times except the provided characters

br

A line break!

capture

Find a specific string and capture it (will get escaped)

capture_expr

Find an expression and capture it

digit

Add the token for matching digits

end_of_line

Add a token for the end of a line

find

Find a specific string

find_expr

Find an expression

line_break

A line break!

maybe

Any string either one or zero times

maybe_expr

Any string either one or zero times

range

A range of characters e.g. [A-Z] Usage example: verex.range(vec![('a', 'z'),('A', 'Z')])

search_one_line

Toggle whether ^ and $ match line start and end or string start and end

something

Any character at least one time

something_but

Any character at least one time except for these characters

start_of_line

Add a token for the start of a line

tab

Add a token for a tab

with_any_case

Toggle whether to match case-sensitively or not

word

Any alphanumeric characters