rexplode 1.0.1

Generate strings from the given regular expression
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use regex_syntax::ast::*;

pub trait ToString {
  fn to_string(&self) -> String;
}

impl ToString for Literal {
  fn to_string(&self) -> String {
    self.c.to_string()
  }
}

impl ToString for ClassAscii {
  fn to_string(&self) -> String {
    use ClassAsciiKind::*;

    format!(
      "[:{}{}:]",
      if self.negated { "^" } else { "" },
      match &self.kind {
        Alnum => "alnum",
        Alpha => "alpha",
        Ascii => "ascii",
        Blank => "blank",
        Cntrl => "cntrl",
        Digit => "digit",
        Graph => "graph",
        Lower => "lower",
        Print => "print",
        Punct => "punct",
        Space => "space",
        Upper => "upper",
        Word => "word",
        Xdigit => "xdigit",
      }
    )
  }
}

impl ToString for ClassUnicode {
  fn to_string(&self) -> String {
    use ClassUnicodeKind::*;
    use ClassUnicodeOpKind::*;

    format!(
      r"\{}{}",
      if self.negated { 'P' } else { 'p' },
      match &self.kind {
        OneLetter(letter) => letter.to_string(),
        Named(name) => format!("{{{}}}", name),
        NamedValue { op: Equal, name, value } => format!("{{{}={}}}", name, value),
        NamedValue { op: Colon, name, value } => format!("{{{}:{}}}", name, value),
        NamedValue {
          op: NotEqual,
          name,
          value,
        } => format!("{{{}!={}}}", name, value),
      }
    )
  }
}

impl ToString for ClassPerl {
  fn to_string(&self) -> String {
    use ClassPerlKind::*;

    format!(
      r"\{}",
      match &self.kind {
        Digit if self.negated => 'D',
        Digit => 'd',
        Space if self.negated => 'S',
        Space => 's',
        Word if self.negated => 'W',
        Word => 'w',
      }
    )
  }
}

impl ToString for ClassBracketed {
  fn to_string(&self) -> String {
    format!("[{}{}]", if self.negated { "^" } else { "" }, self.kind.to_string(),)
  }
}

impl ToString for ClassSet {
  fn to_string(&self) -> String {
    use ClassSet::*;

    match &self {
      Item(item) => item.to_string(),
      BinaryOp(op) => op.to_string(),
    }
  }
}

impl ToString for ClassSetItem {
  fn to_string(&self) -> String {
    use ClassSetItem::*;

    match self {
      Empty(_) => "".to_string(),
      Literal(literal) => literal.to_string(),
      Range(range) => range.to_string(),
      Ascii(ascii) => ascii.to_string(),
      Unicode(unicode) => unicode.to_string(),
      Perl(perl) => perl.to_string(),
      Bracketed(bracketed) => bracketed.to_string(),
      Union(union) => union.to_string(),
    }
  }
}

impl ToString for ClassSetRange {
  fn to_string(&self) -> String {
    format!("{}-{}", self.start.to_string(), self.end.to_string())
  }
}

impl ToString for ClassSetUnion {
  fn to_string(&self) -> String {
    self.items.iter().map(ToString::to_string).collect()
  }
}

impl ToString for ClassSetBinaryOp {
  fn to_string(&self) -> String {
    use ClassSetBinaryOpKind::*;

    match &self.kind {
      Intersection => format!("{}&&{}", self.lhs.to_string(), self.rhs.to_string()),
      Difference => format!("{}--{}", self.lhs.to_string(), self.rhs.to_string()),
      SymmetricDifference => format!("{}~~{}", self.lhs.to_string(), self.rhs.to_string()),
    }
  }
}