Minor and Major cleanup inside Rubberduck.RegexAssistant

Author: Vogel612

Rubberduck.RegexAssistant/Atom.cs

@@ -26,6 +26,7 @@ public CharacterClass(string specifier)
             Match m = Matcher.Match(specifier);
             if (!m.Success)
             {
+                // TODO: i18n
                 throw new ArgumentException("The given specifier does not denote a character class");
             }
             this._specifier = specifier;
@@ -54,14 +55,12 @@ private IList<string> ExtractCharacterSpecifiers(string characterClass)
                 {
                     if (specifier.Value.EndsWith("-\\"))
                     {
-                        // BOOM!
+                        // TODO: i18n
                         throw new ArgumentException("Character Ranges that have incorrectly escaped characters as target are not allowed");
                     }
                     else if (specifier.Value.Length == 1)
                     {
-                        // fun... we somehow got to grab a single backslash. Pattern is probably broken
-                        // alas for simplicity we just skip the incorrect backslash
-                        // TODO: make a warning from this.. how?? no idea
+                        // Something's bork with the Pattern. For now we skip this it shouldn't affect anyone
                         continue;
                     }
                 }
@@ -113,6 +112,7 @@ public Group(string specifier) {
             Match m = Matcher.Match(specifier);
             if (!m.Success)
             {
+                // TODO i18n
                 throw new ArgumentException("The given specifier does not denote a Group");
             }
             _subexpression = RegularExpression.Parse(m.Groups["expression"].Value);
@@ -134,7 +134,6 @@ public string Description
             get
             {
                 return string.Format(AssistantResources.AtomDescription_Group, _specifier);
-                //+"\r\n" + _subexpression.Description
             }
         }
 
@@ -185,6 +184,7 @@ public Literal(string specifier)
             Match m = Matcher.Match(specifier);
             if (!m.Success)
             {
+                // TODO: i18n
                 throw new ArgumentException("The given specifier does not denote a Literal");
             }
             _specifier = specifier;

Rubberduck.RegexAssistant/IRegularExpression.cs

@@ -1,6 +1,5 @@
 using Rubberduck.RegexAssistant.Extensions;
 using Rubberduck.RegexAssistant.i18n;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -29,7 +28,6 @@ public string Description
             get
             {
                 return AssistantResources.ExpressionDescription_ConcatenatedExpression;
-                //return string.Join(Environment.NewLine, _subexpressions.Select(exp => exp.Description));
             }
         }
 
@@ -66,7 +64,6 @@ public string Description
             get
             {
                 return AssistantResources.ExpressionDescription_AlternativesExpression;
-                // + Environment.NewLine + string.Join(Environment.NewLine, _subexpressions.Select(exp => exp.Description))
             }
         }
 
