Add defenitions loading. Store paths to the loaded schemas

Author: Oleg

src/commonMain/kotlin/smirnov/oleg/json/schema/JsonSchema.kt

@@ -10,7 +10,9 @@ import smirnov.oleg.json.schema.internal.SchemaLoader
 import kotlin.jvm.JvmStatic
 
 class JsonSchema internal constructor(
+  private val baseId: String,
   private val assertion: JsonSchemaAssertion,
+  private val references: Map<String, JsonSchemaAssertion>,
 ) {
   fun validate(value: JsonElement, errorCollector: ErrorCollector): Boolean {
     return assertion.validate(value, DefaultAssertionContext(JsonPointer.ROOT), errorCollector)
@@ -20,8 +22,7 @@ class JsonSchema internal constructor(
     @JvmStatic
     fun fromDescription(schema: String): JsonSchema {
       val schemaElement: JsonElement = Json.parseToJsonElement(schema)
-      val schemaAssertion = SchemaLoader().load(schemaElement)
-      return JsonSchema(schemaAssertion)
+      return SchemaLoader().load(schemaElement)
     }
   }
 }

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/AssertionContext.kt

@@ -4,14 +4,14 @@ import smirnov.oleg.json.pointer.JsonPointer
 import smirnov.oleg.json.pointer.div
 import smirnov.oleg.json.pointer.get
 
-interface AssertionContext {
+internal interface AssertionContext {
   val objectPath: JsonPointer
 
   fun at(index: Int): AssertionContext
   fun at(property: String): AssertionContext
 }
 
-data class DefaultAssertionContext(
+internal data class DefaultAssertionContext(
   override val objectPath: JsonPointer,
 ) : AssertionContext {
   override fun at(index: Int): AssertionContext = copy(objectPath = objectPath[index])

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/AssertionFactory.kt

@@ -2,7 +2,7 @@ package smirnov.oleg.json.schema.internal
 
 import kotlinx.serialization.json.JsonElement
 
-interface AssertionFactory {
+internal interface AssertionFactory {
   /**
    * Checks whether the factory can create an assertion from the [element].
    *

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/AssertionsCollection.kt

@@ -3,7 +3,7 @@ package smirnov.oleg.json.schema.internal
 import kotlinx.serialization.json.JsonElement
 import smirnov.oleg.json.schema.ErrorCollector
 
-class AssertionsCollection(
+internal class AssertionsCollection(
   private val assertions: Collection<JsonSchemaAssertion>,
 ) : JsonSchemaAssertion {
 

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/JsonSchemaAssertion.kt

@@ -3,7 +3,7 @@ package smirnov.oleg.json.schema.internal
 import kotlinx.serialization.json.JsonElement
 import smirnov.oleg.json.schema.ErrorCollector
 
-interface JsonSchemaAssertion {
+internal interface JsonSchemaAssertion {
   /**
    * Validates passes [element].
    * If [element] does not pass the assertion returns `false` and calls [ErrorCollector.onError] on passed [errorCollector].

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/LoadingContext.kt

@@ -5,7 +5,7 @@ import smirnov.oleg.json.pointer.JsonPointer
 import smirnov.oleg.json.pointer.div
 import smirnov.oleg.json.pointer.get
 
-interface LoadingContext {
+internal interface LoadingContext {
   val schemaPath: JsonPointer
 
   fun at(property: String): LoadingContext

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/SchemaLoader.kt

@@ -8,6 +8,7 @@ import kotlinx.serialization.json.booleanOrNull
 import smirnov.oleg.json.pointer.JsonPointer
 import smirnov.oleg.json.pointer.div
 import smirnov.oleg.json.pointer.get
+import smirnov.oleg.json.schema.JsonSchema
 import smirnov.oleg.json.schema.internal.factories.array.ContainsAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.array.ItemsAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.array.MaxItemsAssertionFactory
@@ -64,47 +65,89 @@ private val factories: List<AssertionFactory> = listOf(
   NotAssertionFactory,
 )
 
+private const val DEFINITIONS_PROPERTY: String = "definitions"
+private const val ID_PROPERTY: String = "\$id"
+
+private const val rootReference = '#'
+
 class SchemaLoader {
-  fun load(schemaDefinition: JsonElement): JsonSchemaAssertion {
-    return loadSchema(schemaDefinition)
+  fun load(schemaDefinition: JsonElement): JsonSchema {
+    val baseId = extractBaseID(schemaDefinition)
+    val context = defaultLoadingContext(baseId)
+    loadDefinitions(schemaDefinition, context)
+    val schemaAssertion = loadSchema(schemaDefinition, context)
+    return JsonSchema(baseId, schemaAssertion, context.references)
   }
+
+  private fun loadDefinitions(schemaDefinition: JsonElement, context: DefaultLoadingContext) {
+    if (schemaDefinition !is JsonObject) {
+      return
+    }
+    val definitionsElement = schemaDefinition[DEFINITIONS_PROPERTY] ?: return
+    require(definitionsElement is JsonObject) { "$DEFINITIONS_PROPERTY must be an object" }
+    val definitionsContext = context.at(DEFINITIONS_PROPERTY)
+    for ((name, element) in definitionsElement) {
+      loadSchema(element, definitionsContext.at(name))
+    }
+  }
+
+  private fun extractBaseID(schemaDefinition: JsonElement): String =
+    when (schemaDefinition) {
+      is JsonObject -> {
+        schemaDefinition[ID_PROPERTY]?.let {
+          require(it is JsonPrimitive && it.isString) { "$ID_PROPERTY must be a string" }
+          it.content
+        } ?: ""
+      }
+
+      else -> ""
+    }.trimEnd(rootReference)
 }
 
 private fun loadSchema(
   schemaDefinition: JsonElement,
-  context: LoadingContext = defaultLoadingContext()
+  context: DefaultLoadingContext,
 ): JsonSchemaAssertion {
   require(context.isJsonSchema(schemaDefinition)) {
     "schema must be either a valid JSON object or boolean"
   }
-  if (schemaDefinition is JsonPrimitive) {
-    return if (schemaDefinition.boolean) {
+  return when (schemaDefinition) {
+    is JsonPrimitive -> if (schemaDefinition.boolean) {
       TrueSchemaAssertion
     } else {
       FalseSchemaAssertion(path = context.schemaPath)
     }
-  }
-  val assertions = factories.filter { it.isApplicable(schemaDefinition) }
-    .map {
-      it.create(schemaDefinition, context)
-    }
-  return AssertionsCollection(assertions)
+
+    else -> factories.filter { it.isApplicable(schemaDefinition) }
+      .map {
+        it.create(schemaDefinition, context)
+      }.let(::AssertionsCollection)
+  }.apply(context::register)
 }
 
 private data class DefaultLoadingContext(
+  private val baseId: String,
   override val schemaPath: JsonPointer = JsonPointer.ROOT,
+  val references: MutableMap<String, JsonSchemaAssertion> = hashMapOf(),
 ) : LoadingContext {
-  override fun at(property: String): LoadingContext {
+  override fun at(property: String): DefaultLoadingContext {
     return copy(schemaPath = schemaPath / property)
   }
 
-  override fun at(index: Int): LoadingContext {
+  override fun at(index: Int): DefaultLoadingContext {
     return copy(schemaPath = schemaPath[index])
   }
 
   override fun schemaFrom(element: JsonElement): JsonSchemaAssertion = loadSchema(element, this)
   override fun isJsonSchema(element: JsonElement): Boolean = (element is JsonObject
       || (element is JsonPrimitive && element.booleanOrNull != null))
+
+  fun register(assertion: JsonSchemaAssertion) {
+    val referenceId = "$baseId$rootReference$schemaPath"
+    references.put(referenceId, assertion)?.apply {
+      throw IllegalStateException("duplicated definition $referenceId")
+    }
+  }
 }
 
-private fun defaultLoadingContext(): DefaultLoadingContext = DefaultLoadingContext()
+private fun defaultLoadingContext(baseId: String): DefaultLoadingContext = DefaultLoadingContext(baseId)