support !(...) in tag filter syntax

... to have feature parity with streetcomplete, see streetcomplete/StreetComplete#5107

library/src/commonMain/kotlin/de/westnordost/osm_legal_default_speeds/tagfilter/BooleanExpression.kt

@@ -12,7 +12,7 @@ internal abstract class Chain<I : Matcher<T>, T> : BooleanExpression<I, T>() {
 
     val children: List<BooleanExpression<I, T>> get() = nodes.toList()
 
-    fun addChild(child: BooleanExpression<I, T>) {
+    open fun addChild(child: BooleanExpression<I, T>) {
         child.parent = this
         nodes.add(child)
     }
@@ -55,7 +55,7 @@ internal abstract class Chain<I : Matcher<T>, T> : BooleanExpression<I, T>() {
         val it = nodes.listIterator()
         while (it.hasNext()) {
             val child = it.next() as? Chain ?: continue
-            if (child.nodes.size == 1) {
+            if (child.nodes.size == 1 && child !is Not<I, T>) {
                 replaceChildAt(it, child.nodes.first())
                 it.previous() // = the just replaced node will be checked again
             } else {
@@ -69,6 +69,9 @@ internal abstract class Chain<I : Matcher<T>, T> : BooleanExpression<I, T>() {
         val it = nodes.listIterator()
         while (it.hasNext()) {
             val child = it.next() as? Chain ?: continue
+            if (child is Not<I, T>) {
+                continue
+            }
             child.mergeNodesWithSameOperator()
 
             // merge two successive nodes of same type
@@ -128,6 +131,18 @@ internal class AnyOf<I : Matcher<T>, T> : Chain<I, T>() {
         nodes.joinToString(" or ") { "$it" }
 }
 
+internal class Not<I : Matcher<T>, T> : Chain<I, T>() {
+    override fun addChild(child: BooleanExpression<I, T>) {
+        check(nodes.isEmpty()) { "Adding a second child to '!' (NOT) operator is not allowed" }
+        super.addChild(child)
+    }
+
+    override fun matches(obj: T, evaluate: (name: String) -> Boolean) =
+        !nodes.first().matches(obj, evaluate)
+
+    override fun toString() = "!(${nodes.firstOrNull() ?: ""})"
+}
+
 internal interface Matcher<in T> {
     fun matches(obj: T): Boolean
 }

library/src/commonMain/kotlin/de/westnordost/osm_legal_default_speeds/tagfilter/BooleanExpressionBuilder.kt

@@ -45,6 +45,12 @@ internal class BooleanExpressionBuilder<I : Matcher<T>, T> {
             node = node.parent!!
         }
         node = node.parent!!
+
+        if (node is Not)
+        {
+            node = node.parent!!
+        }
+
         node.flatten()
     }
 
@@ -93,6 +99,12 @@ internal class BooleanExpressionBuilder<I : Matcher<T>, T> {
             node = anyOf
         }
     }
+
+    fun addNot() {
+        val not = Not<I, T>()
+        node.addChild(not)
+        node = not
+    }
 }
 
 private fun <I : Matcher<T>, T> Chain<I, T>.ensureNoBracketNodes() {

library/src/commonMain/kotlin/de/westnordost/osm_legal_default_speeds/tagfilter/TagFilterExpressionParser.kt

@@ -33,6 +33,7 @@ import kotlin.math.min
  *  | `shop and name`                | has both a tag with key `shop` and one with key `name`                        |
  *  | `shop or craft`                | has either a tag with key `shop` or one with key `craft`                      |
  *  | `shop and (ref or name)`       | has a tag with key `shop` and either a tag with key `ref` or `name`           |
+ *  | `shop and !(ref or name)`      | hat a tag with key `shop` but not either a tag with key `ref` or `name`       |
  *
  *  ### Equivalent expressions
  *  | expression                     | equivalent expression                                    |
@@ -41,7 +42,8 @@ import kotlin.math.min
  *  | `!shop or shop != boat`        | `shop != boat`                                           |
  *  | `shop = car or shop = boat`    | `shop ~ car|boat`                                        |
  *  | `craft or shop and name`       | `craft or (shop and name)` (`and` has higher precedence) |
- *  | `!(amenity and craft)`         | **<error>** (negation of expression not supported)       |
+ *  | `!(amenity and craft)`         | `!amenity or !craft`                                     |
+ *  | `!(amenity or craft)`          | `!amenity and !craft`                                    |
  *  */
 
 private const val OR = "or"
@@ -81,6 +83,7 @@ private val OPERATORS = linkedSetOf(
 private val ESCAPED_QUOTE_REGEX = Regex("\\\\(['\"])")
 private val WHITESPACE_REGEX = Regex("\\s")
 private val WHITESPACES_REGEX = Regex("\\s*")
+private val NOT_WITH_WHITESPACE_AND_OPENING_BRACE = Regex("!\\s*\\(")
 
 internal fun StringWithCursor.parseTags(): BooleanExpression<TagFilter, Map<String, String>> {
     val builder = BooleanExpressionBuilder<TagFilter, Map<String, String>>()
@@ -93,6 +96,13 @@ internal fun StringWithCursor.parseTags(): BooleanExpression<TagFilter, Map<Stri
         }
         first = false
 
+        if (nextMatches(NOT_WITH_WHITESPACE_AND_OPENING_BRACE) != null) {
+            advanceBy(NOT.length)
+            builder.addNot()
+            // continue is required, as !( could be nested
+            continue
+        }
+
         if (nextIsAndAdvance(NOT + PLACEHOLDER_START)) {
             builder.addNotPlaceholder(parsePlaceholder())
         } else if (nextIsAndAdvance(PLACEHOLDER_START)) {
@@ -105,7 +115,7 @@ internal fun StringWithCursor.parseTags(): BooleanExpression<TagFilter, Map<Stri
 
         if (isAtEnd()) break
 
-        // same as with the opening bracket, only that if the string is over, its okay
+        // same as with the opening bracket, only that if the string is over, it's okay
         if (!separated) {
             throw ParseException("Expected a whitespace or bracket after the tag", cursorPos)
         }

library/src/commonTest/kotlin/de/westnordost/osm_legal_default_speeds/tagfilter/BooleanExpressionTest.kt

@@ -69,7 +69,6 @@ internal class BooleanExpressionTest {
     }
 
     @Test fun list_items() {
-        assertEquals(listOf("1"), getItems("1"))
         assertEquals(listOf("1","2"), getItems("1+2"))
         assertEquals(listOf("1","2"), getItems("1*2"))
         assertEquals(listOf("1","2","3"), getItems("1*(2+3)"))

library/src/commonTest/kotlin/de/westnordost/osm_legal_default_speeds/tagfilter/TagFilterExpressionParserTest.kt

@@ -388,6 +388,78 @@ internal class TagFilterExpressionParserTest {
         notMatches(mapOfKeys("b", "c"), expr)
     }
 
+    @Test fun not_with_leaf() {
+        val expr = "!(a)"
+        matches(mapOfKeys("b"), expr)
+        notMatches(mapOfKeys("a"), expr)
+        notMatches(mapOfKeys("a", "b"), expr)
+    }
+
+    @Test fun not_without_braces() {
+        val expr = "ways with !highway = residential or access = yes"
+        shouldFail(expr)
+    }
+
+    @Test fun not_and_with_space() {
+        val expr = "! (a and b)"
+        matches(mapOfKeys("a"), expr)
+        matches(mapOfKeys("b"), expr)
+        matches(mapOfKeys("b", "c"), expr)
+        matches(mapOfKeys("c"), expr)
+        notMatches(mapOfKeys("a", "b", "c"), expr)
+    }
+
+    @Test fun not_and() {
+        val expr = "!(a and b)"
+        matches(mapOfKeys("a"), expr)
+        matches(mapOfKeys("b"), expr)
+        matches(mapOfKeys("b", "c"), expr)
+        matches(mapOfKeys("c"), expr)
+        notMatches(mapOfKeys("a", "b", "c"), expr)
+    }
+
+    @Test fun not_or() {
+        val expr = "!(a or b)"
+        matches(mapOfKeys("c"), expr)
+        matches(mapOfKeys("c", "d", "e"), expr)
+        notMatches(mapOfKeys("a"), expr)
+        notMatches(mapOfKeys("b"), expr)
+        notMatches(mapOfKeys("b", "c"), expr)
+        notMatches(mapOfKeys("a", "c"), expr)
+        notMatches(mapOfKeys("a", "b", "c"), expr)
+    }
+
+    @Test fun nested_not() {
+        val expr = "!(!(a))" // equals the expression "a"
+        matches(mapOfKeys("a"), expr)
+        matches(mapOfKeys("a", "b"), expr)
+        notMatches(mapOfKeys("b"), expr)
+    }
+
+    @Test fun nested_not_with_or() {
+        val expr = "!(!(a and b) or c)" // equals a and b and !(c)
+        matches(mapOfKeys("a", "b"), expr)
+        matches(mapOfKeys("a", "b", "d"), expr)
+        notMatches(mapOfKeys("a"), expr)
+        notMatches(mapOfKeys("c"), expr)
+        notMatches(mapOfKeys("b", "c"), expr)
+        notMatches(mapOfKeys("a", "b", "c"), expr)
+        notMatches(mapOfKeys("a", "b", "c", "d"), expr)
+    }
+
+    @Test fun nested_not_with_or_and_switched_operands() {
+        val expr = "!(c or !(a and b))" // equals a and b and !(c)
+        matches(mapOfKeys("a", "b"), expr)
+        matches(mapOfKeys("a", "b", "d"), expr)
+        notMatches(mapOfKeys("a"), expr)
+        notMatches(mapOfKeys("c"), expr)
+        notMatches(mapOfKeys("b", "c"), expr)
+        notMatches(mapOfKeys("a", "b", "c"), expr)
+        notMatches(mapOfKeys("a", "b", "c", "d"), expr)
+    }
+
+
+
     @Test fun fail_on_placeholder_not_closed() {
         shouldFail("{my placeholder")
     }

library/src/commonTest/kotlin/de/westnordost/osm_legal_default_speeds/tagfilter/filters/NotHasKeyLikeTest.kt

@@ -21,6 +21,6 @@ internal class NotHasKeyLikeTest {
 
     @Test fun relevantKey() {
         val key = NotHasKeyLike("n.[ms]e")
-        assertEquals("n.[ms]e", (key.relevantKey.regex as RealRegex).toString())
+        assertTrue(key.relevantKey.regex is RealRegex)
     }
 }