Class: FinchAPI::Internal::Type::BaseModel Abstract

Inherits:

Object

Object
FinchAPI::Internal::Type::BaseModel

show all

Extended by:: Converter

Defined in:: lib/finch_api/internal/type/base_model.rb

Overview

This class is abstract.

Direct Known Subclasses

Class Method Summary collapse

.==(other) ⇒ Boolean
.coerce(value, state:) ⇒ FinchAPI::Internal::Type::BaseModel, Object private
.dump(value, state:) ⇒ Hash{Object=>Object}, Object private
.fields ⇒ Hash{Symbol=>Hash{Symbol=>Object}} private
.hash ⇒ Integer
.inspect(depth: 0) ⇒ String private
.known_fields ⇒ Hash{Symbol=>Hash{Symbol=>Object}} private

Assumes superclass fields are totally defined before fields are accessed / defined on subclasses.
.optional(name_sym, type_info, spec = {}) ⇒ Object private
.required(name_sym, type_info, spec = {}) ⇒ Object private
.walk(model) ⇒ Hash{Symbol=>Object} private

Instance Method Summary collapse

#==(other) ⇒ Boolean
#[](key) ⇒ Object^?

Returns the raw value associated with the given key, if found.
#deconstruct_keys(keys) ⇒ Hash{Symbol=>Object}
#hash ⇒ Integer
#initialize(data = {}) ⇒ BaseModel constructor

Create a new instance of a model.
#inspect ⇒ String private
#to_h ⇒ Hash{Symbol=>Object} (also: #to_hash)

Returns a Hash of the data underlying this object.
#to_json(*a) ⇒ String
#to_s ⇒ String
#to_yaml(*a) ⇒ String

Methods included from Converter

coerce, dump, type_info

Constructor Details

#initialize(data = {}) ⇒ `BaseModel`

Create a new instance of a model.

Parameters:

data (Hash{Symbol=>Object}, self) (defaults to: {})

400	# File 'lib/finch_api/internal/type/base_model.rb', line 400 def initialize(data = {}) = (@data = FinchAPI::Internal::Util.coerce_hash!(data).to_h)

Class Method Details

.==(other) ⇒ `Boolean`

Parameters:

other (Object)

Returns:

(Boolean)



174
175
176

# File 'lib/finch_api/internal/type/base_model.rb', line 174

def ==(other)
  other.is_a?(Class) && other <= FinchAPI::Internal::Type::BaseModel && other.fields == fields
end

.coerce(value, state:) ⇒ `FinchAPI::Internal::Type::BaseModel`, `Object`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

value (FinchAPI::Internal::Type::BaseModel, Hash{Object=>Object}, Object)
state (Hash{Symbol=>Object}) —

.

@option state [Boolean, :strong] :strictness

@option state [HashSymbol=>Object] :exactness

@option state [Integer] :branched

Returns:

(FinchAPI::Internal::Type::BaseModel, Object)

