moov_ruby 25.4.10 → 25.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbd8ecd5c888d8e39409b8e2ea2ac8b1a016aef47c57e642f941e87806475b4e
-  data.tar.gz: 9e9539ad015b18effdd6a0333d06e456fa548be0127a9dbd9cfaa86fbd94971c
+  metadata.gz: 82dcd9b70cd7601d6dc51e62a4f9ebe77c12cc7c0c02795efb9bcba05d4a0cbf
+  data.tar.gz: 8d48c43313ee3386ef8f9db2dda57c2fa4c7ff90b2641c9957fa4f1b54dfe6cb
 SHA512:
-  metadata.gz: 37887f67c848d9c21902e307bc748405281a720674eab2d86e8f4cf07096bf11564b402dd1daa7d1a3b4bcf99a6b0ce85ef4679d8b118049f53734edfe141ae2
-  data.tar.gz: 84eadccce8fdf764815131c8a6f53326789e7db03ed3f00a461c485f865aa115b8c9bb0f598b4d7c65fbc2672753271374b0830159a2f507b7266a3b407f728a
+  metadata.gz: 9f2c72b869cdf1dda4f164cac0546923da606385b55dbdadc50ce56993d073bbce4243b6a2d85bf9ca9a3255cff5c365f1414c4f9bfe3fa3b3da3163f3b8052e
+  data.tar.gz: 54fb712dc0f8c91902940a55d3e510a2738880823aec73076eeee96b702ea86284421e7ab5b827a248b0e9111fb79f23f7fb38d4a4f9bf561f60b13288380397

data/lib/crystalline/metadata_fields.rb

@@ -37,30 +37,19 @@ module Crystalline
       def unmarshal_single(field_type, value, format_metadata = nil)
         decoder = format_metadata.fetch(:decoder, nil)
 
-        # Delegate complex Crystalline types to unmarshal_json
-        if field_type.is_a?(Crystalline::DiscriminatedUnion) ||
-           Crystalline::Utils.arr?(field_type) ||
-           Crystalline::Utils.hash?(field_type) ||
-           Crystalline::Utils.union?(field_type)
-          return Crystalline.unmarshal_json(value, field_type)
-        elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
           return field_type.from_dict(value)
         elsif field_type.to_s == 'Date'
           return Date.parse(value)
         elsif field_type.to_s == 'DateTime'
           return DateTime.parse(value)
         elsif field_type.to_s == 'Object'
-          if value.is_a?(::String)
-            trimmed = value.lstrip
-            if trimmed.start_with?('{') || trimmed.start_with?('[')
-              # rubocop:disable Lint/SuppressedException
-              begin
-                value = JSON.parse(value)
-              rescue TypeError, JSON::ParserError
-              end
-              # rubocop:enable Lint/SuppressedException
-            end
+          # rubocop:disable Lint/SuppressedException
+          begin
+            value = JSON.parse(value)
+          rescue TypeError, JSON::ParserError
           end
+          # rubocop:enable Lint/SuppressedException
           return value
         elsif field_type.to_s == 'Float'
           return value.to_f
@@ -76,27 +65,12 @@ module Crystalline
       def from_dict(d)
         to_build = {}
 
-        # Collect lookup keys for regular fields so we can identify additional properties later
-        known_keys = {}
-        additional_props_fields = []
         fields.each do |field|
-          format_metadata = field.metadata.fetch(:format_json, {})
-          if format_metadata.fetch(:additional_properties, false)
-            additional_props_fields << field
-          else
-            lookup = format_metadata.fetch(:letter_case, nil).call
-            known_keys[lookup] = true
-          end
-        end
-
-        # Process regular fields
-        (fields - additional_props_fields).each do |field|
           key = field.name
           format_metadata = field.metadata.fetch(:format_json, {})
-          field_type = field.type
-
           lookup = format_metadata.fetch(:letter_case, nil).call
           value = d[lookup]
+          field_type = field.type
           if ::Crystalline::Utils.nilable? field_type
             if value == 'null'
               to_build[key] = nil
@@ -104,15 +78,13 @@ module Crystalline
             end
             field_type = ::Crystalline::Utils.nilable_of(field_type)
           end
