Support removing matching options

Author: Azoy

Sources/_RegexParser/Regex/Printing/PrettyPrinter.swift

@@ -44,8 +44,9 @@ public struct PrettyPrinter {
   // The current default quantification behavior
   public var quantificationBehavior: AST.Quantification.Kind = .eager
 
-  // A stack of the current added inline matching options, e.g. (?s)
-  public var inlineMatchingOptions: [[AST.MatchingOption]] = []
+  // A stack of the current added inline matching options, e.g. (?s) and a
+  // boolean indicating true = added (?s) and false = removed (?-s).
+  public var inlineMatchingOptions: [([AST.MatchingOption], Bool)] = []
 }
 
 // MARK: - Raw interface
@@ -148,14 +149,17 @@ extension PrettyPrinter {
 
   /// Pushes the list of matching options to the current stack of other matching
   /// options and increases the indentation level by 1.
-  public mutating func pushMatchingOptions(_ options: [AST.MatchingOption]) {
+  public mutating func pushMatchingOptions(
+    _ options: [AST.MatchingOption],
+    isAdded: Bool
+  ) {
     indentLevel += 1
-    inlineMatchingOptions.append(options)
+    inlineMatchingOptions.append((options, isAdded))
   }
 
   /// Pops the most recent list of matching options from the printer and
   /// decreases the indentation level by 1.
-  public mutating func popMatchingOptions() -> [AST.MatchingOption] {
+  public mutating func popMatchingOptions() -> ([AST.MatchingOption], Bool) {
     indentLevel -= 1
     return inlineMatchingOptions.removeLast()
   }

Sources/_StringProcessing/PrintAsPattern.swift

@@ -79,37 +79,37 @@ extension PrettyPrinter {
   }
 
   mutating func printInlineMatchingOptions() {
-    for matchingOptions in inlineMatchingOptions {
-      let options = popMatchingOptions()
+    while !inlineMatchingOptions.isEmpty {
+      let (options, condition) = popMatchingOptions()
 
       printIndented { printer in
         for option in options {
           switch option.kind {
           case .asciiOnlyDigit:
-            printer.print(".asciiOnlyDigits()")
+            printer.print(".asciiOnlyDigits(\(condition))")
 
           case .asciiOnlyPOSIXProps:
-            printer.print(".asciiOnlyCharacterClasses()")
+            printer.print(".asciiOnlyCharacterClasses(\(condition))")
 
           case .asciiOnlySpace:
-            printer.print(".asciiOnlyWhitespace()")
+            printer.print(".asciiOnlyWhitespace(\(condition))")
 
           case .asciiOnlyWord:
-            printer.print(".asciiOnlyWordCharacters()")
+            printer.print(".asciiOnlyWordCharacters(\(condition))")
 
           case .caseInsensitive:
-            printer.print(".ignoresCase()")
+            printer.print(".ignoresCase(\(condition))")
 
           case .multiline:
-            printer.print(".anchorsMatchLineEndings()")
+            printer.print(".anchorsMatchLineEndings(\(condition))")
 
           case .reluctantByDefault:
             // This is handled by altering every OneOrMore, etc by changing each
             // individual repetition behavior instead of creating a nested regex.
             continue
 
           case .singleLine:
-            printer.print(".dotMatchesNewlines()")
+            printer.print(".dotMatchesNewlines(\(condition))")
 
           default:
             break
@@ -1326,14 +1326,30 @@ extension DSLTree.Atom {
       return ("/* TODO: symbolic references */", false)
 
     case .changeMatchingOptions(let matchingOptions):
-      for add in matchingOptions.ast.adding {
-        switch add.kind {
+      let options: [AST.MatchingOption]
+      let isAdd: Bool
+
+      if matchingOptions.ast.removing.isEmpty {
+        options = matchingOptions.ast.adding
+        isAdd = true
+      } else {
+        options = matchingOptions.ast.removing
+        isAdd = false
+      }
+
+      for option in options {
+        switch option.kind {
         case .reluctantByDefault:
-          printer.quantificationBehavior = .reluctant
+          if isAdd {
+            printer.quantificationBehavior = .reluctant
+          } else {
+            printer.quantificationBehavior = .eager
+          }
+
 
           // Don't create a nested Regex for (?U), we handle this by altering
           // every individual repetitionBehavior for things like OneOrMore.
-          if matchingOptions.ast.adding.count == 1 {
+          if options.count == 1 {
             return nil
           }
 
@@ -1343,7 +1359,7 @@ extension DSLTree.Atom {
       }
 
       printer.print("Regex {")
-      printer.pushMatchingOptions(matchingOptions.ast.adding)
+      printer.pushMatchingOptions(options, isAdded: isAdd)
     }
 
     return nil

Tests/RegexTests/RenderDSLTests.swift

@@ -306,7 +306,7 @@ extension RenderDSLTests {
   func testCharacterClass() throws {
     try testConversion(#"[abc]+"#, #"""
       Regex {
-        OneOrMore(.anyOf("abc"))
+        OneOrMore(CharacterClass.anyOf("abc"))
       }
       """#)
 
@@ -337,5 +337,56 @@ extension RenderDSLTests {
         }
       }
       """#)
+
+    try testConversion(#"[^i]*"#, #"""
+      Regex {
+        ZeroOrMore(CharacterClass.anyOf("i").inverted)
+      }
+      """#)
+  }
+
+  func testChangeMatchingOptions() throws {
+    try testConversion(#"(?s).*(?-s).*"#, #"""
+      Regex {
+        Regex {
+          ZeroOrMore {
+            /./
+          }
+          Regex {
+            ZeroOrMore {
+              /./
+            }
+          }
+          .dotMatchesNewlines(false)
+        }
+        .dotMatchesNewlines(true)
+      }
+      """#)
+
+    try testConversion(#"(?U)a+(?-U)a+"#, #"""
+      Regex {
+        OneOrMore(.reluctant) {
+          "a"
+        }
+        OneOrMore {
+          "a"
+        }
+      }
+      """#)
+
+    try testConversion(#"(?sim)hello(?-s)world"#, #"""
+      Regex {
+        Regex {
+          "hello"
+          Regex {
+            "world"
+          }
+          .dotMatchesNewlines(false)
+        }
+        .dotMatchesNewlines(true)
+        .ignoresCase(true)
+        .anchorsMatchLineEndings(true)
+      }
+      """#)
   }
 }