Class: Supercast::DataObject

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/supercast/data_object.rb

Direct Known Subclasses

DataList, Resource

Constant Summary collapse

@@permanent_attributes =

rubocop:disable Style/ClassVars

Set.new([:id])

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(id = nil, opts = {}) ⇒ DataObject

Returns a new instance of DataObject.



12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/supercast/data_object.rb', line 12

def initialize(id = nil, opts = {})
  id, @retrieve_params = Util.normalize_id(id)
  @opts = Util.normalize_opts(opts)
  @original_values = {}
  @values = {}
  # This really belongs in Resource, but not putting it there allows us
  # to have a unified inspect method
  @unsaved_values = Set.new
  @transient_values = Set.new
  @values[:id] = id if id
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object (protected)

Disabling the cop because it’s confused by the fact that the methods are protected, but we do define ‘#respond_to_missing?` just below. Hopefully this is fixed in more recent Rubocop versions.



264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
 
# File 'lib/supercast/data_object.rb', line 264

def method_missing(name, *args)
  # TODO: only allow setting in updateable classes.
  if name.to_s.end_with?('=')
    attr = name.to_s[0...-1].to_sym

    # Pull out the assigned value. This is only used in the case of a
    # boolean value to add a question mark accessor (i.e. `foo?`) for
    # convenience.
    val = args.first

    # the second argument is only required when adding boolean accessors
    add_accessors([attr], attr => val)

    begin
      mth = method(name)
    rescue NameError
      raise NoMethodError,
            "Cannot set #{attr} on this object. HINT: you can't set: " \
            "#{@@permanent_attributes.to_a.join(', ')}"
    end
    return mth.call(args[0])
  elsif @values.key?(name)
    return @values[name]
  end

  begin
    super
  rescue NoMethodError => e
    # If we notice the accessed name if our set of transient values we can
    # give the user a slightly more helpful error message. If not, just
    # raise right away.
    raise unless @transient_values.include?(name)

    raise NoMethodError,
          e.message + ".  HINT: The '#{name}' attribute was set in the " \
          'past, however.  It was then wiped when refreshing the object ' \
          "with the result returned by Supercast's API, probably as a " \
          'result of a save().  The attributes currently available on ' \
          "this object are: #{@values.keys.join(', ')}"
  end
end

Class Method Details

.construct_from(values, opts = {}) ⇒ Object 



24
25
26
27
28
29
 
# File 'lib/supercast/data_object.rb', line 24

def self.construct_from(values, opts = {})
  values = Supercast::Util.symbolize_names(values)

  # work around protected #initialize_from for now
  new(values[:id]).send(:initialize_from, values, opts)
end

.protected_fields ⇒ Object

