hash = fields.hash

in lib/openai/internal/type/base_model.rb [169:249]
50 lines of code
11 McCabe index (conditional complexity)

          def hash = fields.hash
        end

        
        
        
        def ==(other) = self.class == other.class && @data == other.to_h

        
        def hash = [self.class, @data].hash

        class << self
          
          
          
          
          
          
          
          
          
          
          
          
          
          def coerce(value, state:)
            exactness = state.fetch(:exactness)

            if value.is_a?(self.class)
              exactness[:yes] += 1
              return value
            end

            unless (val = OpenAI::Internal::Util.coerce_hash(value)).is_a?(Hash)
              exactness[:no] += 1
              return value
            end
            exactness[:yes] += 1

            keys = val.keys.to_set
            instance = new
            data = instance.to_h

            
            fields.each do |name, field|
              mode, required, target = field.fetch_values(:mode, :required, :type)
              api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)

              unless val.key?(api_name)
                if required && mode != :dump && const == OpenAI::Internal::OMIT
                  exactness[nilable ? :maybe : :no] += 1
                else
                  exactness[:yes] += 1
                end
                next
              end

              item = val.fetch(api_name)
              keys.delete(api_name)

              converted =
                if item.nil? && (nilable || !required)
                  exactness[nilable ? :yes : :maybe] += 1
                  nil
                else
                  coerced = OpenAI::Internal::Type::Converter.coerce(target, item, state: state)
                  case target
                  in OpenAI::Internal::Type::Converter | Symbol
                    coerced
                  else
                    item
                  end
                end
              data.store(name, converted)
            end
            

            keys.each { data.store(_1, val.fetch(_1)) }
            instance
          end