Class: Traim::Resource

Inherits:
Object
  • Object
show all
Defined in:
lib/traim.rb

Constant Summary collapse

ACTION_METHODS = 
{create: 'POST', show: 'GET', update: 'PUT', destory: 'DELETE'}

Instance Method Summary collapse

Constructor Details

#initialize(block, helper) ⇒ Resource

Returns a new instance of Resource.



234
235
236
237
 
# File 'lib/traim.rb', line 234

def initialize(block, helper) 
  instance_eval(&block) 
  @helper = helper
end

Instance Method Details

#action(name, options = {}, &block) ⇒ Object 



250
251
252
 
# File 'lib/traim.rb', line 250

def action(name, options = {}, &block)
  actions[ACTION_METHODS[name]] = {block: block, options: options}
end

#actions ⇒ Object 



249
 
# File 'lib/traim.rb', line 249

def actions; @actions ||= {} end

#attribute(name, &block) ⇒ Object 



274
275
276
 
# File 'lib/traim.rb', line 274

def attribute(name, &block)
  fields << {name: name, type: 'attribute', block: block} 
end

#build_controller(request) ⇒ Object 



286
287
288
 
# File 'lib/traim.rb', line 286

def build_controller(request)
  controller.new(model, actions.dup, @helper.clone, request)
end

#collection(name, &block) ⇒ Object 



263
264
265
 
# File 'lib/traim.rb', line 263

def collection(name, &block)
  collections[name] = block
end

#collections ⇒ Object 



261
 
# File 'lib/traim.rb', line 261

def collections; @collections ||= {} end

#controller(object = nil) ⇒ Object 



244
245
246
247
 
# File 'lib/traim.rb', line 244

def controller(object = nil)
  @controller = object unless object.nil?
  @controller || ArController
end

#fields ⇒ Object 



273
 
# File 'lib/traim.rb', line 273

def fields; @fields ||= [] end

#has_many(name, options = {}, &block) ⇒ Object 



278
279
280
 
# File 'lib/traim.rb', line 278

def has_many(name, options={}, &block)
  fields << {name: name, type: 'association', resource: options[:resource], block: block}
end

#has_one(name, options = {}, &block) ⇒ Object 



282
283
284
 
# File 'lib/traim.rb', line 282

def has_one(name, options={}, &block)
  fields << {name: name, type: 'connection', resource: options[:resource], block: block}
end

#logger ⇒ Object 



254
 
# File 'lib/traim.rb', line 254

def logger; Traim.logger  end

#member(name, &block) ⇒ Object 



269
270
271
 
# File 'lib/traim.rb', line 269

def member(name, &block)
  members[name] = block
end

#members ⇒ Object 



267
 
# File 'lib/traim.rb', line 267

def members; @members ||= {} end

#model(object = nil, options = {}) ⇒ Object 



239
240
241
242
 
# File 'lib/traim.rb', line 239

def model(object = nil, options = {})
  @model = object unless object.nil? 
  @model
end

#resource(object = nil) ⇒ Object 



256
257
258
259
 
# File 'lib/traim.rb', line 256

def resource(object = nil)
  @resource = object unless object.nil?
  @resource
end

#to_hash(controller, resources, nested_associations = []) ⇒ Object 



290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/traim.rb', line 290

def to_hash(controller, resources, nested_associations = []) 
  return if controller.nil?

  hash_fields = fields
  hash_fields += controller.fields if controller.respond_to? :fields
  hash_fields.inject({}) do | hash, attr|
    name = attr[:name]

    hash[name] = if attr[:type] == 'attribute'
      if attr[:block].nil?
        controller.attributes[name.to_s]
      else
        attribute_controller = build_controller(controller.request)
        attribute_controller.record = controller.record
        attribute_controller.execute(attr[:block])
      end
    elsif  attr[:type] == 'association'
      raise Error if nested_associations.include?(name)
      nested_associations << name
      resource = resources[attr[:resource] || name]
      associated_controller = resource.build_controller(controller.request)
      associated_controller.record = if attr[:block].nil?
        controller.send(name)
      else
        controller.dup.execute(attr[:block])
      end
      associated_controller.map_record do |item, controller|
        resource.to_hash(controller, resources, nested_associations.dup) 
      end
    else
      resource_name = name.to_s.pluralize.to_sym
      raise Error.new(message: "Inifinite Association") if nested_associations.include?(resource_name)
      nested_associations << resource_name 
      resource = resources[attr[:resource] || resource_name]
      connected_controller = resource.build_controller(controller.request)
      connected_controller.record = if attr[:block].nil?
        controller.send(name) 
      else
        controller.dup.execute(attr[:block])
      end
      resource.to_hash(connected_controller, resources, nested_associations.dup)
    end
    hash
  end
end