Class: Revox::Internal::Type::BaseModel Abstract

Inherits:

Object

Object
Revox::Internal::Type::BaseModel

show all

Extended by:: Converter, Util::SorbetRuntimeSupport

Defined in:: lib/revox/internal/type/base_model.rb,
sig/revox/internal/type/base_model.rbs

Overview

This class is abstract.

Direct Known Subclasses

Class Method Summary collapse

.==(other) ⇒ Boolean
.coerce(value, state:) ⇒ self, Object private
.dump(value, state:) ⇒ Hash{Object=>Object}, Object private
.fields ⇒ Hash{Symbol=>Hash{Symbol=>Object}} private
.hash ⇒ Integer
.inherited(child) ⇒ void private
Assumes superclass fields are totally defined before fields are accessed / defined on subclasses.
.inspect(depth: 0) ⇒ String private
.known_fields ⇒ Hash{Symbol=>Hash{Symbol=>Object}} private
.optional(name_sym, type_info, spec = {}) ⇒ Object private
.recursively_to_h(model, convert:) ⇒ Hash{Symbol=>Object} private
.required(name_sym, type_info, spec = {}) ⇒ Object private
.to_sorbet_type ⇒ 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}
#deep_to_h ⇒ Hash{Symbol=>Object}
In addition to the behaviour of #to_h, this method will recursively call #to_h on nested models.
#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, meta_info, new_coerce_state, type_info

Methods included from Util::SorbetRuntimeSupport

const_missing, define_sorbet_constant!, sorbet_constant_defined?, to_sorbet_type

Constructor Details

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

Create a new instance of a model.

Parameters:

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

# File 'lib/revox/internal/type/base_model.rb', line 474

def initialize(data = {})
  @data = {}
  @coerced = {}
  Revox::Internal::Util.coerce_hash!(data).each do
    if self.class.known_fields.key?(_1)
      public_send(:"#{_1}=", _2)
    else
      @data.store(_1, _2)
      @coerced.store(_1, false)
    end
  end
end

Class Method Details

.==(other) ⇒ `Boolean`

Parameters:

other (Object)

Returns:

(Boolean)



207
208
209

# File 'lib/revox/internal/type/base_model.rb', line 207

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

.coerce(value, state:) ⇒ `self`, `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 (Revox::Internal::Type::BaseModel, Hash{Object=>Object}, Object)
state (Hash{Symbol=>Object}) —
.

@option state [Boolean] :translate_names

@option state [Boolean] :strictness

@option state [HashSymbol=>Object] :exactness

@option state [Class] :error

@option state [Integer] :branched

Returns:

(self, Object)

# File 'lib/revox/internal/type/base_model.rb', line 247

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

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

  unless (val = Revox::Internal::Util.coerce_hash(value)).is_a?(Hash)
    exactness[:no] += 1
    state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
    return value
  end
  exactness[:yes] += 1

  keys = val.keys.to_set
  instance = new
  data = instance.to_h
  status = instance.instance_variable_get(:@coerced)

  # 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)
    src_name = state.fetch(:translate_names) ? api_name : name

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

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

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

    status.store(name, state.fetch(:error) || true)
    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 (self, Object)
state (Hash{Symbol=>Object}) —
.

@option state [Boolean] :can_retry

Returns:

(Hash{Object=>Object}, Object)

# File 'lib/revox/internal/type/base_model.rb', line 318

def dump(value, state:)
  unless (coerced = Revox::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, Revox::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 == Revox::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/revox/internal/type/base_model.rb', line 31

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

.hash ⇒ `Integer`

Returns:

(Integer)

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

.inherited(child) ⇒ `void`

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.

This method returns an undefined value.

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

Parameters:

child (Class<Revox::Internal::Type::BaseModel>)

# File 'lib/revox/internal/type/base_model.rb', line 18

def inherited(child)
  super
  child.known_fields.replace(known_fields.dup)
end

.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)
depth: (Integer) (defaults to: 0)

Returns:

(String)

# File 'lib/revox/internal/type/base_model.rb', line 493

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 = [
      Revox::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.

Returns:

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

26	# File 'lib/revox/internal/type/base_model.rb', line 26 def known_fields = @known_fields \|\|= {}

.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, Revox::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?"



173
174
175

# File 'lib/revox/internal/type/base_model.rb', line 173

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

.recursively_to_h(model, convert:) ⇒ `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 (Revox::Internal::Type::BaseModel)
convert (Boolean)

