Crate verex

Expand description

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§