Added GetHashCode implementations and suppressed warnings in testcode. Made IRegularExpression public to use in the GUI

Vogel612 · Vogel612 · commit b1a776efcbac · 2016-07-14T01:17:50.000+02:00
diff --git a/Rubberduck.RegexAssistant/Atom.cs b/Rubberduck.RegexAssistant/Atom.cs
@@ -94,6 +94,11 @@ public override bool Equals(object obj)
             }
             return false;
         }
+
+        public override int GetHashCode()
+        {
+            return _specifier.GetHashCode();
+        }
     }
 
     internal class Group : IAtom
@@ -138,6 +143,11 @@ public override bool Equals(object obj)
             }
             return false;
         }
+
+        public override int GetHashCode()
+        {
+            return _specifier.GetHashCode();
+        }
     }
 
     internal class Literal : IAtom
@@ -245,5 +255,10 @@ public override bool Equals(object obj)
             }
             return false;
         }
+
+        public override int GetHashCode()
+        {
+            return _specifier.GetHashCode();
+        }
     }
 }
diff --git a/Rubberduck.RegexAssistant/IRegularExpression.cs b/Rubberduck.RegexAssistant/IRegularExpression.cs
@@ -7,27 +7,28 @@
 
 namespace Rubberduck.RegexAssistant
 {
-    internal interface IRegularExpression : IDescribable
+    public interface IRegularExpression : IDescribable
     {
         Quantifier Quantifier { get; }
+        IList<IRegularExpression> Subexpressions { get; }
     }
 
     internal class ConcatenatedExpression : IRegularExpression
     {
         private readonly Quantifier _quantifier;
-        internal readonly IList<IRegularExpression> Subexpressions;
+        private readonly IList<IRegularExpression> _subexpressions;
 
         public ConcatenatedExpression(IList<IRegularExpression> subexpressions)
         {
-            Subexpressions = subexpressions;
+            _subexpressions = subexpressions;
             _quantifier = new Quantifier(string.Empty); // these are always exactly once. Quantifying happens through groups
         }
 
         public string Description
         {
             get
             {
-                return string.Join(Environment.NewLine, Subexpressions.Select(exp => exp.Description));
+                return string.Join(Environment.NewLine, _subexpressions.Select(exp => exp.Description));
             }
         }
 
@@ -38,24 +39,32 @@ public Quantifier Quantifier
                 return _quantifier;
             }
         }
+
+        public IList<IRegularExpression> Subexpressions
+        {
+            get
+            {
+                return _subexpressions;
+            }
+        }
     }
 
     internal class AlternativesExpression : IRegularExpression
     {
         private readonly Quantifier _quantifier;
-        internal readonly IList<IRegularExpression> Subexpressions;
+        private readonly IList<IRegularExpression> _subexpressions;
 
         public AlternativesExpression(IList<IRegularExpression> subexpressions)
         {
-            Subexpressions = subexpressions;
+            _subexpressions = subexpressions;
             _quantifier = new Quantifier(string.Empty); // these are always exactly once. Quantifying happens through groups
         }
 
         public string Description
         {
             get
             {
-                return AssistantResources.ExpressionDescription_AlternativesExpression + Environment.NewLine + string.Join(Environment.NewLine, Subexpressions.Select(exp => exp.Description));
+                return AssistantResources.ExpressionDescription_AlternativesExpression + Environment.NewLine + string.Join(Environment.NewLine, _subexpressions.Select(exp => exp.Description));
             }
         }
 
@@ -66,6 +75,14 @@ public Quantifier Quantifier
                 return _quantifier;
             }
         }
+
+        public IList<IRegularExpression> Subexpressions
+        {
+            get
+            {
+                return _subexpressions;
+            }
+        }
     }
 
     internal class SingleAtomExpression : IRegularExpression
@@ -95,6 +112,14 @@ public Quantifier Quantifier
             }
         }
 