# File 'lib/finch_api/internal/type/base_model.rb', line 210

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

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

  unless (val = FinchAPI::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

  # rubocop:disable Metrics/BlockLength
  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 == FinchAPI::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 = FinchAPI::Internal::Type::Converter.coerce(target, item, state: state)
        case target
        in FinchAPI::Internal::Type::Converter | Symbol
          coerced
        else
          item
        end
      end
    data.store(name, converted)
  end
  # rubocop:enable Metrics/BlockLength

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

.dump(value, state:) ⇒ `Hash{Object=>Object}`, `Object`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

value (FinchAPI::Internal::Type::BaseModel, Object)
state (Hash{Symbol=>Object}) —

.

@option state [Boolean] :can_retry

Returns:

(Hash{Object=>Object}, Object)

# File 'lib/finch_api/internal/type/base_model.rb', line 275

def dump(value, state:)
  unless (coerced = FinchAPI::Internal::Util.coerce_hash(value)).is_a?(Hash)
    return super
  end

  acc = {}

  coerced.each do |key, val|
    name = key.is_a?(String) ? key.to_sym : key
    case (field = known_fields[name])
    in nil
      acc.store(name, super(val, state: state))
    else
      api_name, mode, type_fn = field.fetch_values(:api_name, :mode, :type_fn)
      case mode
      in :coerce
        next
      else
        target = type_fn.call
        acc.store(api_name, FinchAPI::Internal::Type::Converter.dump(target, val, state: state))
      end
    end
  end

  known_fields.each_value do |field|
    api_name, mode, const = field.fetch_values(:api_name, :mode, :const)
    next if mode == :coerce || acc.key?(api_name) || const == FinchAPI::Internal::OMIT
    acc.store(api_name, const)
  end

  acc
end

.fields ⇒ `Hash{Symbol=>Hash{Symbol=>Object}}`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

(Hash{Symbol=>Hash{Symbol=>Object}})

# File 'lib/finch_api/internal/type/base_model.rb', line 24

def fields
  known_fields.transform_values do |field|
    {**field.except(:type_fn), type: field.fetch(:type_fn).call}
  end
end

.hash ⇒ `Integer`

Returns:

(Integer)

181	# File 'lib/finch_api/internal/type/base_model.rb', line 181 def hash = fields.hash

.inspect(depth: 0) ⇒ `String`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

depth (Integer) (defaults to: 0)

Returns:

(String)

# File 'lib/finch_api/internal/type/base_model.rb', line 408

def inspect(depth: 0)
  return super() if depth.positive?

  depth = depth.succ
  deferred = fields.transform_values do |field|
    type, required, nilable = field.fetch_values(:type, :required, :nilable)
    inspected = [
      FinchAPI::Internal::Type::Converter.inspect(type, depth: depth),
      !required || nilable ? "nil" : nil
    ].compact.join(" | ")
    -> { inspected }.tap { _1.define_singleton_method(:inspect) { call } }
  end

  "#{name}[#{deferred.inspect}]"
end

.known_fields ⇒ `Hash{Symbol=>Hash{Symbol=>Object}}`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Assumes superclass fields are totally defined before fields are accessed / defined on subclasses.

Returns:

(Hash{Symbol=>Hash{Symbol=>Object}})



17
18
19

# File 'lib/finch_api/internal/type/base_model.rb', line 17

def known_fields
  @known_fields ||= (self < FinchAPI::Internal::Type::BaseModel ? superclass.known_fields.dup : {})
end

.optional(name_sym, type_info, spec = {}) ⇒ `Object`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

name_sym (Symbol)
type_info (Hash{Symbol=>Object}, Proc, FinchAPI::Internal::Type::Converter, Class)
spec (Hash{Symbol=>Object}) (defaults to: {}) —

.

@option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const

@option spec [Proc] :enum

@option spec [Proc] :union

@option spec [Boolean] :“nil?”



140
141
142

# File 'lib/finch_api/internal/type/base_model.rb', line 140

def optional(name_sym, type_info, spec = {})
  add_field(name_sym, required: false, type_info: type_info, spec: spec)
end

.required(name_sym, type_info, spec = {}) ⇒ `Object`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

name_sym (Symbol)
type_info (Hash{Symbol=>Object}, Proc, FinchAPI::Internal::Type::Converter, Class)
spec (Hash{Symbol=>Object}) (defaults to: {}) —

.

@option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const

@option spec [Proc] :enum

@option spec [Proc] :union

@option spec [Boolean] :“nil?”



121
122
123

# File 'lib/finch_api/internal/type/base_model.rb', line 121

def required(name_sym, type_info, spec = {})
  add_field(name_sym, required: true, type_info: type_info, spec: spec)
end

.walk(model) ⇒ `Hash{Symbol=>Object}`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

model (FinchAPI::Internal::Type::BaseModel)

Returns:

(Hash{Symbol=>Object})

# File 'lib/finch_api/internal/type/base_model.rb', line 366

def walk(model)
  walk = ->(x) do
    case x
    in FinchAPI::Internal::Type::BaseModel
      walk.call(x.to_h)
    in Hash
      x.transform_values(&walk)
    in Array
      x.map(&walk)
    else
      x
    end
  end
  walk.call(model)
end

Instance Method Details

#==(other) ⇒ `Boolean`

Parameters:

other (Object)

Returns:

(Boolean)

189	# File 'lib/finch_api/internal/type/base_model.rb', line 189 def ==(other) = self.class == other.class && @data == other.to_h

#[](key) ⇒ `Object`^?

Returns the raw value associated with the given key, if found. Otherwise, nil is returned.

It is valid to lookup keys that are not in the API spec, for example to access undocumented features. This method does not parse response data into higher-level types. Lookup by anything other than a Symbol is an ArgumentError.

Parameters:

key (Symbol)

Returns:

(Object, nil)

# File 'lib/finch_api/internal/type/base_model.rb', line 321

def [](key)
  unless key.instance_of?(Symbol)
    raise ArgumentError.new("Expected symbol key for lookup, got #{key.inspect}")
  end

  @data[key]
end

#deconstruct_keys(keys) ⇒ `Hash{Symbol=>Object}`

Parameters:

keys (Array<Symbol>, nil)

Returns:

(Hash{Symbol=>Object})

# File 'lib/finch_api/internal/type/base_model.rb', line 348

def deconstruct_keys(keys)
  (keys || self.class.known_fields.keys)
    .filter_map do |k|
      unless self.class.known_fields.key?(k)
        next
      end

      [k, public_send(k)]
    end
    .to_h
end

#hash ⇒ `Integer`

Returns:

(Integer)

194	# File 'lib/finch_api/internal/type/base_model.rb', line 194 def hash = [self.class, @data].hash

#inspect ⇒ `String`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

(String)

433	# File 'lib/finch_api/internal/type/base_model.rb', line 433 def inspect = "#<#{self.class}:0x#{object_id.to_s(16)} #{self}>"

#to_h ⇒ `Hash{Symbol=>Object}` Also known as: to_hash

Returns a Hash of the data underlying this object. O(1)

Keys are Symbols and values are the raw values from the response. The return value indicates which values were ever set on the object. i.e. there will be a key in this hash if they ever were, even if the set value was nil.

This method is not recursive. The returned value is shared by the object, so it should not be mutated.

Returns:

(Hash{Symbol=>Object})

341	# File 'lib/finch_api/internal/type/base_model.rb', line 341 def to_h = @data

#to_json(*a) ⇒ `String`

Parameters:

a (Object)

Returns:

(String)

388	# File 'lib/finch_api/internal/type/base_model.rb', line 388 def to_json(a) = FinchAPI::Internal::Type::Converter.dump(self.class, self).to_json(a)

#to_s ⇒ `String`

Returns:

(String)

428	# File 'lib/finch_api/internal/type/base_model.rb', line 428 def to_s = self.class.walk(@data).to_s

#to_yaml(*a) ⇒ `String`

Parameters:

a (Object)

Returns:

(String)

395	# File 'lib/finch_api/internal/type/base_model.rb', line 395 def to_yaml(a) = FinchAPI::Internal::Type::Converter.dump(self.class, self).to_yaml(a)

Class: FinchAPI::Internal::Type::BaseModel Abstract

Overview

Direct Known Subclasses

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Converter

Constructor Details

#initialize(data = {}) ⇒ BaseModel

Class Method Details

.==(other) ⇒ Boolean

.coerce(value, state:) ⇒ FinchAPI::Internal::Type::BaseModel, Object

.dump(value, state:) ⇒ Hash{Object=>Object}, Object

.fields ⇒ Hash{Symbol=>Hash{Symbol=>Object}}

.hash ⇒ Integer

.inspect(depth: 0) ⇒ String

.known_fields ⇒ Hash{Symbol=>Hash{Symbol=>Object}}

.optional(name_sym, type_info, spec = {}) ⇒ Object

.required(name_sym, type_info, spec = {}) ⇒ Object

.walk(model) ⇒ Hash{Symbol=>Object}

Instance Method Details

#==(other) ⇒ Boolean

#[](key) ⇒ Object?

#deconstruct_keys(keys) ⇒ Hash{Symbol=>Object}

#hash ⇒ Integer

#inspect ⇒ String

#to_h ⇒ Hash{Symbol=>Object} Also known as: to_hash

#to_json(*a) ⇒ String

#to_s ⇒ String

#to_yaml(*a) ⇒ String

#initialize(data = {}) ⇒ `BaseModel`

.==(other) ⇒ `Boolean`

.coerce(value, state:) ⇒ `FinchAPI::Internal::Type::BaseModel`, `Object`

.dump(value, state:) ⇒ `Hash{Object=>Object}`, `Object`

.fields ⇒ `Hash{Symbol=>Hash{Symbol=>Object}}`

.hash ⇒ `Integer`

.inspect(depth: 0) ⇒ `String`

.known_fields ⇒ `Hash{Symbol=>Hash{Symbol=>Object}}`

.optional(name_sym, type_info, spec = {}) ⇒ `Object`

.required(name_sym, type_info, spec = {}) ⇒ `Object`

.walk(model) ⇒ `Hash{Symbol=>Object}`

#==(other) ⇒ `Boolean`

#[](key) ⇒ `Object`^?

#deconstruct_keys(keys) ⇒ `Hash{Symbol=>Object}`

#hash ⇒ `Integer`

#inspect ⇒ `String`

#to_h ⇒ `Hash{Symbol=>Object}` Also known as: to_hash

#to_json(*a) ⇒ `String`

#to_s ⇒ `String`

#to_yaml(*a) ⇒ `String`