fix(crystal): fix partial_oneof_module by using a class instead of a module

Fix #22563

Author: n-rodriguez

modules/openapi-generator/src/main/resources/crystal/partial_oneof_module.mustache

@@ -1,135 +1,104 @@
   {{#description}}
   # {{{.}}}
   {{/description}}
-  module {{classname}}
+  class {{classname}}
+    include JSON::Serializable
+    include YAML::Serializable
+
+    class SchemaMismatchError < Exception
+    end
+
     {{#oneOf}}
     {{#-first}}
     # List of class defined in oneOf (OpenAPI v3)
     def self.openapi_one_of
       [
     {{/-first}}
-        :"{{{.}}}"{{^-last}},{{/-last}}
+        {{{.}}}{{^-last}},{{/-last}}
     {{#-last}}
       ]
     end
 
     {{/-last}}
     {{/oneOf}}
-    {{#discriminator}}
-    {{#propertyName}}
-    # Discriminator's property name (OpenAPI v3)
-    def self.openapi_discriminator_name
-      :"{{{.}}}"
-    end
 
-    {{/propertyName}}
-    {{#mappedModels}}
-    {{#-first}}
-    # Discriminator's mapping (OpenAPI v3)
-    def self.openapi_discriminator_mapping
-      {
-    {{/-first}}
-        :"{{{mappingName}}}" => :"{{{modelName}}}"{{^-last}},{{/-last}}
-    {{#-last}}
-      }
-    end
-
-    {{/-last}}
-    {{/mappedModels}}
-    {{/discriminator}}
-    # Builds the object
-    # @param [Mixed] Data to be matched against the list of oneOf items
-    # @return [Object] Returns the model or the data itself
-    def self.build(data)
     {{#discriminator}}
-      discriminator_value = data[openapi_discriminator_name]
-      return nil unless discriminator_value
-    {{#mappedModels}}
-    {{#-first}}
-
-      klass = openapi_discriminator_mapping[discriminator_value.to_sym]
-      return nil unless klass
-
-      {{moduleName}}.const_get(klass).build_from_hash(data)
-    {{/-first}}
-    {{/mappedModels}}
-    {{^mappedModels}}
-      {{moduleName}}.const_get(discriminator_value).build_from_hash(data)
-    {{/mappedModels}}
+    use_yaml_discriminator {{#propertyName}}"{{{.}}}"{{/propertyName}}, {
+      {{#mappedModels}}{{{mappingName}}}: {{{modelName}}}{{^-last}},{{/-last}}{{/mappedModels}}
+    }
     {{/discriminator}}
-    {{^discriminator}}
-      # Go through the list of oneOf items and attempt to identify the appropriate one.
-      # Note:
-      # - We do not attempt to check whether exactly one item matches.
-      # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
-      #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
-      # - TODO: scalar values are de facto behaving as if they were nullable.
-      # - TODO: logging when debugging is set.
+
+    def self.build(data)
       openapi_one_of.each do |klass|
         begin
-          next if klass == :AnyType # "nullable: true"
           typed_data = find_and_cast_into_type(klass, data)
           return typed_data if typed_data
-        rescue # rescue all errors so we keep iterating even if the current item lookup raises
+        rescue ex
+          # rescue all errors so we keep iterating even if the current item lookup raises
+          Log.trace { ex.message }
         end
       end
 
-      openapi_one_of.includes?(:AnyType) ? data : nil
-    {{/discriminator}}
+      nil
     end
-    {{^discriminator}}
 
-    SchemaMismatchError = Class.new(StandardError)
-
-    # Note: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
-    private def self.find_and_cast_into_type(klass, data)
+    {{#oneOf}}
+    private def self.find_and_cast_into_type(klass : {{{.}}}.class, data)
       return if data.nil?
 
-      begin
-        case klass.to_s
-        when "Boolean"
-          return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
-        when "Float"
-          return data if data.instance_of?(Float)
-        when "Integer"
-          return data if data.instance_of?(Integer)
-        when "Time"
-          return Time.parse(data)
-        when "Date"
-          return Date.parse(data)
-        when "String"
-          return data if data.instance_of?(String)
-        when "Object" # "type: object"
-          return data if data.instance_of?(Hash)
-        when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
-          if data.instance_of?(Array)
-            sub_type = Regexp.last_match[:sub_type]
-            return data.map { |item| find_and_cast_into_type(sub_type, item) }
-          end
-        when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
-          if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
-            sub_type = Regexp.last_match[:sub_type]
-            return data.each_with_object({} of String | Symbol => Bool | Float | Integer | Time | Date | String | Array | Hash) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
-          end
-        else # model
-          const = {{moduleName}}.const_get(klass)
-          if const
-            if const.respond_to?(:openapi_one_of) # nested oneOf model
-              model = const.build(data)
-              return model if model
-            else
-              # raise if data contains keys that are not known to the model
-              raise unless (data.keys - const.acceptable_attributes).empty?
-              model = const.build_from_hash(data)
-              return model if model && model.valid?
-            end
-          end
+      Log.trace { "INSPECTING DATA" }
+      Log.trace { data.inspect }
+
+      case data
+      when NetboxClient::RecursiveHash
+        if (value = cast_value(array_data: false, array_class: array_class?(klass), klass: klass, data: data))
+          return new(value)
+        end
+      when Array(NetboxClient::RecursiveHash)
+        if (value = cast_value(array_data: true, array_class: array_class?(klass), klass: klass, data: data))
+          return new(value)
         end
+      else
+        raise SchemaMismatchError.new("#{data} doesn't match the #{klass} type")
+      end
+    end
+    {{/oneOf}}
+
+    private def self.cast_value(array_data : Bool, array_class : Bool, klass, data)
+      if array_class == true && array_data == true
+        Log.debug { "Building array of classes: #{klass} / #{data}" }
 
-        raise # if no match by now, raise
-      rescue
-        raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
+        klass.from_json(data.to_json)
+      elsif array_class == false && array_data == false
+        Log.debug { "Building single class: #{klass} / #{data}" }
+
+        klass.from_json(data.to_json)
+      end
+    end
+
+    private def self.array_class?(klass)
+      klass.name.starts_with?("Array(")
+    end
+
+    {{#oneOf}}
+    def initialize(@value : {{{.}}})
+    end
+
+    {{/oneOf}}
+
+    delegate :to_yaml, to: @value
+    delegate :to_json, to: @value
+
+    def to_any_h
+      {"value" => to_h}
+    end
+
+    def to_h
+      val = @value
+      if val.is_a?(Int32)
+        val
+      else
+        val.to_h
       end
     end
-    {{/discriminator}}
   end