+        public IList<IRegularExpression> Subexpressions
+        {
+            get
+            {
+                return new List<IRegularExpression>(Enumerable.Empty<IRegularExpression>());
+            }
+        }
+
         public override bool Equals(object obj)
         {
             if (obj is SingleAtomExpression)
@@ -104,6 +129,12 @@ public override bool Equals(object obj)
             }
             return false;
         }
+
+        public override int GetHashCode()
+        {
+            return Atom.GetHashCode() ^ Quantifier.GetHashCode();
+        }
+
     }
 
     internal static class RegularExpression
diff --git a/Rubberduck.RegexAssistant/Quantifier.cs b/Rubberduck.RegexAssistant/Quantifier.cs
@@ -3,7 +3,7 @@
 
 namespace Rubberduck.RegexAssistant
 {
-    internal class Quantifier
+    public class Quantifier
     {
         public static readonly string Pattern = @"(?<quantifier>(?<!\\)[\?\*\+]|(?<!\\)\{(\d+)(,\d*)?(?<!\\)\})";
         private static readonly Regex Matcher = new Regex(@"^\{(?<min>\d+)(?<max>,\d*)?\}$");
@@ -103,7 +103,7 @@ public override string ToString()
         }
     }
 
-    internal enum QuantifierKind
+    public enum QuantifierKind
     {
         None, Expression, Wildcard
     }
diff --git a/Rubberduck.RegexAssistant/Tests/CharacterClassTests.cs b/Rubberduck.RegexAssistant/Tests/CharacterClassTests.cs
@@ -176,7 +176,9 @@ public void IncorrectlyEscapedRangeTargetLiteralsBlowUp()
                 {
                     CharacterClass cut = new CharacterClass(string.Format("[F-{0}]", escapedLiteral));
                 }
+#pragma warning disable CS0168 // Variable is declared but never used
                 catch (ArgumentException ex)
+#pragma warning restore CS0168 // Variable is declared but never used
                 {
                     continue;
                 }
diff --git a/Rubberduck.RegexAssistant/Tests/LiteralTests.cs b/Rubberduck.RegexAssistant/Tests/LiteralTests.cs
@@ -63,7 +63,9 @@ public void EverythingElseBlowsUp()
                 {
                     Literal cut = new Literal("a"+blowup);
                 }
+#pragma warning disable CS0168 // Variable is declared but never used
                 catch (ArgumentException ex)
