Class: ShellEv::BaseModel

Inherits:
CoreLibrary::BaseModel
  • Object
show all
Defined in:
lib/shell_ev/models/base_model.rb

Overview

Base model. rubocop:disable all

Instance Method Summary collapse

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) 


80
81
82
83
84
 
# File 'lib/shell_ev/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.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/shell_ev/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/shell_ev/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/shell_ev/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.



92
93
94
95
96
 
# File 'lib/shell_ev/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.



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/shell_ev/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.



104
105
106
107
 
# File 'lib/shell_ev/models/base_model.rb', line 104

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