apimatic_core 0.2.2 → 0.3.0

data/lib/apimatic-core/types/union_types/leaf_type.rb

@@ -0,0 +1,298 @@
+module CoreLibrary
+  # Represents a leaf type in a UnionType
+  class LeafType < UnionType
+    attr_reader :type_to_match
+
+    # Initializes a new instance of LeafType
+    # @param type_to_match [Class] The type to match against
+    # @param union_type_context [UnionTypeContext] The UnionTypeContext associated with the leaf type
+    def initialize(type_to_match, union_type_context = UnionTypeContext.new)
+      super(nil, union_type_context)
+      @type_to_match = type_to_match
+    end
+
+    # Validates a value against the leaf type
+    # @param value [Object] The value to validate
+    # @return [LeafType] The current LeafType object
+    def validate(value)
+      context = @union_type_context
+
+      @is_valid = if value.nil?
+                    context.nullable_or_optional?
+                  else
+                    validate_value_against_case(value, context)
+                  end
+
+      self
+    end
+
+    def serialize(value)
+      return nil if value.nil?
+
+      serialize_value_against_case(value, @union_type_context)
+    end
+
+    # Deserializes a value based on the leaf type
+    # @param value [Object] The value to deserialize
+    # @param should_symbolize [Boolean] Indicates whether the deserialized value should be symbolized.
+    # @return [Object, nil] The deserialized value or nil if the input value is nil
+    def deserialize(value, should_symbolize: false)
+      return nil if value.nil?
+
+      deserialize_value_against_case(value, @union_type_context, should_symbolize: should_symbolize)
+    end
+
+    private
+
+    def validate_value_against_case(value, context)
+      if context.is_array && context.is_dict && context.is_array_of_dict
+        validate_array_of_dict_case(value)
+      elsif context.is_array && context.is_dict
+        validate_dict_of_array_case(value)
+      elsif context.is_array
+        validate_array_case(value)
+      elsif context.is_dict
+        validate_dict_case(value)
+      else
+        validate_simple_case(value)
+      end
+    end
+
+    def validate_dict_case(dict_value)
+      return false unless dict_value.instance_of?(Hash)
+
+      dict_value.each do |_key, value|
+        is_valid = validate_simple_case(value)
+        return false unless is_valid
+      end
+
+      true
+    end
+
+    def validate_dict_of_array_case(dict_value)
+      return false unless dict_value.instance_of?(Hash)
+
+      dict_value.each do |_key, value|
+        is_valid = validate_array_case(value)
+        return false unless is_valid
+      end
+
+      true
+    end
+
+    def validate_array_case(array_value)
+      return false unless array_value.instance_of?(Array)
+
+      array_value.each do |item|
+        is_valid = validate_simple_case(item)
+        return false unless is_valid
+      end
+
+      true
+    end
+
+    def validate_array_of_dict_case(array_value)
+      return false unless array_value.instance_of?(Array)
+
+      array_value.each do |item|
+        is_valid = validate_dict_case(item)
+        return false unless is_valid
+      end
+
+      true
+    end
+
+    def validate_simple_case(value)
+      context = @union_type_context
+
+      if value.nil? || context.nullable_or_optional?
+        true
+      elsif value.nil? || value.instance_of?(Array)
+        false
+      else
+        validate_value(value, context)
+      end
+    end
+
+    def validate_value(value, context)
+      if @type_to_match == DateTime
+        dt_string = if value.instance_of?(DateTime) && context.date_time_converter
+                      context.date_time_converter.call(value)
+                    else
+                      value
+                    end
+
+        DateTimeHelper.valid_datetime?(context.date_time_format, dt_string)
+      elsif @type_to_match == Date
+        DateTimeHelper.valid_date?(value)
+      else
+        validate_value_with_discriminator(value, context)
+      end
+    end
+
+    def validate_value_with_discriminator(value, context)
+      discriminator = context.discriminator
+      discriminator_value = context.discriminator_value
+
+      if discriminator && discriminator_value
+        validate_with_discriminator(discriminator, discriminator_value, value)
+      elsif @type_to_match.respond_to?(:validate)
+        @type_to_match.validate(value)
+      else
+        value.instance_of?(@type_to_match)
+      end
+    end
+
+    def validate_with_discriminator(discriminator, discriminator_value, value)
+      return false unless value.instance_of?(Hash) && value[discriminator] == discriminator_value
+
+      if @type_to_match.respond_to?(:validate)
+        @type_to_match.validate(value)
+      else
+        value.instance_of?(@type_to_match)
+      end
+    end
+
+    def serialize_value_against_case(value, context)
+      if context.is_array && context.is_dict && context.is_array_of_dict
+        serialize_array_of_dict_case(value)
+      elsif context.is_array && context.is_dict
+        serialize_dict_of_array_case(value)
+      elsif context.is_array
+        serialize_array_case(value)
+      elsif context.is_dict
+        serialize_dict_case(value)
+      else
+        serialize_simple_case(value)
+      end
+    end
+
+    def serialize_dict_case(dict_value)
+      serialized_value = {}
+
+      dict_value.each do |key, value|
+        result_value = serialize_simple_case(value)
+        serialized_value[key] = result_value
+      end
+
+      serialized_value
+    end
+
+    def serialize_dict_of_array_case(dict_value)
+      serialized_value = {}
+
+      dict_value.each do |key, value|
+        result_value = serialize_array_case(value)
+        serialized_value[key] = result_value
+      end
+
+      serialized_value
+    end
+
+    def serialize_array_case(array_value)
+      serialized_value = []
+
+      array_value.each do |item|
+        result_value = serialize_simple_case(item)
+        serialized_value << result_value
+      end
+
+      serialized_value
+    end
+
+    def serialize_array_of_dict_case(array_value)
+      serialized_value = []
+
+      array_value.each do |item|
+        result_value = serialize_dict_case(item)
+        serialized_value << result_value
+      end
+
+      serialized_value
+    end
+
+    def serialize_simple_case(value)
+      case @union_type_context.date_time_format
+      when DateTimeFormat::HTTP_DATE_TIME
+        return DateTimeHelper.to_rfc1123(value)
+      when DateTimeFormat::RFC3339_DATE_TIME
+        return DateTimeHelper.to_rfc3339(value)
+      when DateTimeFormat::UNIX_DATE_TIME
+        return DateTimeHelper.to_unix(value)
+      end
+
+      value
+    end
+
+    def deserialize_value_against_case(value, context, should_symbolize: false)
+      if context.is_array && context.is_dict && context.is_array_of_dict
+        deserialize_array_of_dict_case(value, should_symbolize: should_symbolize)
+      elsif context.is_array && context.is_dict
+        deserialize_dict_of_array_case(value, should_symbolize: should_symbolize)
+      elsif context.is_array
+        deserialize_array_case(value, should_symbolize: should_symbolize)
+      elsif context.is_dict
+        deserialize_dict_case(value, should_symbolize: should_symbolize)
+      else
+        deserialize_simple_case(value, should_symbolize: should_symbolize)
+      end
+    end
+
+    def deserialize_dict_case(dict_value, should_symbolize: false)
+      deserialized_value = {}
+
+      dict_value.each do |key, value|
+        result_value = deserialize_simple_case(value, should_symbolize: should_symbolize)
+        deserialized_value[key] = result_value
+      end
+
+      deserialized_value
+    end
+
+    def deserialize_dict_of_array_case(dict_value, should_symbolize: false)
+      deserialized_value = {}
+
+      dict_value.each do |key, value|
+        result_value = deserialize_array_case(value, should_symbolize: should_symbolize)
+        deserialized_value[key] = result_value
+      end
+
+      deserialized_value
+    end
+
+    def deserialize_array_case(array_value, should_symbolize: false)
+      deserialized_value = []
+
+      array_value.each do |item|
+        result_value = deserialize_simple_case(item, should_symbolize: should_symbolize)
+        deserialized_value << result_value
+      end
+
+      deserialized_value
+    end
+
+    def deserialize_array_of_dict_case(array_value, should_symbolize: false)
+      deserialized_value = []
+
+      array_value.each do |item|
+        result_value = deserialize_dict_case(item, should_symbolize: should_symbolize)
+        deserialized_value << result_value
+      end
+
+      deserialized_value
+    end
+
+    def deserialize_simple_case(value, should_symbolize: false)
+      if @type_to_match.respond_to?(:from_hash)
+        @type_to_match.from_hash(value)
+      elsif @type_to_match == Date
+        ApiHelper.date_deserializer(value, false, should_symbolize: should_symbolize)
+      elsif @type_to_match == DateTime
+        ApiHelper.deserialize_datetime(value, @union_type_context.date_time_format,
+                                       false, should_symbolize: should_symbolize)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/apimatic-core/types/union_types/one_of.rb

