Class: ThePlaidApi::BaseModel

Inherits:

CoreLibrary::BaseModel

Object
CoreLibrary::BaseModel
ThePlaidApi::BaseModel

show all

Defined in:: lib/the_plaid_api/models/base_model.rb

Overview

Base model. rubocop:disable all

Direct Known Subclasses

Instance Method Summary collapse

#check_for_conflict(name, existing_prop_names) ⇒ Object

Checks if an additional property conflicts with a model’s existing property.
#process_additional_properties(additional_properties, existing_prop_names) ⇒ Object

Processes additional properties, ensuring no conflicts with existing properties.
#process_array(value) ⇒ Object

Processes an array of values, recursively calling ‘to_hash` on BaseModel objects.
#process_basic_value(value) ⇒ Object

Processes a basic value (non-array, non-hash).
#process_hash(value) ⇒ Object

Processes a hash of values, recursively calling ‘to_hash` on BaseModel objects.
#to_hash ⇒ Object

Returns a Hash representation of the current object.
#to_json(options = {}) ⇒ Object

Returns a JSON representation of the curent object.

Instance Method Details

#check_for_conflict(name, existing_prop_names) ⇒ `Object`

Checks if an additional property conflicts with a model’s existing property.

Raises:

(ArgumentError)

# File 'lib/the_plaid_api/models/base_model.rb', line 80

def check_for_conflict(name, existing_prop_names)
  return unless existing_prop_names.key?(name)

  raise ArgumentError, "An additional property key, '#{name}' conflicts with one of the model's properties"
end

#process_additional_properties(additional_properties, existing_prop_names) ⇒ `Object`

Processes additional properties, ensuring no conflicts with existing properties.

# File 'lib/the_plaid_api/models/base_model.rb', line 63

def process_additional_properties(additional_properties, existing_prop_names)
  hash = {}
  additional_properties.each do |name, value|
    check_for_conflict(name, existing_prop_names)

    hash[name] = if value.is_a?(Array)
                   process_array(value)
                 elsif value.is_a?(Hash)
                   process_hash(value)
                 else
                   process_basic_value(value)
                 end
  end
  hash
end

#process_array(value) ⇒ `Object`

Processes an array of values, recursively calling ‘to_hash` on BaseModel objects.



87
88
89

# File 'lib/the_plaid_api/models/base_model.rb', line 87

def process_array(value)
  value.map { |v| v.is_a?(BaseModel) ? v.to_hash : v }
end

#process_basic_value(value) ⇒ `Object`

Processes a basic value (non-array, non-hash).



99
100
101

# File 'lib/the_plaid_api/models/base_model.rb', line 99

def process_basic_value(value)
  value.is_a?(BaseModel) ? value.to_hash : value
end

#process_hash(value) ⇒ `Object`

Processes a hash of values, recursively calling ‘to_hash` on BaseModel objects.

# File 'lib/the_plaid_api/models/base_model.rb', line 92

def process_hash(value)
  value.transform_values do |v|
    v.is_a?(BaseModel) ? v.to_hash : v
  end
end

#to_hash ⇒ `Object`

Returns a Hash representation of the current object.

# File 'lib/the_plaid_api/models/base_model.rb', line 11

def to_hash
  # validating the model being serialized
  self.class.validate(self) if self.class.respond_to?(:validate)

  hash = {}
  instance_variables.each do |name|
    value = instance_variable_get(name)
    name = name[1..]
    if name == 'additional_properties'
      additional_properties = process_additional_properties(value, self.class.names)
      hash.merge!(additional_properties)
    else
      key = self.class.names.key?(name) ? self.class.names[name] : name
      optional_fields = self.class.optionals
      nullable_fields = self.class.nullables
      if value.nil?
        next unless nullable_fields.include?(name)

        if !optional_fields.include?(name) && !nullable_fields.include?(name)
          raise ArgumentError,
                "`#{name}` cannot be nil in `#{self.class}`. Please specify a valid value."
        end
      end

      hash[key] = nil
      unless value.nil?
        if respond_to?("to_custom_#{name}")
          if (value.instance_of? Array) || (value.instance_of? Hash)
            params = [hash, key]
            hash[key] = send("to_custom_#{name}", *params)
          else
            hash[key] = send("to_custom_#{name}")
          end
        elsif respond_to?("to_union_type_#{name}")
          hash[key] = send("to_union_type_#{name}")
        elsif value.instance_of? Array
          hash[key] = value.map { |v| v.is_a?(BaseModel) ? v.to_hash : v }
        elsif value.instance_of? Hash
          hash[key] = {}
          value.each do |k, v|
            hash[key][k] = v.is_a?(BaseModel) ? v.to_hash : v
          end
        else
          hash[key] = value.is_a?(BaseModel) ? value.to_hash : value
        end
      end
    end
  end
  hash
end

#to_json(options = {}) ⇒ `Object`

Returns a JSON representation of the curent object.

# File 'lib/the_plaid_api/models/base_model.rb', line 104

def to_json(options = {})
  hash = to_hash
  hash.to_json(options)
end

Class: ThePlaidApi::BaseModel

Overview

Direct Known Subclasses

Instance Method Summary collapse

Instance Method Details

#check_for_conflict(name, existing_prop_names) ⇒ Object

#process_additional_properties(additional_properties, existing_prop_names) ⇒ Object

#process_array(value) ⇒ Object

#process_basic_value(value) ⇒ Object

#process_hash(value) ⇒ Object

#to_hash ⇒ Object