-
+          
           # If field is not nilable, and the value is not in the dict, raise a KeyError
           raise KeyError, "key #{lookup} not found in hash" if value.nil? && !::Crystalline::Utils.nilable?(field.type)
           # If field is nilable, and the value is not in the dict, just move to the next field
           next if value.nil?
 
-          if field_type.is_a?(Crystalline::DiscriminatedUnion)
-            to_build[key] = field_type.parse(value)
-          elsif Crystalline::Utils.arr? field_type
+          if Crystalline::Utils.arr? field_type
             inner_type = Crystalline::Utils.arr_of(field_type)
             unmarshalled_array = value.map { |f| unmarshal_single(inner_type, f, format_metadata) }
             to_build[key] = unmarshalled_array
@@ -140,21 +112,17 @@ module Crystalline
               union_types = Crystalline::Utils.get_union_types(field_type)
               union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
 
-              if Crystalline.union_strategy == :populated_fields
-                to_build[key] = Crystalline.unmarshal_union_populated_fields(value, union_types)
-              else
-                union_types.each do |union_type|
-                  begin
-                    to_build[key] = Crystalline.unmarshal_json(value, union_type)
-                  rescue TypeError
-                    next
-                  rescue NoMethodError
-                    next
-                  rescue KeyError
-                    next
-                  end
-                  break
+              union_types.each do |union_type|
+                begin
+                  to_build[key] = Crystalline.unmarshal_json(value, union_type)
+                rescue TypeError
+                  next
+                rescue NoMethodError
+                  next
+                rescue KeyError
+                  next
                 end
+                break
               end
             end
           elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
@@ -163,32 +131,6 @@ module Crystalline
             to_build[key] = unmarshal_single(field_type, value, format_metadata)
           end
         end
-
-        # Process additional properties fields: collect remaining keys from the dict
-        additional_props_fields.each do |field|
-          key = field.name
-          format_metadata = field.metadata.fetch(:format_json, {})
-          field_type = field.type
-
-          remaining = d.reject { |k, _| known_keys.key?(k) }
-          if remaining.empty?
-            next if ::Crystalline::Utils.nilable?(field.type)
-
-            raise KeyError, 'no additional properties found in hash'
-          end
-
-          inner_field_type = field_type
-          inner_field_type = ::Crystalline::Utils.nilable_of(inner_field_type) if ::Crystalline::Utils.nilable?(inner_field_type)
-          if Crystalline::Utils.hash?(inner_field_type)
-            val_type = Crystalline::Utils.hash_of(inner_field_type)
-            # rubocop:disable Style/HashTransformValues
-            to_build[key] = remaining.map { |k, v| [k, unmarshal_single(val_type, v, format_metadata)] }.to_h
-            # rubocop:enable Style/HashTransformValues
-          else
-            to_build[key] = remaining
-          end
-        end
-
         new(**to_build)
       end
     end
@@ -230,8 +172,6 @@ module Crystalline
       fields.sort_by(&:name).each do |field|
         format_json_meta = field.metadata[:format_json]
         required = !format_json_meta.nil? && format_json_meta.include?(:required)
-        is_additional_props = !format_json_meta.nil? && format_json_meta.fetch(:additional_properties, false)
-
         if !format_json_meta.nil? && format_json_meta.include?(:letter_case)
           key = format_json_meta[:letter_case].call(field.name)
         else
@@ -242,13 +182,10 @@ module Crystalline
         next if f.nil? && !required
         result[key] = nil if f.nil? && required
 
-        # Flatten additional properties into the parent object
-        if is_additional_props && f.is_a?(::Hash)
-          f.each { |k, v| result[k] = marshal_single(v) }
-        elsif f.is_a? ::Array
+        if f.is_a? Array
           result[key] = f.map { |o| marshal_single(o) }
-        elsif f.is_a? ::Hash
-          result[key] = f.transform_values { |v| marshal_single(v) }
+        elsif f.is_a? Hash
+          result[key] = f.map { |k, v| [k, marshal_single(v)] }
         else
           result[key] = marshal_single(f)
         end

