Enum generator_combinator::Generator

pub enum Generator {
    AlphaLower,
    AlphaUpper,
    Digit,
    AlphaNumLower,
    AlphaNumUpper,
    HexUpper,
    HexLower,
    Char(char),
    Str(String),
    OneOf {
        v: Vec<Generator>,
        is_optional: bool,
    },
    RepeatedN(Box<Generator>, usize),
    RepeatedMN(Box<Generator>, usize, usize),
    Sequence(Vec<Generator>),
    Transform {
        inner: Box<Generator>,
        transform_fn: TransformFn,
    },
}

The building block of generator-combinators.

A Generator can be constructed from strings, chars, and slices:

use generator_combinator::Generator;
let foo = Generator::from("foo"); // generates the string `foo`
let dot = Generator::from('.'); // generates the string `.`
let countries = Generator::from(&["US", "FR", "NZ", "CH"][..]); // generates strings `US`, `FR`, `NZ`, and `CH`.

Individual Generators can be combined as sequences with +, as variants with |, and with repetition with * usize and * (usize, usize):

use generator_combinator::Generator;
let foo = Generator::from("foo");
let bar = Generator::from("bar");
let foobar = foo.clone() + bar.clone(); // generates `foobar`
let foo_or_bar = foo.clone() | bar.clone(); // generates `foo`, `bar`
let foo_or_bar_x2 = foo_or_bar.clone() * 2; // generates `foofoo`, `foobar`, `barfoo`, `barbar`
let foo_x2_to_x4 = foo.clone() * (2, 4); // generates `foofoo`, `foofoofoo`, `foofoofoofoo`

Variants

AlphaLower

Lowercase letters (a-z)

AlphaUpper

Uppercase letters (A-Z)

Digit

Base-10 digits (0-9)

AlphaNumLower

Lowercase letters and digits (a-z0-9)

AlphaNumUpper

Uppercase letters and digits (A-Z0-9)

HexUpper

Uppercase hexadecimal values (0-9A-F)

HexLower

Lowercase hexadecimal values (0-9a-f)

Char(char)

Generates a char literal.

Str(String)

Generates a String literal.

Note that this is not a character class. Str("foo".into()) generates the exact string "foo"

OneOf

A choice between two or more patterns

As a regex, this would be, eg, (a|b|c)? (depending on is_optional)

Fields of OneOf

v: Vec<Generator>is_optional: bool

RepeatedN(Box<Generator>, usize)

A pattern repeated exactly n times. This is the same as RepeatedMN(a, n, n)

As a regex, this would be a{n}

RepeatedMN(Box<Generator>, usize, usize)

A pattern repeated at least m times, as many as n times.

As a regex, this would be a{m,n}

Sequence(Vec<Generator>)

Two or more sequential patterns.

As a regex, this would be, eg, abc

Transform

Wrap the current generator in a user-defined transformation.

Fields of Transform

inner: Box<Generator>transform_fn: TransformFn

Implementations

impl Generator

pub fn regex(&self) -> String

Create a regular expression that represents the patterns generated.

The result here is currently best-guess. It’s not guaranteed valid, correct, idiomatic, etc.

pub fn len(&self) -> u128

The number of possible patterns represented.

pub fn generate_one(&self, num: u128) -> String

Generates the String encoded by the specified num.

Panics if num exceeds the length given by Generator::len

pub fn optional(self) -> Self

Makes this Generator optional.

As a regex, this is the ? operator.

pub fn generate_all(&self) -> StringIter<'_>

Provides an iterator across all possible values for this Generator.

pub fn transform(self, f: fn(_: String) -> String) -> Self

Includes a user-defined transformation when generating values.

pub fn visit_one<F>(&self, num: u128, cb: F) where
    F: FnMut(&str), 

For a value specified by num, applies the callback cb for each of the component values for this Generator.

This may be preferable to [generate_one] if you want to see the individual components comprising the final string and/or if you want to avoid the memory allocation and freeing by creating the values.

Trait Implementations

impl Add<Generator> for Generator

Add operator for exact repetitions.

The following expressions are equivalent:

use generator_combinator::Generator;
let foostr = Generator::from("foofoo");
let foomul = Generator::from("foo") * 2;
let fooadd = Generator::from("foo") + Generator::from("foo");

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AddAssign<Generator> for Generator

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl BitOr<Generator> for Generator

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign<Generator> for Generator

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for Generator

fn clone(&self) -> Generator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Generator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> From<&'_ [T]> for Generator where
    T: AsRef<str> + Display, 

fn from(values: &[T]) -> Self

Performs the conversion.

impl From<&'_ str> for Generator

fn from(s: &str) -> Self

Performs the conversion.

impl<'a> From<&'a Generator> for StringIter<'a>

fn from(c: &'a Generator) -> Self

Performs the conversion.

impl From<char> for Generator

fn from(c: char) -> Self

Performs the conversion.

impl Mul<(usize, usize)> for Generator

Mul operator for repetitions between m and n (inclusive)

use generator_combinator::Generator;
let foo_two_to_five_times = Generator::from("foo") * (2,5);

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: (usize, usize)) -> Self::Output

Performs the * operation.

impl Mul<usize> for Generator

Mul operator for exact repetitions.

The following expressions are equivalent:

use generator_combinator::Generator;
let foostr = Generator::from("foofoo");
let foomul = Generator::from("foo") * 2;
let fooadd = Generator::from("foo") + Generator::from("foo");

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl MulAssign<(usize, usize)> for Generator

fn mul_assign(&mut self, rhs: (usize, usize))

Performs the *= operation.

impl MulAssign<usize> for Generator

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl PartialEq<Generator> for Generator

fn eq(&self, other: &Generator) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Generator) -> bool

This method tests for !=.

impl StructuralPartialEq for Generator