Parser enhancements: anyOf, inline schemas, defaults

.gitignore

@@ -2,3 +2,4 @@ build/
 .gradle/
 .kotlin/
 .idea/
+.planning/

core/src/main/kotlin/com/avsystem/justworks/core/gen/InlineSchemaDeduplicator.kt

@@ -1,24 +1,32 @@
 package com.avsystem.justworks.core.gen
 
 import com.avsystem.justworks.core.model.PropertyModel
+import com.avsystem.justworks.core.model.SchemaModel
 import com.avsystem.justworks.core.model.TypeRef
 
 /**
  * Key for structural equality of inline schemas.
  * Two inline schemas are considered equal if they have the same properties
  * (name, type, required status) regardless of property order.
  */
-data class InlineSchemaKey(val properties: Set<PropertyKey>) {
+data class InlineSchemaKey(val properties: List<PropertyKey>, val requiredProperties: Set<String>,) {
     data class PropertyKey(
         val name: String,
         val type: TypeRef,
         val required: Boolean,
     )
 
     companion object {
-        fun from(properties: List<PropertyModel>, required: Set<String>) = InlineSchemaKey(
-            properties = properties.map { PropertyKey(it.name, it.type, it.name in required) }.toSet(),
-        )
+        /**
+         * Creates an InlineSchemaKey from properties and required set.
+         * Properties are sorted by name for deterministic equality.
+         */
+        fun from(properties: List<PropertyModel>, required: Set<String>): InlineSchemaKey {
+            val propKeys = properties
+                .map { PropertyKey(it.name, it.type, it.name in required) }
+                .sortedBy { it.name } // Deterministic ordering
+            return InlineSchemaKey(properties = propKeys, requiredProperties = required)
+        }
     }
 }
 
@@ -27,24 +35,48 @@ data class InlineSchemaKey(val properties: Set<PropertyKey>) {
  * Ensures that structurally identical inline schemas generate only one class,
  * and handles name collisions with component schemas.
  */
-class InlineSchemaDeduplicator(private val componentSchemaNames: Set<String>) {
+class InlineSchemaDeduplicator {
+    // Maps structural key to the first generated name for that structure
     private val namesByKey = mutableMapOf<InlineSchemaKey, String>()
 
+    // Names of all component schemas (from components/schemas in OpenAPI spec)
+    private val componentSchemaNames = mutableSetOf<String>()
+
+    /**
+     * Registers component schema names to detect collisions.
+     */
+    fun registerComponentSchemas(schemas: List<SchemaModel>) {
+        componentSchemaNames.addAll(schemas.map { it.name })
+    }
+
+    /**
+     * Gets or generates a name for an inline schema.
+     * If a structurally identical schema was already seen, returns its name (deduplication).
+     * If the context name collides with a component schema or another inline schema,
+     * appends "Inline" suffix.
+     *
+     * @param properties The properties of the inline schema
+     * @param requiredProps The set of required property names
+     * @param contextName The base name derived from context (e.g., "PostPetRequest")
+     * @return The final name to use for this inline schema
+     */
     fun getOrGenerateName(
         properties: List<PropertyModel>,
         requiredProps: Set<String>,
         contextName: String,
-    ): String = namesByKey.getOrPut(InlineSchemaKey.from(properties, requiredProps)) {
-        val inlineName = contextName.toInlinedName()
-        val candidates = sequence {
-            yield(inlineName)
-            yield("${inlineName}Inline")
-            generateSequence(2) { it + 1 }.forEach {
-                yield("${inlineName}${it}Inline")
-            }
+    ): String {
+        val key = InlineSchemaKey.from(properties, requiredProps)
+
+        // Check if we've already generated a name for this structure
+        namesByKey[key]?.let { return it }
+
+        // Generate new name, handling collisions
+        var finalName = contextName
+        if (finalName in componentSchemaNames || finalName in namesByKey.values) {
+            finalName = "${contextName}Inline"
         }
 
-        val existingNames = (componentSchemaNames + namesByKey.values).toSet()
-        candidates.first { it !in existingNames }
+        namesByKey[key] = finalName
+        return finalName
     }
 }