Returns:

(Hash{Symbol=>Object})

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

def recursively_to_h(model, convert:)
  rec = ->(x) do
    case x
    in Revox::Internal::Type::BaseModel
      if convert
        fields = x.class.known_fields
        x.to_h.to_h do |key, val|
          [key, rec.call(fields.key?(key) ? x.public_send(key) : val)]
        rescue Revox::Errors::ConversionError
          [key, rec.call(val)]
        end
      else
        rec.call(x.to_h)
      end
    in Hash
      x.transform_values(&rec)
    in Array
      x.map(&rec)
    else
      x
    end
  end
  rec.call(model)
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, Revox::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?"



154
155
156

# File 'lib/revox/internal/type/base_model.rb', line 154

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

.to_sorbet_type ⇒ `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:

(Object)



354
355
356

# File 'lib/revox/internal/type/base_model.rb', line 354

def to_sorbet_type
  self
end

Instance Method Details

#==(other) ⇒ `Boolean`

Parameters:

other (Object)

Returns:

(Boolean)

222	# File 'lib/revox/internal/type/base_model.rb', line 222 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/revox/internal/type/base_model.rb', line 404

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}`

Examples:

# `auth_status_retrieve_response` is a `Revox::Models::AuthStatusRetrieveResponse`
auth_status_retrieve_response => {
  authenticated: authenticated
}

Parameters:

keys (Array<Symbol>, nil)

Returns:

(Hash{Symbol=>Object})

# File 'lib/revox/internal/type/base_model.rb', line 445

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

#deep_to_h ⇒ `Hash{Symbol=>Object}`

In addition to the behaviour of #to_h, this method will recursively call #to_h on nested models.

Returns:

(Hash{Symbol=>Object})

434	# File 'lib/revox/internal/type/base_model.rb', line 434 def deep_to_h = self.class.recursively_to_h(@data, convert: false)

#hash ⇒ `Integer`

Returns:

(Integer)

227	# File 'lib/revox/internal/type/base_model.rb', line 227 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)

# File 'lib/revox/internal/type/base_model.rb', line 518

def inspect
  converted = self.class.recursively_to_h(self, convert: true)
  "#<#{self.class}:0x#{object_id.to_s(16)} #{converted}>"
end

#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})

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

#to_json(*a) ⇒ `String`

Parameters:

a (Object)

Returns:

(String)

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

#to_s ⇒ `String`

Returns:

(String)

513	# File 'lib/revox/internal/type/base_model.rb', line 513 def to_s = deep_to_h.to_s

#to_yaml(*a) ⇒ `String`

Parameters:

a (Object)

Returns:

(String)

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

Class: Revox::Internal::Type::BaseModel Abstract

Overview

Direct Known Subclasses

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Converter

Methods included from Util::SorbetRuntimeSupport

Constructor Details

#initialize(data = {}) ⇒ BaseModel

Class Method Details

.==(other) ⇒ Boolean

.coerce(value, state:) ⇒ self, Object

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

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

.hash ⇒ Integer

.inherited(child) ⇒ void

.inspect(depth: 0) ⇒ String

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

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

.recursively_to_h(model, convert:) ⇒ Hash{Symbol=>Object}

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

.to_sorbet_type ⇒ Object

Instance Method Details

#==(other) ⇒ Boolean

#[](key) ⇒ Object?

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

Examples:

#deep_to_h ⇒ 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:) ⇒ `self`, `Object`

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

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

.hash ⇒ `Integer`

.inherited(child) ⇒ `void`

.inspect(depth: 0) ⇒ `String`

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

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

.recursively_to_h(model, convert:) ⇒ `Hash{Symbol=>Object}`

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

.to_sorbet_type ⇒ `Object`

#==(other) ⇒ `Boolean`

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

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

#deep_to_h ⇒ `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`