@@ -0,0 +1,90 @@
+module CoreLibrary
+  # Represents the OneOf union type in the core library
+  class OneOf < UnionType
+    # Initializes a new instance of OneOf
+    # @param union_types [Array] The array of nested union types
+    # @param union_type_context [UnionTypeContext] The context for the union type
+    def initialize(union_types, union_type_context = UnionTypeContext.new)
+      super(union_types, union_type_context)
+      @collection_cases = nil
+    end
+
+    # Validates a value against the OneOf union type
+    # @param value [Object] The value to validate
+    # @return [OneOf] The validated OneOf object
+    def validate(value)
+      context = @union_type_context
+      UnionTypeHelper.update_nested_flag_for_union_types(@union_types)
+      is_optional_or_nullable = UnionTypeHelper.optional_or_nullable_case?(
+        context,
+        @union_types.map(&:union_type_context)
+      )
+
+      if value.nil? && is_optional_or_nullable
+        @is_valid = true
+        return self
+      end
+
+      if value.nil?
+        @is_valid = false
+        @error_messages = UnionTypeHelper.process_errors(value, @union_types, @error_messages,
+                                                         union_type_context.is_nested, true)
+      end
+
+      _validate_value_against_case(value, context)
+
+      unless @is_valid
+        @error_messages = UnionTypeHelper.process_errors(value, @union_types, @error_messages,
+                                                         union_type_context.is_nested, true)
+      end
+
+      self
+    end
+
+    # Serializes a given value.
+    # @param value [Object] The value to be serialized.
+    # @return [Object, nil] The serialized representation of the value, or nil if the value is nil.
+    def serialize(value)
+      return nil if value.nil?
+
+      UnionTypeHelper.serialize_value(
+        value,
+        @union_type_context,
+        @collection_cases,
+        @union_types
+      )
+    end
+
+    # Deserializes a value based on the OneOf union type
+    # @param value [Object] The value to deserialize
+    # @param should_symbolize [Boolean] Indicates whether the deserialized value should be symbolized.
+    # @return [Object, nil] The deserialized value, or nil if the input value is nil
+    def deserialize(value, should_symbolize: false)
+      return nil if value.nil?
+
+      UnionTypeHelper.deserialize_value(value, @union_type_context, @collection_cases,
+                                        @union_types, should_symbolize: should_symbolize)
+    end
+
+    private
+
+    # Validates a value against the appropriate case of the OneOf union type
+    # @param value [Object] The value to validate
+    # @param context [UnionTypeContext] The context for the union type
+    def _validate_value_against_case(value, context)
+      if context.is_array && context.is_dict && context.is_array_of_dict
+        @is_valid, @collection_cases = UnionTypeHelper.validate_array_of_dict_case(@union_types, value,
+                                                                                   true)
+      elsif context.is_array && context.is_dict
+        @is_valid, @collection_cases = UnionTypeHelper.validate_dict_of_array_case(@union_types, value,
+                                                                                   true)
+      elsif context.is_array
+        @is_valid, @collection_cases = UnionTypeHelper.validate_array_case(@union_types, value, true)
+      elsif context.is_dict
+        @is_valid, @collection_cases = UnionTypeHelper.validate_dict_case(@union_types, value, true)
+      else
+        @is_valid = UnionTypeHelper.get_matched_count(value, @union_types, true) == 1
+      end
+    end
+  end
+end

