Use whitespace converter class & rename variable

IvenBach · IvenBach · commit f7b12e0a428c · 2019-07-11T16:08:32.000-07:00
Got excited when renamed variable came to mind and crossed the streams.
diff --git a/Rubberduck.Core/UI/RegexAssistant/RegexAssistant.xaml b/Rubberduck.Core/UI/RegexAssistant/RegexAssistant.xaml
@@ -80,7 +80,7 @@
                                 IsChecked="{Binding IgnoreCaseFlag}"
                                 Margin="0,0,5,0"/>
                     <CheckBox Content="{Resx ResxName=Rubberduck.Resources.RubberduckUI, Key=RegexAssistant_EncloseWhitespaceFlag}"
-                              IsChecked="{Binding SurroundWhitespaceCharWithIdentifier}"
+                              IsChecked="{Binding SpellOutWhiteSpace}"
                               Margin="0,0,5,0" />
 
                 </StackPanel>
diff --git a/Rubberduck.Core/UI/RegexAssistant/RegexAssistantViewModel.cs b/Rubberduck.Core/UI/RegexAssistant/RegexAssistantViewModel.cs
@@ -47,20 +47,20 @@ public string Pattern
             }
         }
 
-        public bool SurroundWhitespaceCharWithIdentifier
+        public bool SpellOutWhiteSpace
         {
-            get => _surroundWhitespaceCharWithIdentifier;
+            get => _spellOutWhiteSpace;
             set
             {
-                _surroundWhitespaceCharWithIdentifier = value;
+                _spellOutWhiteSpace = value;
                 RecalculateDescription();
             }
         }
 
         private bool _globalFlag;
         private bool _ignoreCaseFlag;
         private string _pattern;
-        private bool _surroundWhitespaceCharWithIdentifier;
+        private bool _spellOutWhiteSpace;
 
         private List<TreeViewItem> _resultItems;
         public List<TreeViewItem> ResultItems
@@ -89,7 +89,7 @@ private void RecalculateDescription()
                 ResultItems = results;
                 return;
             }
-            ResultItems = ToTreeViewItems(new Pattern(_pattern, _ignoreCaseFlag, _globalFlag, _surroundWhitespaceCharWithIdentifier));
+            ResultItems = ToTreeViewItems(new Pattern(_pattern, _ignoreCaseFlag, _globalFlag, _spellOutWhiteSpace));
         }
 
         private List<TreeViewItem> ToTreeViewItems(Pattern pattern)
diff --git a/Rubberduck.RegexAssistant/Atoms/CharacterClass.cs b/Rubberduck.RegexAssistant/Atoms/CharacterClass.cs
@@ -12,7 +12,7 @@ internal class CharacterClass : IAtom
         public bool InverseMatching { get; }
         public IList<string> CharacterSpecifiers { get; }
 