data/lib/crystalline/module.rb

@@ -4,16 +4,11 @@
 # frozen_string_literal: true
 
 module Crystalline
-  @union_strategy = :left_to_right
-
-  class << self
-    attr_accessor :union_strategy
-  end
 
   def self.to_dict(complex)
-    if complex.is_a? ::Array
+    if complex.is_a? Array
       complex.map { |v| Crystalline.to_dict(v) }
-    elsif complex.is_a? ::Hash
+    elsif complex.is_a? Hash
       complex.transform_values { |v| Crystalline.to_dict(v) }
     elsif complex.respond_to?(:class) && complex.class.include?(::Crystalline::MetadataFields)
       complex.to_dict
@@ -34,18 +29,21 @@ module Crystalline
     if Crystalline::Utils.nilable? type
       type = Crystalline::Utils.nilable_of type
     end
-    if type.is_a?(Crystalline::DiscriminatedUnion)
-      type.parse(data)
-    elsif type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
+    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
       type.from_dict(data)
     elsif Crystalline::Utils.union? type
       union_types = Crystalline::Utils.get_union_types(type)
       union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
 
-      if Crystalline.union_strategy == :populated_fields
-        Crystalline.unmarshal_union_populated_fields(data, union_types)
-      else
-        Crystalline.unmarshal_union_left_to_right(data, union_types)
+      union_types.each do |union_type|
+        unmarshalled_val = Crystalline.unmarshal_json(data, union_type)
+        return unmarshalled_val
+      rescue TypeError
+        next
+      rescue NoMethodError
+        next
+      rescue KeyError
+        next
       end
     elsif Crystalline::Utils.arr? type
       data.map { |v| Crystalline.unmarshal_json(v, Crystalline::Utils.arr_of(type)) }
@@ -57,8 +55,6 @@ module Crystalline
       Crystalline::Utils.to_boolean(data)
     elsif type.is_a?(Class) && type < T::Enum
       type.deserialize(data)
-    elsif type.is_a?(Class) && type.respond_to?(:enums) && type.respond_to?(:deserialize)
-      type.deserialize(data)
     else
       data
     end
@@ -68,7 +64,7 @@ module Crystalline
     if val.class.respond_to? :enums
       val.serialize
     elsif val.is_a? DateTime
-      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ').sub(/(\.\d*[1-9])0+Z\z/, '\1Z').sub(/\.0+Z\z/, 'Z')
+      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
     elsif val.nil?
       nil
     elsif primitives
@@ -78,88 +74,6 @@ module Crystalline
     end
   end
 
-  def self.unmarshal_union_left_to_right(data, union_types)
-    union_types.each do |union_type|
-      return Crystalline.unmarshal_json(data, union_type)
-    rescue TypeError
-      next
-    rescue NoMethodError
-      next
-    rescue KeyError
-      next
-    end
-    nil
-  end
-
-  def self.unmarshal_union_populated_fields(data, union_types)
-    best_value = nil
-    best_matched = -1
-    best_inexact = 0
-    best_unmatched = 0
-
-    union_types.each do |union_type|
-      value = Crystalline.unmarshal_json(data, union_type)
-      matched, inexact, unmatched = count_matched_fields(value, data)
-
-      if best_value.nil? ||
-         matched > best_matched ||
-         (matched == best_matched && inexact < best_inexact) ||
-         (matched == best_matched && inexact == best_inexact && unmatched < best_unmatched)
-        best_value = value
-        best_matched = matched
-        best_inexact = inexact
-        best_unmatched = unmatched
-      end
-    rescue TypeError
-      next
-    rescue NoMethodError
-      next
-    rescue KeyError
-      next
-    end
-    best_value
-  end
-
-  def self.count_matched_fields(value, raw_data)
-    matched = 0
-    inexact = 0
-    unmatched = 0
-
-    if value.is_a?(Crystalline::Unknown)
-      return [0, 0, 0]
-    elsif value.class.include?(::Crystalline::MetadataFields)
-      value.fields.each do |field|
-        format_metadata = field.metadata.fetch(:format_json, {})
-        lookup = format_metadata.fetch(:letter_case, nil)&.call
-        field_val = value.send(field.name)
-
-        if raw_data.is_a?(::Hash) && lookup && raw_data.key?(lookup)
-          if field_val.class.include?(::Crystalline::MetadataFields) && raw_data[lookup].is_a?(::Hash)
-            nested_matched, nested_inexact, nested_unmatched = count_matched_fields(field_val, raw_data[lookup])
-            matched += nested_matched
-            inexact += nested_inexact
-            unmatched += nested_unmatched
-          else
-            matched += 1
-            if field_val.respond_to?(:known?) && !field_val.known?
-              inexact += 1
-            end
-          end
-        elsif !::Crystalline::Utils.nilable?(field.type)
-          unmatched += 1
-        end
-      end
-    elsif value.is_a?(::Array)
-      matched = value.length
-    elsif value.is_a?(::Hash)
-      matched = value.length
-    else
-      matched = 1
-    end
-
-    [matched, inexact, unmatched]
-  end
-
   def self.non_nilable_attr_count(klass)
     # somewhat sane sort ordering for Union deserialization.
     # All Crystalline objects return the number of non-nilable fields