data/lib/apimatic-core/types/union_types/union_type_context.rb

@@ -0,0 +1,30 @@
+module CoreLibrary
+  # Represents the context for a UnionType
+  class UnionTypeContext
+    attr_reader :is_array, :is_dict, :is_array_of_dict, :is_optional,
+                :is_nullable, :date_time_format, :date_time_converter
+
+    attr_accessor :is_nested, :discriminator, :discriminator_value
+
+    # Initializes a new instance of UnionTypeContext
+    def initialize(is_array: false, is_dict: false, is_array_of_dict: false, is_optional: false, is_nullable: false,
+                   discriminator: nil, discriminator_value: nil, date_time_format: nil, date_time_converter: nil)
+      @is_array = is_array
+      @is_dict = is_dict
+      @is_array_of_dict = is_array_of_dict
+      @is_optional = is_optional
+      @is_nullable = is_nullable
+      @discriminator = discriminator
+      @discriminator_value = discriminator_value
+      @date_time_format = date_time_format
+      @date_time_converter = date_time_converter
+      @is_nested = false
+    end
+
+    # Determines if the UnionTypeContext is nullable or optional
+    # @return [Boolean] True if the context is nullable or optional, false otherwise
+    def nullable_or_optional?
+      @is_nullable || @is_optional
+    end
+  end
+end