-        public CharacterClass(string specifier, Quantifier quantifier, bool surroundWhitespaceCharWithIdentifier = false)
+        public CharacterClass(string specifier, Quantifier quantifier, bool spellOutWhiteSpace = false)
         {
             if (specifier == null || quantifier == null)
             {
@@ -28,17 +28,17 @@ public CharacterClass(string specifier, Quantifier quantifier, bool surroundWhit
             // trim leading and closing bracket
             var actualSpecifier = specifier.Substring(1, specifier.Length - 2);
             InverseMatching = actualSpecifier.StartsWith("^");
-            CharacterSpecifiers= ExtractCharacterSpecifiers(InverseMatching ? actualSpecifier.Substring(1) : actualSpecifier,
-                surroundWhitespaceCharWithIdentifier);
+            CharacterSpecifiers = ExtractCharacterSpecifiers(InverseMatching ? actualSpecifier.Substring(1) : actualSpecifier,
+                spellOutWhiteSpace);
         }
 
         public string Specifier { get; }
 
         public Quantifier Quantifier { get; }
 
         private static readonly Regex CharacterRanges = new Regex(@"(\\[dDwWsS]|(\\[ntfvr]|\\([0-7]{3}|x[\dA-F]{2}|u[\dA-F]{4}|[\\\.\[\]])|.)(-(\\[ntfvr]|\\([0-7]{3}|x[A-F]{2}|u[\dA-F]{4}|[\.\\\[\]])|.))?)", RegexOptions.Compiled);
-        private static readonly Regex whitespace = new Regex("\\s");
-        private IList<string> ExtractCharacterSpecifiers(string characterClass, bool surroundWhitespaceCharWithIdentifier)
+        
+        private IList<string> ExtractCharacterSpecifiers(string characterClass, bool spellOutWhitespace)
         {
             var specifiers = CharacterRanges.Matches(characterClass);
             var result = new List<string>();
@@ -59,9 +59,15 @@ private IList<string> ExtractCharacterSpecifiers(string characterClass, bool sur
                     }
                 }
 
-                result.Add(whitespace.IsMatch(specifier.Value) && surroundWhitespaceCharWithIdentifier
-                    ? string.Format(RubberduckUI.RegexAssistant_EncloseWhitespace_EnclosingFormat, specifier.Value)
-                    : specifier.Value);
+                if (spellOutWhitespace 
+                    && WhitespaceToString.IsFullySpellingOutApplicable(specifier.Value, out var spelledOutWhiteSpace))
+                {
+                    result.Add(spelledOutWhiteSpace);
+                }
+                else
+                {
+                    result.Add(specifier.Value);
+                }
             }
             return result;
         }
