Class: Remotely::Model

Inherits:
Object
  • Object
show all
Extended by:
ActiveModel::Naming, Forwardable, HTTPMethods
Includes:
ActiveModel::Conversion, Associations
Defined in:
lib/remotely/model.rb

Constant Summary

Constants included from HTTPMethods

HTTPMethods::SUCCESS_STATUSES

Class Attribute Summary collapse

Instance Attribute Summary collapse

Attributes included from HTTPMethods

#app, #uri

Class Method Summary collapse

Instance Method Summary collapse

Methods included from HTTPMethods

before_request, expand, get, http_delete, parse_response, post, put, raise_if_html

Methods included from Associations

included, #path_to, #remote_associations

Constructor Details

#initialize(attributes = {}) ⇒ Model

Returns a new instance of Model.



156
157
158
159
160
 
# File 'lib/remotely/model.rb', line 156

def initialize(attributes={})
  set_errors(attributes.delete('errors')) if attributes['errors']
  self.attributes = attributes.symbolize_keys
  associate!
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object (private) 



298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/remotely/model.rb', line 298

def method_missing(name, *args, &block)
  if self.attributes.include?(name)
    self.attributes[name]
  elsif name =~ /(.*)=$/ && self.attributes.include?($1.to_sym)
    self.attributes[$1.to_sym] = args.first
  elsif name =~ /(.*)\?$/ && self.attributes.include?($1.to_sym)
    !!self.attributes[$1.to_sym]
  else
    super
  end
end

Class Attribute Details

.savable_attributes ⇒ Object (readonly)

Array of attributes to be sent when saving



12
13
14
 
# File 'lib/remotely/model.rb', line 12

def savable_attributes
  @savable_attributes
end

Instance Attribute Details

#attributes ⇒ Hash

Returns Key-value of attributes and values.

Returns:

  • (Hash) —

    Key-value of attributes and values.



154
155
156
 
# File 'lib/remotely/model.rb', line 154

def attributes
  @attributes
end

Class Method Details

.all ⇒ Remotely::Collection

Fetch all entries.

Returns:



32
33
34
 
# File 'lib/remotely/model.rb', line 32

def all
  get uri
end

.attr_savable(*attrs) ⇒ Object

Mark an attribute as safe to save. The save method will only send these attributes when called.

Examples:

Mark name and age as savable

attr_savable :name, :age

Parameters:

  • *attrs (Symbols) —

    List of attributes to make savable.



22
23
24
25
26
 
# File 'lib/remotely/model.rb', line 22

def attr_savable(*attrs)
  @savable_attributes ||= []
  @savable_attributes += attrs
  @savable_attributes.uniq!
end

.base_class ⇒ Object

Remotely models don’t support single table inheritence so the base class is always itself.



128
129
130
 
# File 'lib/remotely/model.rb', line 128

def base_class
  self
end

.create(params = {}) ⇒ Remotely::Model, Boolean Also known as: create!

Creates a new resource.

Parameters:

  • params (Hash) (defaults to: {}) —

    Attributes to create the new resource with.

Returns:

  • (Remotely::Model, Boolean) —

    If the creation succeeds, a new model object is returned, otherwise false.



96
97
98
 
# File 'lib/remotely/model.rb', line 96

def create(params={})
  new(params).tap { |n| n.save }
end

.destroy(id) ⇒ Boolean

Destroy an individual resource.

Parameters:

  • id (Fixnum) —

    id of the resource to destroy.

Returns:

  • (Boolean) —

    If the destruction succeeded.



119
120
121
 
# File 'lib/remotely/model.rb', line 119

def destroy(id)
  http_delete URL(uri, id)
end

.destroy! ⇒ Boolean

Destroy an individual resource.

Parameters:

  • id (Fixnum) —

    id of the resource to destroy.

Returns:

  • (Boolean) —

    If the destruction succeeded.



123
124
125
 
# File 'lib/remotely/model.rb', line 123

def destroy(id)
  http_delete URL(uri, id)
end

.find(id) ⇒ Remotely::Model

Retreive a single object. Combines uri and id to determine the URI to use.

Examples:

Find the User with id=1

User.find(1)

Parameters:

  • id (Fixnum) —

    The id of the resource.

Returns:



46
47
48
 
# File 'lib/remotely/model.rb', line 46

def find(id)
  get URL(uri, id)
end

.find_or_create(attrs = {}) ⇒ Remotely::Model

Fetch the first record matching attrs or initialize and save a new instance with those attributes.

Parameters:

  • attrs (Hash) (defaults to: {}) —

    Attributes to search by, and subsequently instantiate and save with, if not found.

Returns:



70
71
72
 
# File 'lib/remotely/model.rb', line 70

def find_or_create(attrs={})
  where(attrs).first or create(attrs)
end

.find_or_initialize(attrs = {}) ⇒ Remotely::Model

Fetch the first record matching attrs or initialize a new instance with those attributes.

Parameters:

  • attrs (Hash) (defaults to: {}) —

    Attributes to search by, and subsequently instantiate with, if not found.

Returns:



58
59
60
 
# File 'lib/remotely/model.rb', line 58

def find_or_initialize(attrs={})
  where(attrs).first or new(attrs)