data/lib/apimatic-core/utilities/api_helper.rb

@@ -72,9 +72,7 @@ module CoreLibrary
     # Deserializer to use when the type of response is not known beforehand.
     # @param response The response received.
     def self.dynamic_deserializer(response, should_symbolize)
-      decoded = json_deserialize(response, should_symbolize) unless response.nil? ||
-                                                                    response.to_s.strip.empty?
-      decoded
+      json_deserialize(response, should_symbolize) unless response.nil? || response.to_s.strip.empty?
     end
 
     # Deserializes response to a known custom model type.
@@ -228,19 +226,73 @@ module CoreLibrary
       protocol + query + parameters
     end
 
-    # Parses JSON string.
+    # Deserialize the response based on the provided union_type.
+    # @param [UnionType] union_type The union type to validate and deserialize the response.
+    # @param [Object] response The response object to be deserialized.
+    # @param [Boolean] should_deserialize Flag indicating whether the response should be deserialized.
+    #                                    Default is true.
+    # @return [Object] The deserialized response based on the union_type.
+    def self.deserialize_union_type(union_type, response, should_symbolize = false, should_deserialize = false)
+      response = ApiHelper.json_deserialize(response, false, true) if should_deserialize
+
+      union_type_result = union_type.validate(response)
+
+      union_type_result.deserialize(response, should_symbolize: should_symbolize)
+    end
+
+    # Applies a primitive type parser to deserialize a value.
+    # @param [String] value The value to be parsed.
+    # @return [Integer, Float, Boolean, String] The deserialized value,
+    #   which can be an Integer, Float, Boolean, or String.
+    def self.apply_primitive_type_parser(value)
+      # Attempt to deserialize as Integer
+      return value.to_i if value.match?(/^\d+$/)
+
+      # Attempt to deserialize as Float
+      return value.to_f if value.match?(/^\d+(\.\d+)?$/)
+
+      # Attempt to deserialize as Boolean
+      return true if value.downcase == 'true'
+      return false if value.downcase == 'false'
+
+      # Default: return the original string
+      value
+    end
+
+    # Checks if a value or all values in a nested structure satisfy a given type condition.
+    # @param [Object] value The value or nested structure to be checked.
+    # @param [Proc] type_callable A callable object that defines the type condition.
+    # @return [Boolean] Returns true if the value or all values in the
+    #   structure satisfy the type condition, false otherwise.
+    def self.valid_type?(value, type_callable)
+      if value.is_a?(Array)
+        value.all? { |item| valid_type?(item, type_callable) }
+      elsif value.is_a?(Hash)
+        value.values.all? { |item| valid_type?(item, type_callable) }
+      else
+        !value.nil? && type_callable.call(value)
+      end
+    end
+
+    # Parses a JSON string.
     # @param [String] json A JSON string.