@@ -229,7 +226,6 @@ private static IRegularExpression ParseIntoConcatenatedExpression(ref string spe
             int oldSpecifierLength = currentSpecifier.Length + 1;
             while (currentSpecifier.Length > 0 && currentSpecifier.Length < oldSpecifierLength)
             {
-                // Fugly hack for an error-return
                 oldSpecifierLength = currentSpecifier.Length;
                 IRegularExpression expression;
                 // we actually have an AlternativesExpression, return the current status to Parse after updating the specifier
@@ -300,77 +296,5 @@ internal static bool TryParseAsAtom(ref string specifier, out IRegularExpression
             expression = null;
             return false;
         }
-
-        /// <summary>
-        /// Makes the given specifier with the given pipeIndices into an AlternativesExpression 
-        /// </summary>
-        /// <param name="pipeIndices">The indices of Alternative-indicating pipes on the current expression level</param>
-        /// <param name="specifier">The specifier to split into subexpressions</param>
-        /// <returns>An AlternativesExpression consisting of the split alternatives in the specifier, in order of encounter</returns>
-        private static IRegularExpression ParseIntoAlternativesExpression(List<int> pipeIndices, string specifier)
-        {
-            List<IRegularExpression> expressions = new List<IRegularExpression>();
-            string currentRemainder = specifier;
-            for (int i = pipeIndices.Count - 1; i > 0; i--)
-            {
-                expressions.Add(Parse(currentRemainder.Substring(pipeIndices[i] + 1)));
-                currentRemainder = currentRemainder.Substring(0, pipeIndices[i] - 1);
-            }
-            expressions.Reverse(); // because we built them from the back
-            return new AlternativesExpression(expressions);
-        }
-
-
-        /// <summary>
-        /// Finds all Pipes in the given specifier that are not escaped
-        /// </summary>
-        /// <param name="specifier">the regex specifier to search for unescaped pipes</param>
-        /// <returns>A list populated with the indices of all pipes</returns>
-        private static List<int> GrabPipeIndices(string specifier)
-        {
-            // FIXME: Check assumptions: 
-            // - | is never encountered at index 0
-            // - | is never preceded by \\
-
-            if (!specifier.Contains("|")) {
-                return new List<int>();
-            }
-            int currentIndex = 0;
-            List<int> result = new List<int>();
-            while (true)
-            {
-                currentIndex = specifier.IndexOf("|", currentIndex);
-                if(currentIndex == -1)
-                {
-                    break;
-                }
-                // ignore escaped literals
-                // FIXME this is still a little too naive, since we could actually have something like "\\\|", which means that | is escaped again, but it should suffice for now
-                if (currentIndex == 0 || !specifier.Substring(currentIndex - 1, 2).Equals("\\|")
-                    || (currentIndex > 1 && specifier.Substring(currentIndex -2, 2).Equals("\\\\")))
-                {
-                    result.Add(currentIndex);
-                }
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Weeds out pipe indices that do not signify alternatives at the current "top level" from the given String.
-        /// </summary>
-        /// <param name="pipeIndices">indices of unescaped pipes in the given specifier</param>
-        /// <param name="specifier">the regex specifier under scrutiny</param>
-        internal static void WeedPipeIndices(ref List<int> pipeIndices, string specifier)
-        {
-            if (pipeIndices.Count == 0)
-            {
-                return;
-            }
-            foreach (int pipeIndex in pipeIndices)
-            {
-                // must not be between () or [] braces, else we just weed it out
-                
-            }
-        }
     }
 }

Rubberduck.RegexAssistant/Quantifier.cs

@@ -12,6 +12,7 @@ public class Quantifier
         public readonly int MinimumMatches;
         public readonly int MaximumMatches;
 
+        // FIXME i18n ? Shouldn't ever show up actually...
         public Quantifier(string expression)
         {
             if (expression.Length == 0)
@@ -26,7 +27,7 @@ public Quantifier(string expression)
                 Match m = Matcher.Match(expression);
                 if (!m.Success)
                 {
-                    throw new ArgumentException(String.Format("Cannot extract a Quantifier from the expression {1}", expression));
+                    throw new ArgumentException(string.Format("Cannot extract a Quantifier from the expression {1}", expression));
                 }
                 int minimum;
                 // shouldn't ever happen
@@ -93,8 +94,7 @@ public override bool Equals(object obj)
 
         public override int GetHashCode()
         {
-            // FIXME get a proper has function
-            return base.GetHashCode();
+            return MinimumMatches ^ MaximumMatches ^ Kind.GetHashCode();
         }
 
         public override string ToString()

Rubberduck.RegexAssistant/QuantifierExtensions.cs

@@ -30,7 +30,6 @@ public static string HumanReadable(this Quantifier quant)
                         return string.Format(AssistantResources.Quantifier_OpenRange, quant.MinimumMatches);
                     }
                     return string.Format(AssistantResources.Quantifier_ClosedRange, quant.MinimumMatches, quant.MaximumMatches);
-                    
             }
             return "";
         }