Unhappy/Dirty IDescribable method conversion

This commit contains the classes which do have issue with
`Description(bool spelledOutWhitespace=false)`. For these classes the parameter
is not appliable. Need to rubberduck out loud as to how to go about resolving
this. Is the best way to proceed with overloading the method?

Author: IvenBach

Rubberduck.RegexAssistant/Atoms/CharacterClass.cs

@@ -28,8 +28,10 @@ public CharacterClass(string specifier, Quantifier quantifier, bool spellOutWhit
             // trim leading and closing bracket
             var actualSpecifier = specifier.Substring(1, specifier.Length - 2);
             InverseMatching = actualSpecifier.StartsWith("^");
-            CharacterSpecifiers = ExtractCharacterSpecifiers(InverseMatching ? actualSpecifier.Substring(1) : actualSpecifier,
-                spellOutWhiteSpace);
+            CharacterSpecifiers = ExtractCharacterSpecifiers(InverseMatching 
+                    ? actualSpecifier.Substring(1) 
+                    : actualSpecifier
+                , spellOutWhiteSpace);
         }
 
         public string Specifier { get; }
@@ -59,20 +61,14 @@ private IList<string> ExtractCharacterSpecifiers(string characterClass, bool spe
                     }
                 }
 
-                if (spellOutWhitespace 
-                    && WhitespaceToString.IsFullySpellingOutApplicable(specifier.Value, out var spelledOutWhiteSpace))
-                {
-                    result.Add(spelledOutWhiteSpace);
-                }
-                else
-                {
-                    result.Add(specifier.Value);
-                }
+                result.Add(spellOutWhitespace && WhitespaceToString.IsFullySpellingOutApplicable(specifier.Value, out var spelledOutWhiteSpace)
+                    ? spelledOutWhiteSpace
+                    : specifier.Value);
             }
             return result;
         }
 
-        public string Description => string.Format(InverseMatching 
+        public string Description(bool notApplicable) => string.Format(InverseMatching 
                 ? AssistantResources.AtomDescription_CharacterClass_Inverted 
                 : AssistantResources.AtomDescription_CharacterClass
             , HumanReadableClass());

Rubberduck.RegexAssistant/Expressions/AlternativesExpression.cs

@@ -12,7 +12,7 @@ public AlternativesExpression(IList<IRegularExpression> subexpressions)
             Subexpressions = subexpressions ?? throw new ArgumentNullException();
         }
 
-        public string Description => string.Format(AssistantResources.ExpressionDescription_AlternativesExpression, Subexpressions.Count);
+        public string Description(bool notApplicable) => string.Format(AssistantResources.ExpressionDescription_AlternativesExpression, Subexpressions.Count);
 
         public IList<IRegularExpression> Subexpressions { get; }
 

Rubberduck.RegexAssistant/Expressions/ConcatenatedExpression.cs

@@ -12,7 +12,7 @@ public ConcatenatedExpression(IList<IRegularExpression> subexpressions)
             Subexpressions = subexpressions ?? throw new ArgumentNullException();
         }
 
-        public string Description => AssistantResources.ExpressionDescription_ConcatenatedExpression;
+        public string Description(bool notApplicable) => AssistantResources.ExpressionDescription_ConcatenatedExpression;
 
         public IList<IRegularExpression> Subexpressions { get; }
 

Rubberduck.RegexAssistant/Expressions/ErrorExpression.cs

@@ -13,7 +13,7 @@ public ErrorExpression(string errorToken)
             _errorToken = errorToken ?? throw new ArgumentNullException();
         }
 
-        public string Description => string.Format(AssistantResources.ExpressionDescription_ErrorExpression, _errorToken);
+        public string Description(bool notApplicable) => string.Format(AssistantResources.ExpressionDescription_ErrorExpression, _errorToken);
 
         public IList<IRegularExpression> Subexpressions => new List<IRegularExpression>();
 

Rubberduck.RegexAssistant/Pattern.cs

@@ -8,7 +8,8 @@ public class Pattern : IDescribable
         public IRegularExpression RootExpression;
         readonly MatcherFlags Flags;
 
-        public string Description { get; }
+        private readonly string _description;
+        public string Description(bool notApplicable) => _description;
 
         public Pattern(string expression, bool ignoreCase = false, bool global = false, bool spellOutWhitespace = false)
         {
@@ -25,16 +26,20 @@ 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), spellOutWhitespace);
-            Description = AssembleDescription();
+
+            _spellOutWhiteSpace = spellOutWhitespace;
+            RootExpression = VBRegexParser.Parse(expression.Substring(start, expression.Length - end), _spellOutWhiteSpace);
+            _description = AssembleDescription();
         }
 
+        private readonly bool _spellOutWhiteSpace;
+
         private string AssembleDescription()
         {
             var result = string.Empty;
             result += CasingDescription;
             result += StartAnchorDescription;
-            result += RootExpression.Description;
+            result += RootExpression.Description(_spellOutWhiteSpace);
             result += EndAnchorDescription;
             return result;
         }