Rework the way the circled references are determine to avoid false-positive results

src/commonMain/kotlin/io/github/optimumcode/json/pointer/internal/extensions.kt

@@ -32,4 +32,15 @@ internal fun JsonPointer.dropLast(): JsonPointer? {
     return EmptyPointer
   }
   return JsonPointer.compile(fullPath.substring(0, lastPathPart))
+}
+
+internal fun JsonPointer.lastSegment(): String? {
+  var cur: JsonPointer? = this
+  while (cur != EmptyPointer) {
+    if (cur is SegmentPointer && cur.next is EmptyPointer) {
+      return cur.propertyName
+    }
+    cur = cur?.next
+  }
+  return null
 }

src/commonMain/kotlin/io/github/optimumcode/json/schema/internal/ReferenceValidator.kt

@@ -2,7 +2,8 @@ package io.github.optimumcode.json.schema.internal
 
 import com.eygraber.uri.Uri
 import io.github.optimumcode.json.pointer.JsonPointer
-import io.github.optimumcode.json.pointer.contains
+import io.github.optimumcode.json.pointer.internal.dropLast
+import io.github.optimumcode.json.pointer.internal.lastSegment
 import io.github.optimumcode.json.pointer.startsWith
 
 internal object ReferenceValidator {
@@ -34,8 +35,8 @@ internal object ReferenceValidator {
     checkCircledReferences(usedRef, referencesWithPath)
   }
 
-  private val alwaysRunAssertions = hashSetOf("allOf", "anyOf", "oneOf")
-  private val mightNotRun = hashSetOf("properties")
+  private val alwaysRunInPlaceApplicators = hashSetOf("allOf", "anyOf", "oneOf")
+  private val definitionProperties = hashSetOf("definitions", "\$defs")
 
   private fun checkCircledReferences(
     usedRefs: Set<ReferenceLocation>,
@@ -48,9 +49,12 @@ internal object ReferenceValidator {
 
     val circledReferences = hashSetOf<CircledReference>()
 
-    fun checkRunAlways(path: JsonPointer): Boolean {
-      return alwaysRunAssertions.any { path.contains(it) } && mightNotRun.none { path.contains(it) }
-    }
+    val refsByBaseId: Map<Uri, Set<JsonPointer>> =
+      referencesWithPath
+        .entries
+        .groupingBy { it.value.baseId }
+        .fold(hashSetOf()) { acc, el -> acc.apply { add(el.value.pointer) } }
+
     for ((location, refId) in locationToRef) {
       val schemaLocation: PointerWithBaseId = referencesWithPath.getValue(refId)
 
@@ -64,7 +68,12 @@ internal object ReferenceValidator {
       ) {
         continue
       }
-      if (checkRunAlways(location) && checkRunAlways(otherLocation) && location != otherLocation) {
+      val refsForBaseId = refsByBaseId[schemaLocation.baseId] ?: emptySet()
+      if (checkRunAlways(
+          location,
+          refsForBaseId,
+        ) && checkRunAlways(otherLocation, refsForBaseId) && location != otherLocation
+      ) {
         circledReferences +=
           CircledReference(
             firstLocation = location,
@@ -83,6 +92,31 @@ internal object ReferenceValidator {
     }
   }
 
+  private fun checkRunAlways(
+    path: JsonPointer,
+    schemaLocations: Set<JsonPointer>,
+  ): Boolean {
+    var curPath: JsonPointer? = path
+    while (curPath != null) {
+      val parentPath = curPath.dropLast()
+      // The idea here is the following:
+      // 'parentPath in schemaLocations' returns true only if the last segment is a schema keyword.
+      // If this is the case we should check if this keyword is not applied in-place.
+      // We also check that this keyword is not a definition as this would be incorrect.
+      // If this all is 'true' this is not a circled reference
+      if (
+        parentPath in schemaLocations &&
+        curPath.lastSegment()?.let {
+          it !in alwaysRunInPlaceApplicators && it !in definitionProperties
+        } == true
+      ) {
+        return false
+      }
+      curPath = parentPath
+    }
+    return true
+  }
+
   private class CircledReference(
     val firstLocation: JsonPointer,
     val firstRef: JsonPointer,

src/commonTest/kotlin/io/github/optimumcode/json/schema/base/JsonSchemaCircledReferencesTest.kt

@@ -0,0 +1,211 @@
+package io.github.optimumcode.json.schema.base
+
+import io.github.optimumcode.json.schema.JsonSchema
+import io.kotest.assertions.asClue
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+
+class JsonSchemaCircledReferencesTest : FunSpec() {
+  init {
+
+    listOf(
+      "oneOf",
+      "allOf",
+      "anyOf",
+    ).forEach {
+      test("reports circled references $it") {
+        shouldThrow<IllegalArgumentException> {
+          JsonSchema.fromDefinition(
+            """
+            {
+              "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+              "definitions": {
+                "alice": {
+                  "$it": [
+                    { "${KEY}ref": "#/definitions/bob" }
+                  ]
+                },
+                "bob": {
+                  "$it": [
+                    { "${KEY}ref": "#/definitions/alice" }
+                  ]
+                }
+              },
+              "properties": {
+                "alice": {
+                  "${KEY}ref": "#/definitions/alice"
+                },
+                "bob": {
+                  "${KEY}ref": "#/definitions/bob"
+                }
+              }
+            }
+            """.trimIndent(),
+          )
+        }.message shouldBe "circled references: /definitions/alice/$it/0 ref to /definitions/bob" +
+          " and /definitions/bob/$it/0 ref to /definitions/alice"
+      }
+    }
+
+    test("reports if properties is not the applicator") {
+      shouldThrow<IllegalArgumentException> {
+        JsonSchema.fromDefinition(
+          """
+          {
+            "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+            "definitions": {
+              "alice": {
+                "allOf": [
+                  { "${KEY}ref": "#/definitions/properties" }
+                ]
+              },
+              "properties": {
+                "allOf": [
+                  { "${KEY}ref": "#/definitions/alice" }
+                ]
+              }
+            },
+            "properties": {
+              "alice": {
+                "${KEY}ref": "#/definitions/alice"
+              },
+              "bob": {
+                "${KEY}ref": "#/definitions/properties"
+              }
+            }
+          }
+          """.trimIndent(),
+        )
+      }.message shouldBe "circled references: /definitions/alice/allOf/0 ref to /definitions/properties" +
+        " and /definitions/properties/allOf/0 ref to /definitions/alice"
+    }
+
+    test("does not report circled references if definitions have similar names") {
+      shouldNotThrowAny {
+        JsonSchema.fromDefinition(
+          """
+          {
+            "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+            "definitions": {
+              "nonNegativeInteger": {
+                  "type": "integer",
+                  "minimum": 0
+              },
+              "nonNegativeIntegerDefault0": {
+                  "allOf": [
+                      { "${KEY}ref": "#/definitions/nonNegativeInteger" },
+                      { "default": 0 }
+                  ]
+              }
+            }
+          }
+          """.trimIndent(),
+        )
+      }
+    }
+
+    test("does not report circled references if one is defined inside properties applicator") {
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "definitions": {
+          "alice": {
+            "allOf": [
+              { "${KEY}ref": "#/definitions/bob" }
+            ]
+          },
+          "bob": {
+            "properties": {
+              "test": {
+                "allOf": [
+                  { "${KEY}ref": "#/definitions/alice" }
+                ]
+              }
+            }
+          }
+        },
+        "properties": {
+          "alice": {
+            "${KEY}ref": "#/definitions/alice"
+          },
+          "bob": {
+            "${KEY}ref": "#/definitions/bob"
+          }
+        }
+      }
+      """.trimIndent().asClue {
+        shouldNotThrowAny {
+          JsonSchema.fromDefinition(it)
+        }
+      }
+
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "definitions": {
+          "alice": {
+            "properties": {
+              "test": {
+                "allOf": [
+                  { "${KEY}ref": "#/definitions/alice" }
+                ]
+              }
+            }
+          },
+          "bob": {
+            "allOf": [
+              { "${KEY}ref": "#/definitions/bob" }
+            ]
+          }
+        },
+        "properties": {
+          "alice": {
+            "${KEY}ref": "#/definitions/alice"
+          },
+          "bob": {
+            "${KEY}ref": "#/definitions/bob"
+          }
+        }
+      }
+      """.trimIndent().asClue {
+        shouldNotThrowAny {
+          JsonSchema.fromDefinition(it)
+        }
+      }
+    }
+
+    test("does not report circled references if property match allOf") {
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "definitions": {
+          "alice": {
+            "allOf": [
+              { "${KEY}ref": "#/definitions/bob" }
+            ]
+          },
+          "bob": {
+            "properties": {
+              "allOf": { "${KEY}ref": "#/definitions/alice" }
+            }
+          }
+        },
+        "properties": {
+          "alice": {
+            "${KEY}ref": "#/definitions/alice"
+          },
+          "bob": {
+            "${KEY}ref": "#/definitions/bob"
+          }
+        }
+      }
+      """.trimIndent().asClue {
+        shouldNotThrowAny {
+          JsonSchema.fromDefinition(it)
+        }
+      }
+    }
+  }
+}