simple_regex

Struct RegexBuilder

Source 
pub struct RegexBuilder {
    pub value: String,
}
Expand description

Builder for constructing regular expressions.

Fields§

§value: String

Implementations§

Source§

impl RegexBuilder

Source

pub fn new() -> Self

Creates a new instance of RegexBuilder.

Examples found in repository?
examples/mail_matching.rs (line 4)
3fn main() {
4    let builder: RegexBuilder = RegexBuilder::new().bound_word(
5        RegexBuilder::new()
6            .character_class("A-Za-z0-9._%+-")
7            .literal('@')
8            .character_class("A-Za-z0-9.-")
9            .literal('\\')
10            .dot()
11            .exact_repetitions(RegexBuilder::new().character_class("A-Za-z"), 2)
12    );
13    let regex = builder.to_regex_or_panic();
14    println!("{}", regex.is_match("asasinbro3@gmail.com"));
15    println!("{}", regex.is_match("ABC@gmail.az"));
16}
More examples
Hide additional examples
examples/phone_number.rs (line 5)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn to_regex(&self) -> Result<Regex, Error>

Converts the current RegexBuilder into a Regex object.

§Example
use simple_regex::RegexBuilder;
use regex::Regex;

let regex_builder = RegexBuilder::new().literal('a');
let regex_result = regex_builder.to_regex();

match regex_result {
    Ok(regex) => {
        // Use the regex object
        assert!(regex.is_match("a"));
    }
    Err(e) => {
        // Handle the error if the regex is invalid
        eprintln!("Error creating regex: {}", e);
    }
}
Source

pub fn to_regex_or_panic(&self) -> Regex

Converts the current RegexBuilder into a Regex object or panics if an error occurs.

§Panics

Panics if the regex construction fails.

§Example
use simple_regex::RegexBuilder;
use regex::Regex;

let regex_builder = RegexBuilder::new().literal('a');
let regex = regex_builder.to_regex_or_panic();

// Use the regex object
assert!(regex.is_match("a"));
Examples found in repository?
examples/mail_matching.rs (line 13)
3fn main() {
4    let builder: RegexBuilder = RegexBuilder::new().bound_word(
5        RegexBuilder::new()
6            .character_class("A-Za-z0-9._%+-")
7            .literal('@')
8            .character_class("A-Za-z0-9.-")
9            .literal('\\')
10            .dot()
11            .exact_repetitions(RegexBuilder::new().character_class("A-Za-z"), 2)
12    );
13    let regex = builder.to_regex_or_panic();
14    println!("{}", regex.is_match("asasinbro3@gmail.com"));
15    println!("{}", regex.is_match("ABC@gmail.az"));
16}
More examples
Hide additional examples
examples/phone_number.rs (line 44)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn literal(&mut self, char_: char) -> Self

Appends a literal character to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().literal('a').build();
assert_eq!(regex, "\\a");
Examples found in repository?
examples/mail_matching.rs (line 7)
3fn main() {
4    let builder: RegexBuilder = RegexBuilder::new().bound_word(
5        RegexBuilder::new()
6            .character_class("A-Za-z0-9._%+-")
7            .literal('@')
8            .character_class("A-Za-z0-9.-")
9            .literal('\\')
10            .dot()
11            .exact_repetitions(RegexBuilder::new().character_class("A-Za-z"), 2)
12    );
13    let regex = builder.to_regex_or_panic();
14    println!("{}", regex.is_match("asasinbro3@gmail.com"));
15    println!("{}", regex.is_match("ABC@gmail.az"));
16}
More examples
Hide additional examples
examples/phone_number.rs (line 14)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn string(&mut self, string: &str) -> Self

Appends a string to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().string("word").build();
assert_eq!(regex, "word");
Source

pub fn dot(&mut self) -> Self

Appends a dot (.) to the regular expression, matching any single character.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().dot().build();
assert_eq!(regex, ".");
Examples found in repository?
examples/mail_matching.rs (line 10)
3fn main() {
4    let builder: RegexBuilder = RegexBuilder::new().bound_word(
5        RegexBuilder::new()
6            .character_class("A-Za-z0-9._%+-")
7            .literal('@')
8            .character_class("A-Za-z0-9.-")
9            .literal('\\')
10            .dot()
11            .exact_repetitions(RegexBuilder::new().character_class("A-Za-z"), 2)
12    );
13    let regex = builder.to_regex_or_panic();
14    println!("{}", regex.is_match("asasinbro3@gmail.com"));
15    println!("{}", regex.is_match("ABC@gmail.az"));
16}
Source

