Merge pull request #77 from m-ender/feature/match-index

Add match-index feature
m-ender · Apr 12, 2019 · 6a7231c · 6a7231c
2 parents 9992af1 + 2cf1d4e
commit 6a7231c
Show file tree

Hide file tree

Showing 5 changed files with 73 additions and 17 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 1.2.0
+
+- Substitution syntax: added `$:&` and `$;&` to generate the match's index from the left and right, respectively. `<>[]` modifiers can be (ab)used for some off-by-one shenanigans.
+
 ## 1.1.1
 
 This version switches from .NET Framework to .NET Core.

diff --git a/Retina/Retina/Replace/Nodes/DynamicElement.cs b/Retina/Retina/Replace/Nodes/DynamicElement.cs
@@ -9,9 +9,9 @@ namespace Retina.Replace.Nodes
     public class DynamicElement : Node
     {
         public Node Child { get; set; }
-        private bool CyclicMatches;
+        private readonly bool CyclicMatches;
 
-        private History History;
+        private readonly History History;
 
         public DynamicElement(Node child, History history, bool cyclicMatches)
         {
@@ -49,8 +49,8 @@ private string ResolveChild(string input, List<MatchContext> matches, List<Match
                   [<>[\]]
                 )?
                 (
-                  (?<modifier>      # Capture count or random capture.
-                    [#?]
+                  (?<modifier>      # Generic capture modifier.
+                    [#:;?]
                   )?
                   (
                     (?<entireMatch> # $& and $0 refer to the entire match.
@@ -97,30 +97,50 @@ private string ResolveChild(string input, List<MatchContext> matches, List<Match
             if (parserMatch.Groups["modifier"].Success)
                 modifier = parserMatch.Groups["modifier"].Value[0];
 
+            // Will be set to false if an adjacency modifier shifts
+            // the context to a separator.
+            bool contextIsMatch = true;
             MatchContext match;
             switch (adjacent)
             {
             case '<':
                 match = separators[index];
+                contextIsMatch = false;
                 break;
             case '>':
-                match = separators[index+1];
+                ++index;
+                match = separators[index];
+                contextIsMatch = false;
                 break;
             case '[':
                 if (CyclicMatches)
-                    match = matches[(index - 1 + matches.Count) % matches.Count];
+                {
+                    index = (index - 1 + matches.Count) % matches.Count;
+                    match = matches[index];
+                }
                 else if (index == 0)
                     return "";
                 else
-                    match = matches[index - 1];
+                {
+                    --index;
+                    match = matches[index];
+                }
+
                 break;
             case ']':
                 if (CyclicMatches)
-                    match = matches[(index + 1) % matches.Count];
+                {
+                    index = (index + 1) % matches.Count;
+                    match = matches[index];
+                }
                 else if (index == matches.Count - 1)
                     return "";
                 else
-                    match = matches[index + 1];
+                {
+                    ++index;
+                    match = matches[index];
+                }
+
                 break;
             default:
                 match = matches[index];
@@ -137,6 +157,15 @@ private string ResolveChild(string input, List<MatchContext> matches, List<Match
                     // Subtract 1 to account for group 0.
                     value = (match.Regex.GetGroupNumbers().Count(i => match.Match.Groups[i].Success) - 1).ToString();
                     break;
+                case ':':
+                    value = index.ToString();
+                    break;
+                case ';':
+                    {
+                        int maxIndex = (contextIsMatch ? matches : separators).Count - 1;
+                        value = (maxIndex - index).ToString();
+                        break;
+                    }
                 case '?':
                     int[] groups = match.Regex.GetGroupNumbers();
                     // Offset by 1 to account for group 0.

diff --git a/Retina/Retina/Replace/Parser.cs b/Retina/Retina/Replace/Parser.cs
@@ -16,12 +16,12 @@ public ParserError(string message) : base(message) { }
             public ParserError(string message, Exception innerException) : base(message, innerException) { }
         }
 
-        private bool CyclicMatches;
+        private readonly bool CyclicMatches;
 
         private List<Token> Tokens;
         private int Current;
 
-        private History History;
+        private readonly History History;
 
         public Parser(History history)
         {
@@ -70,7 +70,7 @@ private void Tokenize(string replacement)
                   (
                     (?<numbered>       # $n are numbered groups.
                       [<>[\]]?         # Pull the value from an adjacent separator or match.
-                      [#?]?            # Capture count or random capture.
+                      [#:;?]?          # Generic capture modifiers.
                       (?:\d+|&)        # & is an alias for 0.
                     )
                   |

diff --git a/Retina/Retina/Stages/AtomicStage.cs b/Retina/Retina/Stages/AtomicStage.cs
@@ -24,8 +24,8 @@ public abstract class AtomicStage : Stage
         private int PatternIndex;
 
         protected History History;
-        private bool RegisterWithHistory;
-        private int HistoryIndex;
+        private readonly bool RegisterWithHistory;
+        private readonly int HistoryIndex;
 
         protected AtomicStage(Config config, History history, bool registerByDefault) : base(config) {
             History = history;
@@ -203,8 +203,7 @@ private void LimitMatches()
             if (Config.SingleRandomMatch && Matches.Count > 0)
             {
                 var chosenMatch = Matches[Random.RNG.Next(Matches.Count)];
-                Matches = new List<MatchContext>();
-                Matches.Add(chosenMatch);
+                Matches = new List<MatchContext> { chosenMatch };
             }
         }
 

diff --git a/Retina/RetinaTest/ReplacerTest.cs b/Retina/RetinaTest/ReplacerTest.cs
@@ -219,6 +219,31 @@ public void TestCaptureCount()
             AssertProgram(new TestSuite { Sources = { "(a|b)+(cd)|d(e)f", "$#0${#0}${#00}" }, TestCases = { { "abcd\ndef", "222\n111" } } });
         }
 
+        [TestMethod]
+        public void TestMatchIndex()
+        {
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$:0" }, TestCases = { { "123,321,123,321", "0,1,2,3" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$:&" }, TestCases = { { "123,321,123,321", "0,1,2,3" } } });
+
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$;0" }, TestCases = { { "123,321,123,321", "3,2,1,0" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$;&" }, TestCases = { { "123,321,123,321", "3,2,1,0" } } });
+
+            // Test interaction with adjacency modifiers
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$<:&" }, TestCases = { { "123,321,123,321", "0,1,2,3" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$>:&" }, TestCases = { { "123,321,123,321", "1,2,3,4" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$[:&" }, TestCases = { { "123,321,123,321", ",0,1,2" } } });
+            AssertProgram(new TestSuite { Sources = { @"y`\w+", "$[:&" }, TestCases = { { "123,321,123,321", "3,0,1,2" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$]:&" }, TestCases = { { "123,321,123,321", "1,2,3," } } });
+            AssertProgram(new TestSuite { Sources = { @"y`\w+", "$]:&" }, TestCases = { { "123,321,123,321", "1,2,3,0" } } });
+
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$<;&" }, TestCases = { { "123,321,123,321", "4,3,2,1" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$>;&" }, TestCases = { { "123,321,123,321", "3,2,1,0" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$[;&" }, TestCases = { { "123,321,123,321", ",3,2,1" } } });
+            AssertProgram(new TestSuite { Sources = { @"y`\w+", "$[;&" }, TestCases = { { "123,321,123,321", "0,3,2,1" } } });
+            AssertProgram(new TestSuite { Sources = { @"\w+", "$];&" }, TestCases = { { "123,321,123,321", "2,1,0," } } });
+            AssertProgram(new TestSuite { Sources = { @"y`\w+", "$];&" }, TestCases = { { "123,321,123,321", "2,1,0,3" } } });
+        }
+
         [TestMethod]
         public void TestRandomCapture()
         {
@@ -235,7 +260,6 @@ public void TestRandomCapture()
             });
         }
 
-
         [TestMethod]
         public void TestRandomGroup()
         {