A protected field is one that doesn’t get an accessor assigned to it (i.e. ‘obj.public = …`) and one which is not allowed to be updated via the class level `Model.update(id, { … })`.



191
192
193
 
# File 'lib/supercast/data_object.rb', line 191

def self.protected_fields
  []
end

Instance Method Details

#==(other) ⇒ Object

Determines the equality of two Supercast objects. Supercast objects are considered to be equal if they have the same set of values and each one of those values is the same.



34
35
36
37
 
# File 'lib/supercast/data_object.rb', line 34

def ==(other)
  other.is_a?(DataObject) &&
    @values == other.instance_variable_get(:@values)
end

#[](key) ⇒ Object 



88
89
90
 
# File 'lib/supercast/data_object.rb', line 88

def [](key)
  @values[key.to_sym]
end

#[]=(key, value) ⇒ Object 



92
93
94
 
# File 'lib/supercast/data_object.rb', line 92

def []=(key, value)
  send(:"#{key}=", value)
end

#as_json(*opts) ⇒ Object 



108
109
110
 
# File 'lib/supercast/data_object.rb', line 108

def as_json(*opts)
  @values.as_json(*opts)
end

#dirty! ⇒ Object

Sets all keys within the DataObject as unsaved so that they will be included with an update when #serialize_params is called.



133
134
135
136
137
138
139
 
# File 'lib/supercast/data_object.rb', line 133

def dirty!
  @unsaved_values = Set.new(@values.keys)

  @values.each_value do |v|
    dirty_value!(v)
  end
end

#each(&blk) ⇒ Object 



127
128
129
 
# File 'lib/supercast/data_object.rb', line 127

def each(&blk)
  @values.each(&blk)
end

#eql?(other) ⇒ Boolean

Hash equality. As with ‘#==`, we consider two equivalent Supercast objects equal.

Returns:

  • (Boolean) 


41
42
43
44
 
# File 'lib/supercast/data_object.rb', line 41

def eql?(other)
  # Defer to the implementation on `#==`.
  self == other
end

#hash ⇒ Object

As with equality in ‘#==` and `#eql?`, we hash two Supercast objects to the same value if they’re equivalent objects.



48
49
50
 
# File 'lib/supercast/data_object.rb', line 48

def hash
  @values.hash
end

#inspect ⇒ Object 



56
57
58
59
60
 
# File 'lib/supercast/data_object.rb', line 56

def inspect
  id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ''
  "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " +
    JSON.pretty_generate(@values)
end

#keys ⇒ Object 



96
97
98
 
# File 'lib/supercast/data_object.rb', line 96

def keys
  @values.keys
end

#marshal_dump ⇒ Object

Implements custom encoding for Ruby’s Marshal. The data produced by this method should be comprehendable by #marshal_load.

This allows us to remove certain features that cannot or should not be serialized.



146
147
148
149
150
151
152
153
 
# File 'lib/supercast/data_object.rb', line 146

def marshal_dump
  # The Client instance in @opts is not serializable and is not
  # really a property of the DataObject, so we exclude it when
  # dumping
  opts = @opts.clone
  opts.delete(:client)
  [@values, opts]
end

#marshal_load(data) ⇒ Object

Implements custom decoding for Ruby’s Marshal. Consumes data that’s produced by #marshal_dump.



157
158
159
160
161
 
# File 'lib/supercast/data_object.rb', line 157

def marshal_load(data)
  values, opts = data
  initialize(values[:id])
  initialize_from(values, opts)
end

#serialize_params(options = {}) ⇒ Object 



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/supercast/data_object.rb', line 163

def serialize_params(options = {})
  update_hash = {}

  @values.each do |k, _v|
    # There are a few reasons that we may want to add in a parameter for
    # update:
    #
    #   1. The `force` option has been set.
    #   2. We know that it was modified.
    #
    unsaved = @unsaved_values.include?(k)
    next unless options[:force] || unsaved

    update_hash[k.to_sym] = serialize_params_value(
      @values[k], @original_values[k], unsaved, options[:force], key: k
    )
  end

  # a `nil` that makes it out of `#serialize_params_value` signals an empty
  # value that we shouldn't appear in the serialized form of the object
  update_hash.reject! { |_, v| v.nil? }

  update_hash
end

#to_hash ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/supercast/data_object.rb', line 112

def to_hash
  maybe_to_hash = lambda do |value|
    value&.respond_to?(:to_hash) ? value.to_hash : value
  end

  @values.each_with_object({}) do |(key, value), acc|
    acc[key] = case value
               when Array
                 value.map(&maybe_to_hash)
               else
                 maybe_to_hash.call(value)
               end
  end
end

#to_json(_opts) ⇒ Object 



104
105
106
 
# File 'lib/supercast/data_object.rb', line 104

def to_json(_opts)
  JSON.generate(@values)
end

#to_s(*_args) ⇒ Object 



52
53
54
 
# File 'lib/supercast/data_object.rb', line 52

def to_s(*_args)
  JSON.pretty_generate(to_hash)
end

#update_attributes(values, opts = {}, dirty: true) ⇒ Object

Mass assigns attributes on the model.

This is a version of update_attributes that takes some extra options for internal use.

Attributes

  • values - Hash of values to use to update the current attributes of the object.

  • opts - Options for DataObject like an API key that will be reused on subsequent API calls.

Options

  • :dirty - Whether values should be initiated as “dirty” (unsaved) and which applies only to new DataObjects being initiated under this DataObject. Defaults to true.



79
80
81
82
83
84
85
86
 
# File 'lib/supercast/data_object.rb', line 79

def update_attributes(values, opts = {}, dirty: true)
  values.each do |k, v|
    add_accessors([k], values) unless metaclass.method_defined?(k.to_sym)
    @values[k] = Util.convert_to_supercast_object(v, opts)
    dirty_value!(@values[k]) if dirty
    @unsaved_values.add(k)
  end
end

#values ⇒ Object 



100
101
102
 
# File 'lib/supercast/data_object.rb', line 100

def values
  @values.values
end