pub fn escape(&mut self, char_: char) -> Self

Appends an escaped character to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().escape('[').build();
assert_eq!(regex, "\\[");
Source

pub fn start_of_line(&mut self) -> Self

Appends the start of line anchor (^) to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().start_of_line().build();
assert_eq!(regex, "^");
Examples found in repository?
examples/phone_number.rs (line 6)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn end_of_line(&mut self) -> Self

Appends the end of line anchor ($) to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().end_of_line().build();
assert_eq!(regex, "$");
Examples found in repository?
examples/phone_number.rs (line 42)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn character_class(&mut self, chars: &str) -> Self

Appends a character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().character_class("abc").build();
assert_eq!(regex, "[abc]");
Examples found in repository?
examples/mail_matching.rs (line 6)
3fn main() {
4    let builder: RegexBuilder = RegexBuilder::new().bound_word(
5        RegexBuilder::new()
6            .character_class("A-Za-z0-9._%+-")
7            .literal('@')
8            .character_class("A-Za-z0-9.-")
9            .literal('\\')
10            .dot()
11            .exact_repetitions(RegexBuilder::new().character_class("A-Za-z"), 2)
12    );
13    let regex = builder.to_regex_or_panic();
14    println!("{}", regex.is_match("asasinbro3@gmail.com"));
15    println!("{}", regex.is_match("ABC@gmail.az"));
16}
Source

pub fn negated_character_class(&mut self, chars: &str) -> Self

Appends a negated character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().negated_character_class("abc").build();
assert_eq!(regex, "[^abc]");
Source

pub fn range_character_class(&mut self, start: char, end: char) -> Self

Appends a range character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().range_character_class('a', 'z').build();
assert_eq!(regex, "[a-z]");
Examples found in repository?
examples/phone_number.rs (line 15)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn digit(&mut self) -> Self

Appends a digit character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().digit().build();
assert_eq!(regex, "\\d");
Examples found in repository?
examples/phone_number.rs (line 18)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn non_digit(&mut self) -> Self

Appends a non-digit character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().non_digit().build();
assert_eq!(regex, "\\D");
Source

pub fn word_character(&mut self) -> Self

Appends a word character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().word_character().build();
assert_eq!(regex, "\\w");
Source

pub fn non_word_character(&mut self) -> Self

Appends a non-word character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().non_word_character().build();
assert_eq!(regex, "\\W");
Source

pub fn whitespace(&mut self) -> Self

Appends a whitespace character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().whitespace().build();
assert_eq!(regex, "\\s");
Examples found in repository?
examples/phone_number.rs (line 7)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn non_whitespace(&mut self) -> Self

Appends a non-whitespace character class to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().non_whitespace().build();
assert_eq!(regex, "\\S");
Source

pub fn zero_or_more(&mut self, regex: RegexBuilder) -> Self

Appends a zero or more quantifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .zero_or_more(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "[a]*");
Examples found in repository?
examples/phone_number.rs (line 7)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn one_or_more(&mut self, regex: RegexBuilder) -> Self

Appends a one or more quantifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .one_or_more(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "[a]+");
Source

pub fn zero_or_one(&mut self, regex: RegexBuilder) -> Self

Appends a zero or one quantifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .zero_or_one(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "[a]?");
Examples found in repository?
examples/phone_number.rs (line 14)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn exact_repetitions(&mut self, regex: RegexBuilder, n: usize) -> Self

Appends an exact repetitions quantifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .exact_repetitions(RegexBuilder::new().digit(), 3)
    .build();
assert_eq!(regex, "\\d{3}");
Examples found in repository?
examples/mail_matching.rs (line 11)
3fn main() {
4    let builder: RegexBuilder = RegexBuilder::new().bound_word(
5        RegexBuilder::new()
6            .character_class("A-Za-z0-9._%+-")
7            .literal('@')
8            .character_class("A-Za-z0-9.-")
9            .literal('\\')
10            .dot()
11            .exact_repetitions(RegexBuilder::new().character_class("A-Za-z"), 2)
12    );
13    let regex = builder.to_regex_or_panic();
14    println!("{}", regex.is_match("asasinbro3@gmail.com"));
15    println!("{}", regex.is_match("ABC@gmail.az"));
16}
More examples
Hide additional examples
examples/phone_number.rs (line 15)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn min_repetitions(&mut self, regex: RegexBuilder, n: usize) -> Self