-    # rubocop:disable Style/OptionalBooleanParameter
-    def self.json_deserialize(json, should_symbolize = false)
+    # @param [Boolean] should_symbolize Determines whether the keys should be symbolized.
+    #   If set to true, the keys will be converted to symbols. Defaults to false.
+    # @param [Boolean] allow_primitive_type_parsing Determines whether to allow parsing of primitive types.
+    #   If set to true, the method will attempt to parse primitive types like numbers and booleans. Defaults to false.
+    # @return [Hash, Array, nil] The parsed JSON object, or nil if the input string is nil.
+    # @raise [TypeError] if the server responds with invalid JSON and primitive type parsing is not allowed.
+    def self.json_deserialize(json, should_symbolize = false, allow_primitive_type_parsing = false)
       return if json.nil?
 
       begin
         JSON.parse(json, symbolize_names: should_symbolize)
       rescue StandardError
-        raise TypeError, 'Server responded with invalid JSON.'
+        raise TypeError, 'Server responded with invalid JSON.' unless allow_primitive_type_parsing
+
+        ApiHelper.apply_primitive_type_parser(json)
       end
     end
-    # rubocop:enable Style/OptionalBooleanParameter
 
     # Parses JSON string.
     # @param [object] obj The object to serialize.
@@ -383,154 +435,6 @@ module CoreLibrary
       val
     end
 
