implement recursive wildcard

codeniko · codeniko · commit 749d1f7a7246 · 2020-06-18T11:24:26.000-07:00
diff --git a/src/main/kotlin/com/nfeld/jsonpathkt/PathCompiler.kt b/src/main/kotlin/com/nfeld/jsonpathkt/PathCompiler.kt
@@ -27,11 +27,13 @@ internal object PathCompiler {
 
         fun addObjectAccessorToken() {
             val key = keyBuilder.toString()
-            when {
-                isDeepScan -> tokens.add(DeepScanObjectAccessorToken(listOf(key)))
-                isWildcard -> tokens.add(WildcardToken())
-                else -> tokens.add(ObjectAccessorToken(key))
+            val token = when {
+                isDeepScan && isWildcard -> DeepScanWildcardToken()
+                isDeepScan -> DeepScanObjectAccessorToken(listOf(key))
+                isWildcard -> WildcardToken()
+                else -> ObjectAccessorToken(key)
             }
+            tokens.add(token)
         }
 
         val len = path.length
@@ -40,6 +42,9 @@ internal object PathCompiler {
             val c = path[i]
             val next = path.getOrNull(i + 1)
             when {
+                c == '*' && isDeepScan -> {
+                    isWildcard = true
+                }
                 c == '.' -> {
                     if (keyBuilder.isNotEmpty() || isWildcard) {
                         addObjectAccessorToken()
@@ -68,6 +73,7 @@ internal object PathCompiler {
                         val token = compileBracket(path, i, closingBracketIndex)
                         if (isDeepScan) {
                             val deepScanToken: Token? = when (token) {
+                                is WildcardToken -> DeepScanWildcardToken()
                                 is ObjectAccessorToken -> DeepScanObjectAccessorToken(listOf(token.key))
                                 is MultiObjectAccessorToken -> DeepScanObjectAccessorToken(token.keys)
                                 is ArrayAccessorToken -> DeepScanArrayAccessorToken(listOf(token.index))
diff --git a/src/main/kotlin/com/nfeld/jsonpathkt/Token.kt b/src/main/kotlin/com/nfeld/jsonpathkt/Token.kt
@@ -352,9 +352,8 @@ internal data class DeepScanLengthBasedArrayAccessorToken(val startIndex: Int,
             }
             is ArrayNode -> {
                 ArrayLengthBasedRangeAccessorToken(startIndex, endIndex, offsetFromEnd)
-                    ?.read(node)
-                    ?.let { resultAny ->
-                        val resultArray = resultAny as? ArrayNode
+                    .read(node)?.let { resultNode ->
+                        val resultArray = resultNode as? ArrayNode
                         resultArray?.forEach { result.add(it) }
                     }
 
@@ -430,6 +429,51 @@ internal class WildcardToken : Token {
     override fun equals(other: Any?): Boolean = other is WildcardToken
 }
 
+internal class DeepScanWildcardToken : Token {
+    private fun scan(node: JsonNode, result: ArrayNode) {
+        when (node) {
+            is RootLevelArrayNode -> {
+                // no need to add anything on root level, scan down next level
+                node.forEach {
+                    if (it.isNotNullOrMissing()) {
+                        scan(it, result)
+                    }
+                }
+            }
+            is ObjectNode,
+            is ArrayNode -> {
+                WildcardToken().read(node)?.let {
+                    if (it is ArrayNode) {
+                        it.forEach {
+                            if (it.isNotNullOrMissing()) {
+                                result.add(it)
+                            }
+                        }
+                    }
+                }
+
+                // now recursively scan underlying objects/arrays
+                node.forEach {
+                    if (it.isNotNullOrMissing()) {
+                        scan(it, result)
+                    }
+                }
+            }
+            else -> {}
+        }
+    }
+
+    override fun read(json: JsonNode): JsonNode? {
+        val result = RootLevelArrayNode()
+        scan(json, result)
+        return result
+    }
+
+    override fun toString(): String = "DeepScanWildcardToken"
+    override fun hashCode(): Int = toString().hashCode()
+    override fun equals(other: Any?): Boolean = other is DeepScanWildcardToken
+}
+
 interface Token {
     /**
      * Takes in JsonNode and outputs next JsonNode or value by evaluating token against current object/array in path
diff --git a/src/test/kotlin/com/nfeld/jsonpathkt/JsonPathTest.kt b/src/test/kotlin/com/nfeld/jsonpathkt/JsonPathTest.kt
@@ -521,6 +521,16 @@ class JsonPathTest : DescribeSpec({
             JsonPath.parse("""[[1], [2,3]]""")!!.read<JsonNode>("$.*").toString() shouldBe """[[1],[2,3]]"""
             JsonPath.parse("""[[1], [2,3]]""")!!.read<JsonNode>("$.*.*").toString() shouldBe """[1,2,3]"""
             JsonPath.parse("""[[1], [2,3]]""")!!.read<JsonNode>("$.*.*.*").toString() shouldBe """[]"""
+
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$.*").toString() shouldBe """[1,[2],[3,4],[5,6,7,[8,9,10,11]]]"""
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$.*.*").toString() shouldBe """[2,3,4,5,6,7,[8,9,10,11]]"""
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$.*.*.*").toString() shouldBe """[8,9,10,11]"""
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$.*.*.*.*").toString() shouldBe """[]"""
+
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$..*").toString() shouldBe """[1,[2],[3,4],[5,6,7,[8,9,10,11]],2,3,4,5,6,7,[8,9,10,11],8,9,10,11]"""
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$..[*]").toString() shouldBe """[1,[2],[3,4],[5,6,7,[8,9,10,11]],2,3,4,5,6,7,[8,9,10,11],8,9,10,11]"""
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$..*.*").toString() shouldBe """[2,3,4,5,6,7,[8,9,10,11],8,9,10,11]"""
+            JsonPath.parse("""[1,[2],[3,4],[5,6,7,[8,9,10,11]]]""")!!.read<JsonNode>("$..*..*").toString() shouldBe """[2,3,4,5,6,7,[8,9,10,11],8,9,10,11,8,9,10,11]"""
         }
 
         it("should handle lists properly") {
diff --git a/src/test/kotlin/com/nfeld/jsonpathkt/PathCompilerTest.kt b/src/test/kotlin/com/nfeld/jsonpathkt/PathCompilerTest.kt
@@ -47,6 +47,10 @@ class PathCompilerTest : StringSpec({
         assertEquals(listOf(WildcardToken(), DeepScanObjectAccessorToken(listOf("key"))), f("$.*..key"))
         assertEquals(listOf(WildcardToken(), DeepScanArrayAccessorToken(listOf(1,2,3))), f("$.*..[1:4]"))
         f("""$..["key"]""") shouldBe listOf(DeepScanObjectAccessorToken(listOf("key")))
+        f("$..*") shouldBe listOf(DeepScanWildcardToken())
+        f("$..[*]") shouldBe listOf(DeepScanWildcardToken())
+        f("$..*..*") shouldBe listOf(DeepScanWildcardToken(), DeepScanWildcardToken())
+        f("$..[*]..[*]") shouldBe listOf(DeepScanWildcardToken(), DeepScanWildcardToken())
     }
 
     "should compile without root $ token" {
diff --git a/src/test/kotlin/com/nfeld/jsonpathkt/TokenTest.kt b/src/test/kotlin/com/nfeld/jsonpathkt/TokenTest.kt
@@ -367,5 +367,37 @@ class TokenTest : DescribeSpec({
                 WildcardToken().equals(RootLevelArrayNode()) shouldBe false
             }
         }
+
+        describe("DeepScanWildcardToken") {
+            it("should handle empty cases") {
+                WildcardToken().read(createArrayNode()).toString() shouldBe """[]"""
+                WildcardToken().read(createObjectNode()).toString() shouldBe """[]"""
+            }
+
+            it("should get values from objects and strip") {
+                val objectNode = readTree("""{ "some": "string", "int": 42, "object": { "key": "value" }, "array": [0, 1] }""")
+                WildcardToken().read(objectNode).toString() shouldBe """["string",42,{"key":"value"},[0,1]]"""
+            }
+
+            it("should return a RootLevelArrayNode if root list replaced with another list before modifying values") {
+                val arrayNode = readTree("""["string", 42, { "key": "value" }, [0, 1] ]""")
+                WildcardToken().read(arrayNode).toString() shouldBe """["string",42,{"key":"value"},[0,1]]"""
+            }
+
+            it("should drop scalars and move everything down on root RootLevelArrayNode") {
+                val arrayNode = readTree("""["string", 42, { "key": "value" }, [0, 1] ]""")
+                val res1 = WildcardToken().read(arrayNode)
+                (res1 is RootLevelArrayNode) shouldBe true
+                val res2 = WildcardToken().read(res1!!)
+                res2.toString() shouldBe """["value",0,1]"""
+            }
+
+            it("should override toString, hashCode, and equals") {
+                WildcardToken().toString() shouldBe "WildcardToken"
+                WildcardToken().hashCode() shouldBe "WildcardToken".hashCode()
+                WildcardToken().equals(WildcardToken()) shouldBe true
+                WildcardToken().equals(RootLevelArrayNode()) shouldBe false
+            }
+        }
     }
 })