diff --git a/Rubberduck.RegexAssistant/Atoms/Group.cs b/Rubberduck.RegexAssistant/Atoms/Group.cs
@@ -8,7 +8,7 @@ namespace Rubberduck.RegexAssistant.Atoms
 {
     public class Group : IAtom
     {
-        public Group(IRegularExpression expression, string specifier, Quantifier quantifier) {
+        public Group(IRegularExpression expression, string specifier, Quantifier quantifier, bool spellOutWhiteSpace = false) {
             if (expression == null || quantifier == null)
             {
                 throw new ArgumentNullException();
@@ -17,6 +17,7 @@ public Group(IRegularExpression expression, string specifier, Quantifier quantif
             Quantifier = quantifier;
             Subexpression = expression;
             Specifier = specifier;
+            _spellOutWhiteSpace = spellOutWhiteSpace;
         }
 
         public IRegularExpression Subexpression { get; }
@@ -25,7 +26,12 @@ public Group(IRegularExpression expression, string specifier, Quantifier quantif
 
         public string Specifier { get; }
 
-        public string Description => string.Format(AssistantResources.AtomDescription_Group, Specifier);
+        private readonly bool _spellOutWhiteSpace;
+
+        public string Description => string.Format(AssistantResources.AtomDescription_Group, 
+            _spellOutWhiteSpace && WhitespaceToString.IsFullySpellingOutApplicable(Specifier, out var spelledOutWhiteSpace)
+                ? spelledOutWhiteSpace
+                : Specifier);
 
 
         public override string ToString() => Specifier;
diff --git a/Rubberduck.RegexAssistant/Atoms/Literal.cs b/Rubberduck.RegexAssistant/Atoms/Literal.cs
@@ -11,6 +11,7 @@ internal class Literal : IAtom
         public static readonly string Pattern = @"(?<expression>\\(u[\dA-F]{4}|x[\dA-F]{2}|[0-7]{3}|[bB\(\){}\\\[\]\.+*?1-9nftvrdDwWsS])|[^()\[\]{}\\*+?^$])";
         private static readonly Regex Matcher = new Regex($"^{Pattern}$", RegexOptions.Compiled);
         private static readonly ISet<char> EscapeLiterals = new HashSet<char>();
+        private readonly bool _surroundWhitespaceCharWithIdentifier;
 
         static Literal() {
             foreach (var escape in new[]{ '.', '+', '*', '?', '(', ')', '{', '}', '[', ']', '|', '\\' })
@@ -32,7 +33,7 @@ static Literal() {
             _escapeDescriptions.Add('t', AssistantResources.AtomDescription_HTab);
         }
 
-        public Literal(string specifier, Quantifier quantifier)
+        public Literal(string specifier, Quantifier quantifier, bool spellOutWhitespace = false)
         {
             if (specifier == null || quantifier == null)
             {
@@ -45,6 +46,8 @@ public Literal(string specifier, Quantifier quantifier)
             {
                 throw new ArgumentException("The given specifier does not denote a Literal");
             }
+
+            _surroundWhitespaceCharWithIdentifier = spellOutWhitespace;
             Specifier = specifier;
         }
 
@@ -95,9 +98,15 @@ public string Description
                     }
                 }
 
-                return Specifier.Equals(".") 
-                    ? AssistantResources.AtomDescription_Dot 
-                    : string.Format(AssistantResources.AtomDescription_Literal_ActualLiteral, Specifier);
+                if (Specifier.Equals("."))
+                {
+                    return AssistantResources.AtomDescription_Dot;
+                }
+
+                return string.Format(AssistantResources.AtomDescription_Literal_ActualLiteral, 
+                    _surroundWhitespaceCharWithIdentifier && WhitespaceToString.IsFullySpellingOutApplicable(Specifier, out var spelledOutWhiteSpace)
+                        ? spelledOutWhiteSpace
+                        : Specifier);
             }
         }
 
diff --git a/Rubberduck.RegexAssistant/Pattern.cs b/Rubberduck.RegexAssistant/Pattern.cs
@@ -10,7 +10,7 @@ public class Pattern : IDescribable
 
         public string Description { get; }
 
-        public Pattern(string expression, bool ignoreCase = false, bool global = false, bool surroundWhitespaceCharWithIdentifier = false)
+        public Pattern(string expression, bool ignoreCase = false, bool global = false, bool spellOutWhitespace = false)
         {
             if (expression == null)
             {
@@ -25,7 +25,7 @@ public Pattern(string expression, bool ignoreCase = false, bool global = false,
 
             var start = AnchoredAtStart ? 1 : 0;
             var end = (AnchoredAtEnd ? 1 : 0) + start;
-            RootExpression = VBRegexParser.Parse(expression.Substring(start, expression.Length - end), surroundWhitespaceCharWithIdentifier);
+            RootExpression = VBRegexParser.Parse(expression.Substring(start, expression.Length - end), spellOutWhitespace);
             Description = AssembleDescription();
         }
 
diff --git a/Rubberduck.RegexAssistant/VBRegexParser.cs b/Rubberduck.RegexAssistant/VBRegexParser.cs
@@ -12,7 +12,7 @@ internal class VBRegexParser
         private static readonly Regex LITERAL_PATTERN = new Regex("^" + Literal.Pattern);
         private static readonly Regex QUANTIFIER_PATTERN = new Regex("^" + Quantifier.Pattern);
 
-        public static IRegularExpression Parse(string specifier, bool surroundWhitespaceCharWithIdentifier = false)
+        public static IRegularExpression Parse(string specifier, bool spellOutWhiteSpace = false)
         {
             if (specifier == null) throw new ArgumentNullException(nameof(specifier));
 
@@ -34,7 +34,7 @@ public static IRegularExpression Parse(string specifier, bool surroundWhitespace
                     {
                         var quantifier = GetQuantifier(specifier, expressionBody.Length);
                         var expression = Parse(expressionBody.Substring(1, expressionBody.Length - 2));
-                        concatenation.Add(new SingleAtomExpression(new RdGroup(expression, expressionBody, new Quantifier(quantifier))));
+                        concatenation.Add(new SingleAtomExpression(new RdGroup(expression, expressionBody, new Quantifier(quantifier), spellOutWhiteSpace)));
                         specifier = specifier.Substring(expressionBody.Length + quantifier.Length);
                         continue;
                     }
@@ -45,7 +45,7 @@ public static IRegularExpression Parse(string specifier, bool surroundWhitespace
                     if (expressionBody.Length != 0)
                     {
                         var quantifier = GetQuantifier(specifier, expressionBody.Length);
-                        concatenation.Add(new SingleAtomExpression(new CharacterClass(expressionBody, new Quantifier(quantifier), surroundWhitespaceCharWithIdentifier)));
+                        concatenation.Add(new SingleAtomExpression(new CharacterClass(expressionBody, new Quantifier(quantifier), spellOutWhiteSpace)));
                         specifier = specifier.Substring(expressionBody.Length + quantifier.Length);
                         continue;
                     }
@@ -61,7 +61,7 @@ public static IRegularExpression Parse(string specifier, bool surroundWhitespace
                         continue;
                     }
                     var quantifier = GetQuantifier(specifier, expressionBody.Length);
-                    concatenation.Add(new SingleAtomExpression(new Literal(expressionBody, new Quantifier(quantifier))));
+                    concatenation.Add(new SingleAtomExpression(new Literal(expressionBody, new Quantifier(quantifier), spellOutWhiteSpace)));
                     specifier = specifier.Substring(expressionBody.Length + quantifier.Length);
                     continue;
                 }

Original file line number	Diff line number	Diff line change
`@@ -47,20 +47,20 @@ public string Pattern`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`- public bool SurroundWhitespaceCharWithIdentifier`
	`50`	`+ public bool SpellOutWhiteSpace`
`51`	`51`	`{`
`52`		`- get => _surroundWhitespaceCharWithIdentifier;`
	`52`	`+ get => _spellOutWhiteSpace;`
`53`	`53`	`set`
`54`	`54`	`{`
`55`		`- _surroundWhitespaceCharWithIdentifier = value;`
	`55`	`+ _spellOutWhiteSpace = value;`
`56`	`56`	`RecalculateDescription();`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`private bool _globalFlag;`
`61`	`61`	`private bool _ignoreCaseFlag;`
`62`	`62`	`private string _pattern;`
`63`		`- private bool _surroundWhitespaceCharWithIdentifier;`
	`63`	`+ private bool _spellOutWhiteSpace;`
`64`	`64`
`65`	`65`	`private List<TreeViewItem> _resultItems;`
`66`	`66`	`public List<TreeViewItem> ResultItems`
`@@ -89,7 +89,7 @@ private void RecalculateDescription()`
`89`	`89`	`ResultItems = results;`
`90`	`90`	`return;`
`91`	`91`	`}`
`92`		`- ResultItems = ToTreeViewItems(new Pattern(_pattern, _ignoreCaseFlag, _globalFlag, _surroundWhitespaceCharWithIdentifier));`
	`92`	`+ ResultItems = ToTreeViewItems(new Pattern(_pattern, _ignoreCaseFlag, _globalFlag, _spellOutWhiteSpace));`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`private List<TreeViewItem> ToTreeViewItems(Pattern pattern)`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal class CharacterClass : IAtom`
`12`	`12`	`public bool InverseMatching { get; }`
`13`	`13`	`public IList<string> CharacterSpecifiers { get; }`
`14`	`14`
`15`		`- public CharacterClass(string specifier, Quantifier quantifier, bool surroundWhitespaceCharWithIdentifier = false)`
	`15`	`+ public CharacterClass(string specifier, Quantifier quantifier, bool spellOutWhiteSpace = false)`
`16`	`16`	`{`
`17`	`17`	`if (specifier == null \|\| quantifier == null)`
`18`	`18`	`{`
`@@ -28,17 +28,17 @@ public CharacterClass(string specifier, Quantifier quantifier, bool surroundWhit`
`28`	`28`	`// trim leading and closing bracket`
`29`	`29`	`var actualSpecifier = specifier.Substring(1, specifier.Length - 2);`
`30`	`30`	`InverseMatching = actualSpecifier.StartsWith("^");`
`31`		`- CharacterSpecifiers= ExtractCharacterSpecifiers(InverseMatching ? actualSpecifier.Substring(1) : actualSpecifier,`
`32`		`- surroundWhitespaceCharWithIdentifier);`
	`31`	`+ CharacterSpecifiers = ExtractCharacterSpecifiers(InverseMatching ? actualSpecifier.Substring(1) : actualSpecifier,`
	`32`	`+ spellOutWhiteSpace);`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`public string Specifier { get; }`
`36`	`36`
`37`	`37`	`public Quantifier Quantifier { get; }`
`38`	`38`
`39`	`39`	`private static readonly Regex CharacterRanges = new Regex(@"(\\[dDwWsS]\|(\\[ntfvr]\|\\([0-7]{3}\|x[\dA-F]{2}\|u[\dA-F]{4}\|[\\\.\[\]])\|.)(-(\\[ntfvr]\|\\([0-7]{3}\|x[A-F]{2}\|u[\dA-F]{4}\|[\.\\\[\]])\|.))?)", RegexOptions.Compiled);`
`40`		`- private static readonly Regex whitespace = new Regex("\\s");`
`41`		`- private IList<string> ExtractCharacterSpecifiers(string characterClass, bool surroundWhitespaceCharWithIdentifier)`
	`40`	`+`
	`41`	`+ private IList<string> ExtractCharacterSpecifiers(string characterClass, bool spellOutWhitespace)`
`42`	`42`	`{`
`43`	`43`	`var specifiers = CharacterRanges.Matches(characterClass);`
`44`	`44`	`var result = new List<string>();`
`@@ -59,9 +59,15 @@ private IList<string> ExtractCharacterSpecifiers(string characterClass, bool sur`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`- result.Add(whitespace.IsMatch(specifier.Value) && surroundWhitespaceCharWithIdentifier`
`63`		`- ? string.Format(RubberduckUI.RegexAssistant_EncloseWhitespace_EnclosingFormat, specifier.Value)`
`64`		`- : specifier.Value);`
	`62`	`+ if (spellOutWhitespace`
	`63`	`+ && WhitespaceToString.IsFullySpellingOutApplicable(specifier.Value, out var spelledOutWhiteSpace))`
	`64`	`+ {`
	`65`	`+ result.Add(spelledOutWhiteSpace);`
	`66`	`+ }`
	`67`	`+ else`
	`68`	`+ {`
	`69`	`+ result.Add(specifier.Value);`
	`70`	`+ }`
`65`	`71`	`}`
`66`	`72`	`return result;`
`67`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace Rubberduck.RegexAssistant.Atoms`
`8`	`8`	`{`
`9`	`9`	`public class Group : IAtom`
`10`	`10`	`{`
`11`		`- public Group(IRegularExpression expression, string specifier, Quantifier quantifier) {`
	`11`	`+ public Group(IRegularExpression expression, string specifier, Quantifier quantifier, bool spellOutWhiteSpace = false) {`
`12`	`12`	`if (expression == null \|\| quantifier == null)`
`13`	`13`	`{`
`14`	`14`	`throw new ArgumentNullException();`
`@@ -17,6 +17,7 @@ public Group(IRegularExpression expression, string specifier, Quantifier quantif`
`17`	`17`	`Quantifier = quantifier;`
`18`	`18`	`Subexpression = expression;`
`19`	`19`	`Specifier = specifier;`
	`20`	`+ _spellOutWhiteSpace = spellOutWhiteSpace;`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`public IRegularExpression Subexpression { get; }`
`@@ -25,7 +26,12 @@ public Group(IRegularExpression expression, string specifier, Quantifier quantif`
`25`	`26`
`26`	`27`	`public string Specifier { get; }`
`27`	`28`
`28`		`- public string Description => string.Format(AssistantResources.AtomDescription_Group, Specifier);`
	`29`	`+ private readonly bool _spellOutWhiteSpace;`
	`30`	`+`
	`31`	`+ public string Description => string.Format(AssistantResources.AtomDescription_Group,`
	`32`	`+ _spellOutWhiteSpace && WhitespaceToString.IsFullySpellingOutApplicable(Specifier, out var spelledOutWhiteSpace)`
	`33`	`+ ? spelledOutWhiteSpace`
	`34`	`+ : Specifier);`
`29`	`35`
`30`	`36`
`31`	`37`	`public override string ToString() => Specifier;`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ internal class Literal : IAtom`
`11`	`11`	`public static readonly string Pattern = @"(?<expression>\\(u[\dA-F]{4}\|x[\dA-F]{2}\|[0-7]{3}\|[bB\(\){}\\\[\]\.+?1-9nftvrdDwWsS])\|[^()\[\]{}\\+?^$])";`
`12`	`12`	`private static readonly Regex Matcher = new Regex($"^{Pattern}$", RegexOptions.Compiled);`
`13`	`13`	`private static readonly ISet<char> EscapeLiterals = new HashSet<char>();`
	`14`	`+ private readonly bool _surroundWhitespaceCharWithIdentifier;`
`14`	`15`
`15`	`16`	`static Literal() {`
`16`	`17`	`foreach (var escape in new[]{ '.', '+', '*', '?', '(', ')', '{', '}', '[', ']', '\|', '\\' })`
`@@ -32,7 +33,7 @@ static Literal() {`
`32`	`33`	`_escapeDescriptions.Add('t', AssistantResources.AtomDescription_HTab);`
`33`	`34`	`}`
`34`	`35`
`35`		`- public Literal(string specifier, Quantifier quantifier)`
	`36`	`+ public Literal(string specifier, Quantifier quantifier, bool spellOutWhitespace = false)`
`36`	`37`	`{`
`37`	`38`	`if (specifier == null \|\| quantifier == null)`
`38`	`39`	`{`
`@@ -45,6 +46,8 @@ public Literal(string specifier, Quantifier quantifier)`
`45`	`46`	`{`
`46`	`47`	`throw new ArgumentException("The given specifier does not denote a Literal");`
`47`	`48`	`}`
	`49`	`+`
	`50`	`+ _surroundWhitespaceCharWithIdentifier = spellOutWhitespace;`
`48`	`51`	`Specifier = specifier;`
`49`	`52`	`}`
`50`	`53`
`@@ -95,9 +98,15 @@ public string Description`
`95`	`98`	`}`
`96`	`99`	`}`
`97`	`100`
`98`		`- return Specifier.Equals(".")`
`99`		`- ? AssistantResources.AtomDescription_Dot`
`100`		`- : string.Format(AssistantResources.AtomDescription_Literal_ActualLiteral, Specifier);`
	`101`	`+ if (Specifier.Equals("."))`
	`102`	`+ {`
	`103`	`+ return AssistantResources.AtomDescription_Dot;`
	`104`	`+ }`
	`105`	`+`
	`106`	`+ return string.Format(AssistantResources.AtomDescription_Literal_ActualLiteral,`
	`107`	`+ _surroundWhitespaceCharWithIdentifier && WhitespaceToString.IsFullySpellingOutApplicable(Specifier, out var spelledOutWhiteSpace)`
	`108`	`+ ? spelledOutWhiteSpace`
	`109`	`+ : Specifier);`
`101`	`110`	`}`
`102`	`111`	`}`
`103`	`112`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public class Pattern : IDescribable`
`10`	`10`
`11`	`11`	`public string Description { get; }`
`12`	`12`
`13`		`- public Pattern(string expression, bool ignoreCase = false, bool global = false, bool surroundWhitespaceCharWithIdentifier = false)`
	`13`	`+ public Pattern(string expression, bool ignoreCase = false, bool global = false, bool spellOutWhitespace = false)`
`14`	`14`	`{`
`15`	`15`	`if (expression == null)`
`16`	`16`	`{`
`@@ -25,7 +25,7 @@ public Pattern(string expression, bool ignoreCase = false, bool global = false,`
`25`	`25`
`26`	`26`	`var start = AnchoredAtStart ? 1 : 0;`
`27`	`27`	`var end = (AnchoredAtEnd ? 1 : 0) + start;`
`28`		`- RootExpression = VBRegexParser.Parse(expression.Substring(start, expression.Length - end), surroundWhitespaceCharWithIdentifier);`
	`28`	`+ RootExpression = VBRegexParser.Parse(expression.Substring(start, expression.Length - end), spellOutWhitespace);`
`29`	`29`	`Description = AssembleDescription();`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal class VBRegexParser`
`12`	`12`	`private static readonly Regex LITERAL_PATTERN = new Regex("^" + Literal.Pattern);`
`13`	`13`	`private static readonly Regex QUANTIFIER_PATTERN = new Regex("^" + Quantifier.Pattern);`
`14`	`14`
`15`		`- public static IRegularExpression Parse(string specifier, bool surroundWhitespaceCharWithIdentifier = false)`
	`15`	`+ public static IRegularExpression Parse(string specifier, bool spellOutWhiteSpace = false)`
`16`	`16`	`{`
`17`	`17`	`if (specifier == null) throw new ArgumentNullException(nameof(specifier));`
`18`	`18`
`@@ -34,7 +34,7 @@ public static IRegularExpression Parse(string specifier, bool surroundWhitespace`
`34`	`34`	`{`
`35`	`35`	`var quantifier = GetQuantifier(specifier, expressionBody.Length);`
`36`	`36`	`var expression = Parse(expressionBody.Substring(1, expressionBody.Length - 2));`
`37`		`- concatenation.Add(new SingleAtomExpression(new RdGroup(expression, expressionBody, new Quantifier(quantifier))));`
	`37`	`+ concatenation.Add(new SingleAtomExpression(new RdGroup(expression, expressionBody, new Quantifier(quantifier), spellOutWhiteSpace)));`
`38`	`38`	`specifier = specifier.Substring(expressionBody.Length + quantifier.Length);`
`39`	`39`	`continue;`
`40`	`40`	`}`
`@@ -45,7 +45,7 @@ public static IRegularExpression Parse(string specifier, bool surroundWhitespace`
`45`	`45`	`if (expressionBody.Length != 0)`
`46`	`46`	`{`
`47`	`47`	`var quantifier = GetQuantifier(specifier, expressionBody.Length);`
`48`		`- concatenation.Add(new SingleAtomExpression(new CharacterClass(expressionBody, new Quantifier(quantifier), surroundWhitespaceCharWithIdentifier)));`
	`48`	`+ concatenation.Add(new SingleAtomExpression(new CharacterClass(expressionBody, new Quantifier(quantifier), spellOutWhiteSpace)));`
`49`	`49`	`specifier = specifier.Substring(expressionBody.Length + quantifier.Length);`
`50`	`50`	`continue;`
`51`	`51`	`}`
`@@ -61,7 +61,7 @@ public static IRegularExpression Parse(string specifier, bool surroundWhitespace`
`61`	`61`	`continue;`
`62`	`62`	`}`
`63`	`63`	`var quantifier = GetQuantifier(specifier, expressionBody.Length);`
`64`		`- concatenation.Add(new SingleAtomExpression(new Literal(expressionBody, new Quantifier(quantifier))));`
	`64`	`+ concatenation.Add(new SingleAtomExpression(new Literal(expressionBody, new Quantifier(quantifier), spellOutWhiteSpace)));`
`65`	`65`	`specifier = specifier.Substring(expressionBody.Length + quantifier.Length);`
`66`	`66`	`continue;`
`67`	`67`	`}`