Appends a minimum repetitions quantifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .min_repetitions(RegexBuilder::new().digit(), 3)
    .build();
assert_eq!(regex, "\\d{3,}");
Source

pub fn range_repetitions( &mut self, regex: RegexBuilder, n: usize, m: usize, ) -> Self

Appends a range repetitions quantifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .range_repetitions(RegexBuilder::new().digit(), 3, 5)
    .build();
assert_eq!(regex, "\\d{3,5}");
Source

pub fn group(&mut self, regex: RegexBuilder) -> Self

Appends a group to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .group(RegexBuilder::new().character_class("ab"))
    .build();
assert_eq!(regex, "(?:[ab])");
Examples found in repository?
examples/phone_number.rs (lines 8-24)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn backreference(&mut self, group_number: usize) -> Self

Appends a backreference to a capturing group in the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .capturing_group(RegexBuilder::new().character_class("ab"))
    .backreference(1)
    .build();
assert_eq!(regex, "([ab])\\1");
Source

pub fn word_boundary(&mut self) -> Self

Appends a word boundary anchor (\b) to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().word_boundary().build();
assert_eq!(regex, "\\b");
Source

pub fn non_word_boundary(&mut self) -> Self

Appends a non-word boundary anchor (\B) to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new().non_word_boundary().build();
assert_eq!(regex, "\\B");
Source

pub fn case_insensitive(&mut self, regex: RegexBuilder) -> Self

Appends a case-insensitive modifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .case_insensitive(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?i[a])");

Appends a global search modifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .global_search(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?g[a])");
Source

pub fn multiline(&mut self, regex: RegexBuilder) -> Self

Appends a multiline modifier to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .multiline(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?m[a])");
Source

pub fn dot_all(&mut self, regex: RegexBuilder) -> Self

Appends a dot-all modifier to the regular expression, allowing ‘.’ to match newline characters.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .dot_all(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?s[a])");
Source

pub fn alternative( &mut self, regex1: RegexBuilder, regex2: RegexBuilder, ) -> Self

Appends an alternative (|) to the regular expression, allowing either of the provided patterns to match.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .alternative(RegexBuilder::new().character_class("a"), RegexBuilder::new().character_class("b"))
    .build();
assert_eq!(regex, "[a]|[b]");
Examples found in repository?
examples/phone_number.rs (lines 10-23)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn capturing_group(&mut self, regex: RegexBuilder) -> Self

Appends a capturing group to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .capturing_group(RegexBuilder::new().character_class("ab"))
    .build();
assert_eq!(regex, "([ab])");
Source

pub fn non_capturing_group(&mut self, regex: RegexBuilder) -> Self

Appends a non-capturing group to the regular expression.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .non_capturing_group(RegexBuilder::new().character_class("ab"))
    .build();
assert_eq!(regex, "(?:[ab])");
Source

pub fn bound_word(&mut self, regex: RegexBuilder) -> Self

Appends a word boundary anchor (\b) to the regular expression, asserting the position between a word character and a non-word character.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .bound_word(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "\\b[a]\\b");
Examples found in repository?
examples/mail_matching.rs (lines 4-12)
3fn main() {
4    let builder: RegexBuilder = RegexBuilder::new().bound_word(
5        RegexBuilder::new()
6            .character_class("A-Za-z0-9._%+-")
7            .literal('@')
8            .character_class("A-Za-z0-9.-")
9            .literal('\\')
10            .dot()
11            .exact_repetitions(RegexBuilder::new().character_class("A-Za-z"), 2)
12    );
13    let regex = builder.to_regex_or_panic();
14    println!("{}", regex.is_match("asasinbro3@gmail.com"));
15    println!("{}", regex.is_match("ABC@gmail.az"));
16}
Source

pub fn negative_word_boundary(&mut self, regex: RegexBuilder) -> Self

Appends a negative word boundary anchor (\B) to the regular expression, asserting a position where a word character is not followed by another word character.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .negative_word_boundary(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "\\B[a]\\B");
Source

pub fn positive_lookahead(&mut self, regex: RegexBuilder) -> Self

Appends a positive lookahead assertion to the regular expression, asserting that the given pattern can match next at the current position.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .positive_lookahead(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?=[a])");
Source