+#pragma warning restore CS0168 // Variable is declared but never used
                 {
                     Assert.IsTrue(true); // Assert.Pass();
                     continue;
@@ -82,7 +84,9 @@ public void SingleEscapedCharsAreNotParsedAsLiteral()
                 {
                     Literal cut = new Literal(escape);
                 }
+#pragma warning disable CS0168 // Variable is declared but never used
                 catch (ArgumentException ex)
+#pragma warning restore CS0168 // Variable is declared but never used
                 {
                     Assert.IsTrue(true); // Assert.Pass();
                     continue;

Original file line number	Diff line number	Diff line change
`@@ -94,6 +94,11 @@ public override bool Equals(object obj)`
`94`	`94`	`}`
`95`	`95`	`return false;`
`96`	`96`	`}`
	`97`	`+`
	`98`	`+ public override int GetHashCode()`
	`99`	`+ {`
	`100`	`+ return _specifier.GetHashCode();`
	`101`	`+ }`
`97`	`102`	`}`
`98`	`103`
`99`	`104`	`internal class Group : IAtom`
`@@ -138,6 +143,11 @@ public override bool Equals(object obj)`
`138`	`143`	`}`
`139`	`144`	`return false;`
`140`	`145`	`}`
	`146`	`+`
	`147`	`+ public override int GetHashCode()`
	`148`	`+ {`
	`149`	`+ return _specifier.GetHashCode();`
	`150`	`+ }`
`141`	`151`	`}`
`142`	`152`
`143`	`153`	`internal class Literal : IAtom`
`@@ -245,5 +255,10 @@ public override bool Equals(object obj)`
`245`	`255`	`}`
`246`	`256`	`return false;`
`247`	`257`	`}`
	`258`	`+`
	`259`	`+ public override int GetHashCode()`
	`260`	`+ {`
	`261`	`+ return _specifier.GetHashCode();`
	`262`	`+ }`
`248`	`263`	`}`
`249`	`264`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,27 +7,28 @@`
`7`	`7`
`8`	`8`	`namespace Rubberduck.RegexAssistant`
`9`	`9`	`{`
`10`		`- internal interface IRegularExpression : IDescribable`
	`10`	`+ public interface IRegularExpression : IDescribable`
`11`	`11`	`{`
`12`	`12`	`Quantifier Quantifier { get; }`
	`13`	`+ IList<IRegularExpression> Subexpressions { get; }`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`internal class ConcatenatedExpression : IRegularExpression`
`16`	`17`	`{`
`17`	`18`	`private readonly Quantifier _quantifier;`
`18`		`- internal readonly IList<IRegularExpression> Subexpressions;`
	`19`	`+ private readonly IList<IRegularExpression> _subexpressions;`
`19`	`20`
`20`	`21`	`public ConcatenatedExpression(IList<IRegularExpression> subexpressions)`
`21`	`22`	`{`
`22`		`- Subexpressions = subexpressions;`
	`23`	`+ _subexpressions = subexpressions;`
`23`	`24`	`_quantifier = new Quantifier(string.Empty); // these are always exactly once. Quantifying happens through groups`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`public string Description`
`27`	`28`	`{`
`28`	`29`	`get`
`29`	`30`	`{`
`30`		`- return string.Join(Environment.NewLine, Subexpressions.Select(exp => exp.Description));`
	`31`	`+ return string.Join(Environment.NewLine, _subexpressions.Select(exp => exp.Description));`
`31`	`32`	`}`
`32`	`33`	`}`
`33`	`34`
`@@ -38,24 +39,32 @@ public Quantifier Quantifier`
`38`	`39`	`return _quantifier;`
`39`	`40`	`}`
`40`	`41`	`}`
	`42`	`+`
	`43`	`+ public IList<IRegularExpression> Subexpressions`
	`44`	`+ {`
	`45`	`+ get`
	`46`	`+ {`
	`47`	`+ return _subexpressions;`
	`48`	`+ }`
	`49`	`+ }`
`41`	`50`	`}`
`42`	`51`
`43`	`52`	`internal class AlternativesExpression : IRegularExpression`
`44`	`53`	`{`
`45`	`54`	`private readonly Quantifier _quantifier;`
`46`		`- internal readonly IList<IRegularExpression> Subexpressions;`
	`55`	`+ private readonly IList<IRegularExpression> _subexpressions;`
`47`	`56`
`48`	`57`	`public AlternativesExpression(IList<IRegularExpression> subexpressions)`
`49`	`58`	`{`
`50`		`- Subexpressions = subexpressions;`
	`59`	`+ _subexpressions = subexpressions;`
`51`	`60`	`_quantifier = new Quantifier(string.Empty); // these are always exactly once. Quantifying happens through groups`
`52`	`61`	`}`
`53`	`62`
`54`	`63`	`public string Description`
`55`	`64`	`{`
`56`	`65`	`get`
`57`	`66`	`{`
`58`		`- return AssistantResources.ExpressionDescription_AlternativesExpression + Environment.NewLine + string.Join(Environment.NewLine, Subexpressions.Select(exp => exp.Description));`
	`67`	`+ return AssistantResources.ExpressionDescription_AlternativesExpression + Environment.NewLine + string.Join(Environment.NewLine, _subexpressions.Select(exp => exp.Description));`
`59`	`68`	`}`
`60`	`69`	`}`
`61`	`70`
`@@ -66,6 +75,14 @@ public Quantifier Quantifier`
`66`	`75`	`return _quantifier;`
`67`	`76`	`}`
`68`	`77`	`}`
	`78`	`+`
	`79`	`+ public IList<IRegularExpression> Subexpressions`
	`80`	`+ {`
	`81`	`+ get`
	`82`	`+ {`
	`83`	`+ return _subexpressions;`
	`84`	`+ }`
	`85`	`+ }`
`69`	`86`	`}`
`70`	`87`
`71`	`88`	`internal class SingleAtomExpression : IRegularExpression`
`@@ -95,6 +112,14 @@ public Quantifier Quantifier`
`95`	`112`	`}`
`96`	`113`	`}`
`97`	`114`
	`115`	`+ public IList<IRegularExpression> Subexpressions`
	`116`	`+ {`
	`117`	`+ get`
	`118`	`+ {`
	`119`	`+ return new List<IRegularExpression>(Enumerable.Empty<IRegularExpression>());`
	`120`	`+ }`
	`121`	`+ }`
	`122`	`+`
`98`	`123`	`public override bool Equals(object obj)`
`99`	`124`	`{`
`100`	`125`	`if (obj is SingleAtomExpression)`
`@@ -104,6 +129,12 @@ public override bool Equals(object obj)`
`104`	`129`	`}`
`105`	`130`	`return false;`
`106`	`131`	`}`
	`132`	`+`
	`133`	`+ public override int GetHashCode()`
	`134`	`+ {`
	`135`	`+ return Atom.GetHashCode() ^ Quantifier.GetHashCode();`
	`136`	`+ }`
	`137`	`+`
`107`	`138`	`}`
`108`	`139`
`109`	`140`	`internal static class RegularExpression`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace Rubberduck.RegexAssistant`
`5`	`5`	`{`
`6`		`- internal class Quantifier`
	`6`	`+ public class Quantifier`
`7`	`7`	`{`
`8`	`8`	`public static readonly string Pattern = @"(?<quantifier>(?<!\\)[\?\\+]\|(?<!\\)\{(\d+)(,\d)?(?<!\\)\})";`
`9`	`9`	`private static readonly Regex Matcher = new Regex(@"^\{(?<min>\d+)(?<max>,\d*)?\}$");`
`@@ -103,7 +103,7 @@ public override string ToString()`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`		`- internal enum QuantifierKind`
	`106`	`+ public enum QuantifierKind`
`107`	`107`	`{`
`108`	`108`	`None, Expression, Wildcard`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -176,7 +176,9 @@ public void IncorrectlyEscapedRangeTargetLiteralsBlowUp()`
`176`	`176`	`{`
`177`	`177`	`CharacterClass cut = new CharacterClass(string.Format("[F-{0}]", escapedLiteral));`
`178`	`178`	`}`
	`179`	`+#pragma warning disable CS0168 // Variable is declared but never used`
`179`	`180`	`catch (ArgumentException ex)`
	`181`	`+#pragma warning restore CS0168 // Variable is declared but never used`
`180`	`182`	`{`
`181`	`183`	`continue;`
`182`	`184`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,9 @@ public void EverythingElseBlowsUp()`
`63`	`63`	`{`
`64`	`64`	`Literal cut = new Literal("a"+blowup);`
`65`	`65`	`}`
	`66`	`+#pragma warning disable CS0168 // Variable is declared but never used`
`66`	`67`	`catch (ArgumentException ex)`
	`68`	`+#pragma warning restore CS0168 // Variable is declared but never used`
`67`	`69`	`{`
`68`	`70`	`Assert.IsTrue(true); // Assert.Pass();`
`69`	`71`	`continue;`
`@@ -82,7 +84,9 @@ public void SingleEscapedCharsAreNotParsedAsLiteral()`
`82`	`84`	`{`
`83`	`85`	`Literal cut = new Literal(escape);`
`84`	`86`	`}`
	`87`	`+#pragma warning disable CS0168 // Variable is declared but never used`
`85`	`88`	`catch (ArgumentException ex)`
	`89`	`+#pragma warning restore CS0168 // Variable is declared but never used`
`86`	`90`	`{`
`87`	`91`	`Assert.IsTrue(true); // Assert.Pass();`
`88`	`92`	`continue;`