data/lib/crystalline/types.rb

@@ -14,7 +14,7 @@ module Crystalline
 
   class Hash
     attr_accessor :key_type, :value_type
-
+    
     def initialize(key_type, value_type)
       @key_type = key_type
       @value_type = value_type
@@ -23,7 +23,7 @@ module Crystalline
 
   class Union
     attr_accessor :types
-
+    
     def initialize(*types)
       @types = types
     end
@@ -31,7 +31,7 @@ module Crystalline
 
   class Nilable
     attr_accessor :inner_type
-
+    
     def initialize(inner_type)
       @inner_type = inner_type
     end
@@ -40,58 +40,6 @@ module Crystalline
   class Boolean
   end
 
-  # Wraps an unrecognized payload from an open discriminated union.
-  # Produced when the discriminator value is missing, unknown, or schema validation fails.
-  class Unknown
-    attr_reader :raw
-
-    def initialize(raw:)
-      @raw = raw
-    end
-
-    def unknown?
-      true
-    end
-  end
-
-  # Forward-compatible discriminated union parser.
-  # Known discriminator values are deserialized to their mapped types.
-  # Unknown or invalid payloads are captured as Crystalline::Unknown.
-  class DiscriminatedUnion
-    attr_reader :discriminator, :variants
-
-    def initialize(discriminator, variants)
-      @discriminator = discriminator
-      @variants = variants
-    end
-
-    def parse(payload)
-      unless payload.is_a?(::Hash)
-        return Unknown.new(raw: payload)
-      end
-
-      disc_value = payload[@discriminator]
-      unless disc_value.is_a?(::String)
-        return Unknown.new(raw: payload)
-      end
-
-      variant_type = @variants[disc_value]
-      unless variant_type
-        return Unknown.new(raw: payload)
-      end
-
-      begin
-        Crystalline.unmarshal_json(payload, variant_type)
-      rescue StandardError
-        Unknown.new(raw: payload)
-      end
-    end
-  end
-
-  def self.unknown?(value)
-    value.is_a?(Unknown)
-  end
-
   module Enum
     def self.included(base)
       base.extend(ClassMethods)
@@ -119,19 +67,9 @@ module Crystalline
         end
       end
 
-      def open!
-        @open = true
-      end
-
-      def open?
-        @open == true
-      end
-
       def deserialize(val)
         if @mapping.include? val
           @mapping[val]
-        elsif open?
-          new(val)
         else
           raise "Invalid value for enum: #{val}"
         end
@@ -141,30 +79,5 @@ module Crystalline
     def serialize
       @val
     end
-
-    def to_s
-      serialize.to_s
-    end
-
-    def inspect
-      "#<#{self.class} #{serialize.inspect}>"
-    end
-
-    def known?
-      self.class.instance_variable_get(:@mapping)&.value?(self) || false
-    end
-
-    def ==(other)
-      other = other.serialize if other.is_a?(self.class)
-      @val == other
-    end
-
-    def eql?(other)
-      self == other
-    end
-
-    def hash
-      @val.hash
-    end
   end
 end