end

.update_all(params = {}) ⇒ Boolean Also known as: update_all!

Update every entry with values from params.

Parameters:

  • params (Hash) (defaults to: {}) —

    Key-Value pairs of attributes to update

Returns:

  • (Boolean) —

    If the update succeeded



107
108
109
 
# File 'lib/remotely/model.rb', line 107

def update_all(params={})
  put uri, params
end

.where(params = {}) ⇒ Remotely::Collection

Search the remote API for a resource matching conditions specified in params. Sends params as a url-encoded query string. It assumes the search endpoint is at “/resource_plural/search”.

Examples:

Search for a person by name and title

User.where(:name => "Finn", :title => "The Human")

Parameters:

  • params (Hash) (defaults to: {}) —

    Key-value pairs of attributes and values to search by.

Returns:



85
86
87
 
# File 'lib/remotely/model.rb', line 85

def where(params={})
  get URL(uri, "search"), params
end

Instance Method Details

#destroy ⇒ Object

Destroy this object with the might of 60 jotun!



241
242
243
 
# File 'lib/remotely/model.rb', line 241

def destroy
  self.class.destroy(id)
end

#errors ⇒ Object

Track errors with ActiveModel::Errors



235
236
237
 
# File 'lib/remotely/model.rb', line 235

def errors
  @errors ||= ActiveModel::Errors.new(self)
end

#id ⇒ Object 



252
253
254
 
# File 'lib/remotely/model.rb', line 252

def id
  self.attributes[:id]
end

#new_record? ⇒ Boolean

Assumes that if the object doesn’t have an id, it’s new.

Returns:

  • (Boolean) 


258
259
260
 
# File 'lib/remotely/model.rb', line 258

def new_record?
  self.attributes[:id].nil?
end

#persisted? ⇒ Boolean

Returns:

  • (Boolean) 


262
263
264
 
# File 'lib/remotely/model.rb', line 262

def persisted?
  !new_record?
end

#reload ⇒ Object

Re-fetch the resource from the remote API.



247
248
249
250
 
# File 'lib/remotely/model.rb', line 247

def reload
  self.attributes = get(URL(uri, id)).attributes
  self
end

#respond_to?(name) ⇒ Boolean

Returns:

  • (Boolean) 


266
267
268
 
# File 'lib/remotely/model.rb', line 266

def respond_to?(name)
  self.attributes and self.attributes.include?(name) or super
end

#savable_attributes ⇒ Object 



223
224
225
 
# File 'lib/remotely/model.rb', line 223

def savable_attributes
  (self.class.savable_attributes || attributes.keys) << :id
end

#save ⇒ Boolean

Persist this object to the remote API.

If the request returns a status code of 201 or 200 (for creating new records and updating existing ones, respectively) it is considered a successful save and returns the object. Any other status will result in a return value of false. In addition, the obj.errors collection will be populated with any errors returns from the remote API.

For save to handle errors correctly, the remote API should return a response body which matches a JSONified ActiveRecord errors object. ie:

{"errors":{"attribute":["message", "message"]}}

Returns:

  • (Boolean) —

    Remote API returns 200/201 status: true Remote API returns any other status: false



205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/remotely/model.rb', line 205

def save
  method = new_record? ? :post      : :put
  status = new_record? ? 201        : 200
  attrs  = new_record? ? attributes : attributes.slice(*savable_attributes)
  url    = new_record? ? uri        : URL(uri, id)

  resp = public_send(method, url, attrs)
  body = MultiJson.load(resp.body)

  if resp.status == status && !body.nil?
    self.attributes.merge!(body.symbolize_keys)
    true
  else
    set_errors(body.delete("errors")) unless body.nil?
    false
  end
end

#set_errors(hash) ⇒ Object

Sets multiple errors with a hash



228
229
230
231
232
 
# File 'lib/remotely/model.rb', line 228

def set_errors(hash)
  (hash || {}).each do |attribute, messages|
    Array(messages).each {|m| errors.add(attribute, m) }
  end
end

#to_json ⇒ Object 



270
271
272
 
# File 'lib/remotely/model.rb', line 270

def to_json
  MultiJson.dump(self.attributes)
end

#update_attribute(name, value) ⇒ Boolean, Mixed

Update a single attribute.

Parameters:

  • name (Symbol, String) —

    Attribute name

  • value (Mixed) —

    New value for the attribute

  • should_save (Boolean) —

    Should it save after updating the attributes. Default: true

Returns:

  • (Boolean, Mixed) —

    Boolean if the it tried to save, the new value otherwise.



171
172
173
174
 
# File 'lib/remotely/model.rb', line 171

def update_attribute(name, value)
  self.attributes[name.to_sym] = value
  save
end

#update_attributes(attrs = {}) ⇒ Boolean

Update multiple attributes.

Parameters:

  • attrs (Hash) (defaults to: {}) —

    Hash of attributes/values to update with.

Returns:

  • (Boolean) —

    Did the save succeed.



181
182
183
184
 
# File 'lib/remotely/model.rb', line 181

def update_attributes(attrs={})
  self.attributes.merge!(attrs.symbolize_keys)
  save
end