Class: Cubits::Resource

Inherits:
Hashie::Mash
  • Object
show all
Defined in:
lib/cubits/resource.rb

Direct Known Subclasses

Account, Channel, Channel::Tx, Invoice, Quote

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.all ⇒ Array<Resource>

Loads collection of resources

Returns:



76
77
78
79
80
81
 
# File 'lib/cubits/resource.rb', line 76

def self.all
  fail NoMethodError, "Resource #{name} does not expose .all" unless exposed_method?(:all)
  Cubits.connection.get(path_to)[collection_name].map { |r| new r }
rescue NotFound
  nil
end

.belongs_to(association_name, params = {}) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/cubits/resource.rb', line 60

def self.belongs_to(association_name, params = {})
  define_method(association_name) do
    association_id = send :"#{association_name}_id"
    unless association_id
      fail ArgumentError, "No #{association_name}_id attribute is defined for #{self}"
    end
    class_name = params[:class_name] || association_name.to_s.capitalize
    resource = Cubits.const_get(class_name) || fail("Failed to find class #{class_name}")
    resource.find(association_id)
  end
end

.collection_name ⇒ Object

By convention collection name for the resource is the last part of the path



14
15
16
 
# File 'lib/cubits/resource.rb', line 14

def self.collection_name
  @path.split('/').last
end

.create(params = {}) ⇒ Object

Creates a new resource



140
141
142
143
 
# File 'lib/cubits/resource.rb', line 140

def self.create(params = {})
  fail NoMethodError, "Resource #{name} does not expose .create" unless exposed_method?(:create)
  new Cubits.connection.post(path_to, params)
end

.expose_methods(*args) ⇒ Object

Sets exposed methods for the resource



20
21
22
 
# File 'lib/cubits/resource.rb', line 20

def self.expose_methods(*args)
  @exposed_methods = args
end

.exposed_method?(method_name) ⇒ Boolean

Returns true if the method is exposed by this resource.

Returns:

  • (Boolean) —

    true if the method is exposed by this resource



26
27
28
 
# File 'lib/cubits/resource.rb', line 26

def self.exposed_method?(method_name)
  (@exposed_methods || []).include?(method_name)
end

.find(id) ⇒ Object

Loads resource

Parameters:

  • id (String)

Returns:

  • nil if resource is not found



89
90
91
92
93
94
 
# File 'lib/cubits/resource.rb', line 89

def self.find(id)
  fail NoMethodError, "Resource #{name} does not expose .find" unless exposed_method?(:find)
  new Cubits.connection.get(path_to(id))
rescue NotFound
  nil
end

.from_callback(params) ⇒ Resource, Hash

Processes callback request parsed into separate params and instantiates a resource object on success.

Parameters:

  • params (Hash)
  • params (:cubits_callback_id) —
    String

    Value of the CUBITS_CALLBACK_ID header

  • params (:cubits_key) —
    String

    Value of the CUBITS_KEY header

  • params (:cubits_signature) —
    String

    Value of the CUBITS_SIGNATURE header

  • params (:body) —
    String

    Request body

  • params (:allow_insecure) —
    Boolean

    (optional) Allow insecure, unsigned callbacks (default: false)

Returns:

Raises:



111
112
113
114
115
116
 
# File 'lib/cubits/resource.rb', line 111

def self.from_callback(params)
  unless exposed_method?(:from_callback)
    fail NoMethodError, "Resource #{name} does not expose .from_callback"
  end
  Cubits::Callback.from_params(params.merge(resource_class: self))
end

.has_many(association_name, params = {}) ⇒ Object

Associations



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/cubits/resource.rb', line 44

def self.has_many(association_name, params = {})
  define_method(association_name) do
    association = instance_variable_get("@#{association_name}")
    return association if association
    class_name = params[:class_name] || association_name.to_s.capitalize.sub(/s$/, '')
    resource = Cubits.const_get(class_name) || fail("Failed to find class #{class_name}")
    association = ResourceCollection.new(
      path: self.class.path_to(id) + '/' + association_name.to_s,
      resource: resource,
      expose_methods: params[:expose_methods] || [:find, :all]
    )
    instance_variable_set("@#{association_name}", association)
    association
  end
end

.path(p) ⇒ Object

Sets path for the resource



8
9
10
 
# File 'lib/cubits/resource.rb', line 8

def self.path(p)
  @path = p
end

.path_to(resource_or_id = nil) ⇒ Object

Returns API path to resource



32
33
34
35
36
37
38
39
40
41
 
# File 'lib/cubits/resource.rb', line 32

def self.path_to(resource_or_id = nil)
  fail ArgumentError, "Resource path is not set for #{name}" unless @path
  if resource_or_id.is_a?(Resource)
    "#{@path}/#{resource_or_id.id}"
  elsif resource_or_id
    "#{@path}/#{resource_or_id}"
  else
    @path
  end
end

Instance Method Details

#reload ⇒ Object

Reloads resource



120
121
122
123
124
125
126
 
# File 'lib/cubits/resource.rb', line 120

def reload
  unless self.class.exposed_method?(:reload)
    fail NoMethodError, "Resource #{self.class.name} does not expose #reload"
  end
  fail "Resource #{self.class.name} does not have an id" unless self.respond_to?(:id)
  replace(self.class.find(id))
end

#update(params = {}) ⇒ Object

Updates the resource



130
131
132
133
134
135
136
 
# File 'lib/cubits/resource.rb', line 130

def update(params = {})
  unless self.class.exposed_method?(:update)
    fail NoMethodError, "Resource #{self.class.name} does not expose #update"
  end
  fail "Resource #{self.class.name} does not have an id" unless self.respond_to?(:id)
  replace(self.class.new Cubits.connection.post(self.class.path_to(id), params))
end