data/lib/moov/account_terminal_applications.rb

@@ -39,12 +39,10 @@ module Moov
     end
 
 
-
-
-    sig { params(link_account_terminal_application: Models::Components::LinkAccountTerminalApplication, account_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::LinkAccountTerminalApplicationResponse) }
-    def link(link_account_terminal_application:, account_id:, x_moov_version: nil, timeout_ms: nil, http_headers: nil)
+    sig { params(link_account_terminal_application: Models::Components::LinkAccountTerminalApplication, account_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LinkAccountTerminalApplicationResponse) }
+    def link(link_account_terminal_application:, account_id:, x_moov_version: nil, timeout_ms: nil)
       # link - Link an account with a terminal application.
-      #
+      # 
       # To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
       # you'll need to specify the `/accounts/{accountID}/terminal-applications.write` scope.
       request = Models::Operations::LinkAccountTerminalApplicationRequest.new(
@@ -67,7 +65,7 @@ module Moov
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form && !form.empty?
+      if form
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -103,9 +101,6 @@ module Moov
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
-          http_headers&.each do |key, value|
-            req.headers[key.to_s] = value
-          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -208,10 +203,10 @@ module Moov
     end
 
 
-    sig { params(account_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ListAccountTerminalApplicationsResponse) }
-    def list(account_id:, x_moov_version: nil, timeout_ms: nil, http_headers: nil)
+    sig { params(account_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer)).returns(Models::Operations::ListAccountTerminalApplicationsResponse) }
+    def list(account_id:, x_moov_version: nil, timeout_ms: nil)
       # list - Retrieve all terminal applications linked to a specific account.
-      #
+      # 
       # To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
       # you'll need to specify the `/accounts/{accountID}/terminal-applications.read` scope.
       request = Models::Operations::ListAccountTerminalApplicationsRequest.new(
@@ -257,9 +252,6 @@ module Moov
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
-          http_headers&.each do |key, value|
-            req.headers[key.to_s] = value
-          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -332,10 +324,10 @@ module Moov
     end
 
 
-    sig { params(account_id: ::String, terminal_application_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::GetAccountTerminalApplicationResponse) }
-    def get(account_id:, terminal_application_id:, x_moov_version: nil, timeout_ms: nil, http_headers: nil)
+    sig { params(account_id: ::String, terminal_application_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetAccountTerminalApplicationResponse) }
+    def get(account_id:, terminal_application_id:, x_moov_version: nil, timeout_ms: nil)
       # get - Verifies if a specific Terminal Application is linked to an Account. This endpoint acts as a validation check for the link's existence.
-      #
+      # 
       # To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
       # you'll need to specify the `/accounts/{accountID}/terminal-applications.read` scope.
       request = Models::Operations::GetAccountTerminalApplicationRequest.new(
@@ -382,9 +374,6 @@ module Moov
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
-          http_headers&.each do |key, value|
-            req.headers[key.to_s] = value
-          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -457,10 +446,10 @@ module Moov
     end
 
 
-    sig { params(account_id: ::String, terminal_application_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::GetTerminalConfigurationResponse) }
-    def get_configuration(account_id:, terminal_application_id:, x_moov_version: nil, timeout_ms: nil, http_headers: nil)
+    sig { params(account_id: ::String, terminal_application_id: ::String, x_moov_version: T.nilable(::String), timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetTerminalConfigurationResponse) }
+    def get_configuration(account_id:, terminal_application_id:, x_moov_version: nil, timeout_ms: nil)
       # get_configuration - Fetch the configuration for a given Terminal Application linked to a specific Account.
-      #
+      # 
       # To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
       # you'll need to specify the `/accounts/{accountID}/terminal-configuration.read` scope.
       request = Models::Operations::GetTerminalConfigurationRequest.new(
@@ -507,9 +496,6 @@ module Moov
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
-          http_headers&.each do |key, value|
-            req.headers[key.to_s] = value
-          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -580,5 +566,5 @@ module Moov
 
       end
     end
-end
+  end
 end