Crate readable_regex

Source
Expand description

§Regex for human beings.

Regex is useful. But, sincerely, since code it is more read than written regex could be more understandable in a verbose mode.

readable-regex crate is a set of tools to build those regexes in a verbose way. Which aims to improve readability of code.

§Available APIs

The main wrapper is the ReadableRe enum.

There are tow main options to build regexes with it, either using the enum itself:

use readable_regex::ReadableRe;
let query = ReadableRe::Raw("<some regex expression>");

or by using the functions wrappers around it:

use readable_regex::raw_regex;
let query = raw_regex("<some regex expression>");

Also, any combination of them:

use readable_regex::{digit, group};
use readable_regex::ReadableRe::*;
let query = group(digit() + Digit + digit());
println!("{}", query.to_string());

§Examples

How to build a simple date match (as implemented in the datetime module under presets feature):

use once_cell::sync::Lazy;
use readable_regex::*;
use readable_regex::ReadableRe::*;

/// Month day, `01`-`31`
pub const DAY: Lazy<ReadableRe> = Lazy::new(|| {
    either([
        Raw("0") + chars("1-9"),
        chars("12") + chars("1-9"),
        Raw("3") + chars("01"),
    ])
});

/// Month numeral, `01`-`12`
pub const MONTH: Lazy<ReadableRe> =
    Lazy::new(|| either([Raw("0") + chars("1-9"), Raw("1") + chars("0-2")]));

/// Years from `1000` to `2999`
pub const YEAR: Lazy<ReadableRe> = Lazy::new(|| chars("12") + exactly(3, Digit));

/// Date Format `YYYY-MM-dd`
pub const DATE_Y_M_D: Lazy<ReadableRe> = Lazy::new(|| {
    group(
        group(YEAR.clone())
            + chars(r"-/.\\")
            + group(MONTH.clone())
            + chars(r"-/.\\")
            + group(DAY.clone()),
    )
});

assert!(DATE_Y_M_D.compile().unwrap().is_match("2022/04/18"));

§Features

  • re => Use regex crate backend.
  • re-fancy => Use [fancy_regex] crate backend and expands this crate functionality.

Re-exports§

pub use readable::ReadableRe;

Modules§

readable
solvers

Functions§

any_char
anything
ascii_alphanumeric
ascii_letter
ascii_lowercase
ascii_non_alphanumeric
ascii_non_letter
ascii_non_lowercase
ascii_non_numeric
ascii_non_uppercase
ascii_numeric
ascii_uppercase
asterisk
at_least
at_most
back_slash
boundary
caret
chars
close_brace
close_bracket
close_parenthesis
concat
digit
dollar
double_quote
either
ends_with
escape
escape_str
everything
exactly
group
hexadecimal
minus_sign
named_group
new_line
non_capture_group
non_digit
non_hexadecimal
non_whitespace
non_word
not_chars
one_or_more
one_or_more_lazy
open_brace
open_bracket
open_parenthesis
optional
period
pipe
plus_sign
question_mark
quote
ranged
raw_regex
something
something_greedy
starts_and_ends_with
starts_with
string_regex
tab
whitespace
word
zero_or_more
zero_or_more_lazy