pub fn negative_lookahead(&mut self, regex: RegexBuilder) -> Self

Appends a negative lookahead assertion to the regular expression, asserting that the given pattern cannot match next at the current position.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .negative_lookahead(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?![a])");
Source

pub fn positive_lookbehind(&mut self, regex: RegexBuilder) -> Self

Appends a positive lookbehind assertion to the regular expression, asserting that the given pattern can match preceding at the current position.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .positive_lookbehind(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?<=a)");
Source

pub fn negative_lookbehind(&mut self, regex: RegexBuilder) -> Self

Appends a negative lookbehind assertion to the regular expression, asserting that the given pattern cannot match preceding at the current position.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .negative_lookbehind(RegexBuilder::new().character_class("a"))
    .build();
assert_eq!(regex, "(?<!a)");
Source

pub fn optional(&mut self, regex: RegexBuilder) -> Self

Appends an optional pattern to the regular expression, allowing the given pattern to match zero or one time.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .optional(RegexBuilder::new().literal('a'))
    .build();
assert_eq!(regex, "(a)?");
Source

pub fn dash_space_character_class(&mut self) -> Self

Appends to the regular expression the character class [-\s].

§Example
use my_regex_builder::RegexBuilder;

let regex = RegexBuilder::new()
    .literal('-')
    .dash_space_character_class()
    .literal('a')
    .build();
assert_eq!(regex, "-[-\\s]a");
Examples found in repository?
examples/phone_number.rs (line 31)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}
Source

pub fn build(&self) -> String

Builds the regular expression as a string.

§Example
use simple_regex::RegexBuilder;

let regex = RegexBuilder::new()
    .literal('a')
    .character_class("bc")
    .zero_or_more(RegexBuilder::new().digit())
    .build();
assert_eq!(regex, "a[bc]*\\d*");
Examples found in repository?
examples/phone_number.rs (line 45)
3fn main() {
4    // \s*(?:\+?[0-9]{10}|\(\d{3}\)|\d{3})(?:[-\s]?\d{3}[-\s]?\d{4})?\s*$
5    let builder =  RegexBuilder::new()
6    .start_of_line()
7    .zero_or_more(RegexBuilder::new().whitespace())
8    .group(
9        RegexBuilder::new()
10            .alternative(
11                RegexBuilder::new()
12                    .alternative(
13                        RegexBuilder::new()
14                            .zero_or_one(RegexBuilder::new().literal('+'))
15                            .exact_repetitions(RegexBuilder::new().range_character_class('0', '9'), 10),
16                        RegexBuilder::new()
17                            .literal('(')
18                            .exact_repetitions(RegexBuilder::new().digit(), 3)
19                            .literal(')'),
20                ),
21                RegexBuilder::new().exact_repetitions(RegexBuilder::new().digit(), 3)
22
23            )
24    )
25    .zero_or_one(
26        RegexBuilder::new()
27            .group(
28                RegexBuilder::new()
29                    .zero_or_one(
30                        RegexBuilder::new()
31                            .dash_space_character_class()
32                    )
33                    .exact_repetitions(RegexBuilder::new().digit(), 3)
34                    .zero_or_one(
35                        RegexBuilder::new()
36                            .dash_space_character_class()
37                    )
38                    .exact_repetitions(RegexBuilder::new().digit(), 4)
39            )
40    )
41    .zero_or_more(RegexBuilder::new().whitespace())
42    .end_of_line();
43
44    let regex_ = builder.to_regex_or_panic();
45    println!("{}", builder.build());
46    println!("{}", ansi::fg_green(
47        format!(
48            "{}", regex_.is_match("1234567890")
49        )
50    ));
51    println!("{}", ansi::fg_green(
52        format!(
53            "{}", regex_.is_match("(123) 456-7890")
54        )
55    ));
56    println!("{}", ansi::fg_green(
57        format!(
58            "{}", regex_.is_match("123-456-7890")
59        )
60    ));
61    println!("{}", ansi::fg_green(
62        format!(
63            "{}", regex_.is_match("123 456 7890")
64        )
65    ));
66    println!("{}", ansi::fg_green(
67        format!(
68            "{}", regex_.is_match("1234567890")
69        )
70    ));
71}

Trait Implementations§

Source§

impl Clone for RegexBuilder

Source§

fn clone(&self) -> RegexBuilder

Returns a copy of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.