-    # Deserialize the value against the template (group of types).
-    # @param [String] value The value to be deserialized.
-    # @param [String] template The type-combination group for which the value will be mapped (oneOf(Integer, String)).
-    def self.deserialize(template, value, sdk_module, should_symbolize)
-      decoded = json_deserialize(value, should_symbolize)
-      map_types(decoded, template, sdk_module: sdk_module)
-    end
-
-    # Validates and processes the value against the template(group of types).
-    # @param [String] value The value to be mapped against the template.
-    # @param [String] template The parameter indicates the group of types (oneOf(Integer, String)).
-    # @param [String] group_name The parameter indicates the group (oneOf|anyOf).
-    def self.map_types(value, template, group_name: nil, sdk_module: nil)
-      result_value = nil
-      matches = 0
-      types = []
-      group_name = template.partition('(').first if group_name.nil? && template.match?(/anyOf|oneOf/)
-
-      return if value.nil?
-
-      if template.end_with?('{}') || template.end_with?('[]')
-        types = template.split(group_name, 2).last.gsub(/\s+/, '').split
-      else
-        template = template.split(group_name, 2).last.delete_prefix('(').delete_suffix(')')
-        types = template.scan(/(anyOf|oneOf)[(]([^[)]]*)[)]/).flatten.combination(2).map { |a, b| "#{a}(#{b})" }
-        types.each { |t| template = template.gsub(", #{t}", '') }
-        types = template.gsub(/\s+/, '').split(',').push(*types)
-      end
-      types.each do |element|
-        if element.match?(/^(oneOf|anyOf)[(].*$/)
-          begin
-            result_value = map_types(value, element, matches)
-            matches += 1
-          rescue ValidationException
-            next
-          end
-        elsif element.end_with?('{}')
-          result_value, matches = map_hash_type(value, element, group_name, matches)
-        elsif element.end_with?('[]')
-          result_value, matches = map_array_type(value, element, group_name, matches)
-        else
-          begin
-            result_value, matches = map_type(value, element, group_name, matches, sdk_module)
-          rescue StandardError
-            next
-          end
-        end
-        break if group_name == 'anyOf' && matches == 1
-      end
-      raise ValidationException, "The value #{value} provided doesn't validate against the schema #{template}" unless
-        matches == 1
-
-      value = result_value unless result_value.nil?
-      value
-    end
-
-    # Validates and processes the value against the [Hash] type.
-    # @param [String] value The value to be mapped against the type.
-    # @param [String] type The possible type of the value.
-    # @param [String] group_name The parameter indicates the group (oneOf|anyOf).
-    # @param [Integer] matches The parameter indicates the number of matches of value against types.
-    def self.map_hash_type(value, type, group_name, matches)
-      if value.instance_of? Hash
-        decoded = {}
-        value.each do |key, val|
-          type = type.chomp('{}').to_s
-          val = map_types(val, type, group_name: group_name)
-          decoded[key] = val unless type.empty?
-        rescue ValidationException
-          next
-        end
-        matches += 1 if decoded.length == value.length
-        value = decoded unless decoded.empty?
-      end
-      [value, matches]
-    end
-
-    # Validates and processes the value against the [Array] type.
-    # @param [String] value The value to be mapped against the type.
-    # @param [String] type The possible type of the value.
-    # @param [String] group_name The parameter indicates the group (oneOf|anyOf).
-    # @param [Integer] matches The parameter indicates the number of matches of value against types.
-    def self.map_array_type(value, type, group_name, matches)
-      if value.instance_of? Array
-        decoded = []
-        value.each do |val|
-          type = type.chomp('[]').to_s
-          val = map_types(val, type, group_name: group_name)
-          decoded.append(val) unless type.empty?
-        rescue ValidationException
-          next
-        end
-        matches += 1 if decoded.length == value.length
-        value = decoded unless decoded.empty?
-      end
-      [value, matches]
-    end
-
-    # Validates and processes the value against the type.
-    # @param [String] value The value to be mapped against the type.
-    # @param [String] type The possible type of the value.
-    # @param [String] _group_name The parameter indicates the group (oneOf|anyOf).
-    # @param [Integer] matches The parameter indicates the number of matches of value against types.
-    def self.map_type(value, type, _group_name, matches, sdk_module)
-      if sdk_module.constants.select do |c|
-        sdk_module.const_get(c).to_s == "#{sdk_module}::#{type}"
-      end.empty?
-        value, matches = map_data_type(value, type, matches)
-      else
-        value, matches = map_complex_type(value, type, matches, sdk_module)
-      end
-      [value, matches]
-    end
-
-    # Validates and processes the value against the complex types.
-    # @param [String] value The value to be mapped against the type.
-    # @param [String] type The possible type of the value.
-    # @param [Integer] matches The parameter indicates the number of matches of value against types.
-    def self.map_complex_type(value, type, matches, sdk_module)
-      # TODO: Add a nil check on sdk_module?
-      obj = sdk_module.const_get(type)
-      value = if obj.respond_to? 'from_hash'
-                obj.send('from_hash', value)
-              else
-                obj.constants.find { |k| obj.const_get(k) == value }
-              end
-      matches += 1 unless value.nil?
-      [value, matches]
-    end
-
-    # Validates and processes the value against the data types.
-    # @param [String] value The value to be mapped against the type.
-    # @param [String] element The possible type of the value.
-    # @param [Integer] matches The parameter indicates the number of matches of value against types.
-    def self.map_data_type(value, element, matches)
-      element = element.split('|').map { |x| Object.const_get x }
-      matches += 1 if element.all? { |x| data_types.include?(x) } &&
-                      element.any? { |x| (value.instance_of? x) || (value.class.ancestors.include? x) }
-      [value, matches]
-    end
-
-    # Validates the value against the template(group of types).
-    # @param [String] value The value to be mapped against the type.
-    # @param [String] template The parameter indicates the group of types (oneOf(Integer, String)).
-    def self.validate_types(value, template, sdk_module, should_symbolize)
-      map_types(json_deserialize(value.to_json, should_symbolize), template, sdk_module: sdk_module)
-    end
-
     # Get content-type depending on the value
     # @param [Object] value The value for which the content-type is resolved.
     def self.get_content_type(value)