Class: Nested::Resource

Inherits:
Object
  • Object
show all
Includes:
WithSingleton
Defined in:
lib/nested/resource.rb

Direct Known Subclasses

Many, One, Singleton

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from WithSingleton

#singleton, #singleton_if

Constructor Details

#initialize(app, sinatra, name, parent, resource_if_block, model_block) ⇒ Resource

Returns a new instance of Resource.



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/nested/resource.rb', line 7

def initialize(app, sinatra, name, parent, resource_if_block, model_block)
  raise "resource must be given a name" unless name

  @app = app
  @sinatra = sinatra
  @name = name
  @parent = parent
  @resources = []
  @actions = []

  raise "resource_if_block is nil, pass Nested::PROC_TRUE instead" unless resource_if_block
  @resource_if_block = resource_if_block

  unless @model_block = model_block
    if is_a?(One)
      @model_block = default_model_block
    else
      @model_block = resource_if_block != PROC_TRUE ? parent.try(:model_block) : default_model_block
    end
  end

  raise "no model_block passed and could not lookup any parent or default model_block" unless @model_block

  @before_blocks = []
  @after_blocks = []

  @serializer = initialize_serializer_factory
end

Instance Attribute Details

#actions ⇒ Object (readonly)

Returns the value of attribute actions.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def actions
  @actions
end

#after_blocks ⇒ Object (readonly)

Returns the value of attribute after_blocks.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def after_blocks
  @after_blocks
end

#before_blocks ⇒ Object (readonly)

Returns the value of attribute before_blocks.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def before_blocks
  @before_blocks
end

#model_block ⇒ Object (readonly)

Returns the value of attribute model_block.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def model_block
  @model_block
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def name
  @name
end

#parent ⇒ Object (readonly)

Returns the value of attribute parent.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def parent
  @parent
end

#resources ⇒ Object (readonly)

Returns the value of attribute resources.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def resources
  @resources
end

#serializer ⇒ Object (readonly)

Returns the value of attribute serializer.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def serializer
  @serializer
end

#sinatra ⇒ Object (readonly)

Returns the value of attribute sinatra.



3
4
5
 
# File 'lib/nested/resource.rb', line 3

def sinatra
  @sinatra
end

Instance Method Details

#after(&block) ⇒ Object 



63
64
65
66
 
# File 'lib/nested/resource.rb', line 63

def after(&block)
  @after_blocks << block
  self
end

#before(&block) ⇒ Object 



58
59
60
61
 
# File 'lib/nested/resource.rb', line 58

def before(&block)
  @before_blocks << block
  self
end

#behave(name) ⇒ Object 



36
37
38
 
# File 'lib/nested/resource.rb', line 36

def behave(name)
  instance_exec(&@app.behaviors[name])
end

#child_resource(name, clazz, resource_if_block, model_block, &block) ⇒ Object 



44
45
46
47
48
 
# File 'lib/nested/resource.rb', line 44

def child_resource(name, clazz, resource_if_block, model_block, &block)
   clazz.new(@app, @sinatra, name, self, resource_if_block, model_block)
    .tap{|r| r.instance_eval(&(block||Proc.new{ }))}
    .tap{|r| @resources << r}
end

#create_sinatra_route(method, action, method_if_block, &block) ⇒ Object 



258
259
260
261
262
263
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
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/nested/resource.rb', line 258

def create_sinatra_route(method, action, method_if_block, &block)
  @actions << {method: method, action: action, block: block}

  resource = self

  route = resource.route(action)

  @sinatra.send(method, route) do
    def self.error(message)
      errors.add(:base, message)
    end

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

    begin
      content_type :json

      resource.sinatra_init_data(self, method, &block)

      resource.self_and_parents.reverse.each do |res|
        res.sinatra_init(self)
      end

      raise "method_if_block returns false for method: #{method}, action: #{action}, resource: #{resource.name}" unless instance_exec(&method_if_block)

      resource.send(:"sinatra_exec_#{method}_block", self, &block)

      resource.sinatra_response(self, method)
    rescue Exception => e
      context_arr = []
      context_arr << "route: #{route}"
      context_arr << "method: #{method}"
      context_arr << "action: #{action}"
      context_arr << "params: #{params.inspect}"
      context_arr << "__raw_data: #{@__raw_data.inspect}"
      context_arr << "__data: #{@__data.inspect}"


      context_arr << "resource: #{resource.name} (#{resource.class.name})"
      resource_object = instance_variable_get("@#{resource.instance_variable_name}")
      context_arr << "@#{resource.instance_variable_name}: #{resource_object.inspect}"

      resource.parents.each do |parent|
        context_arr << "parent: #{parent.name} (#{parent.class.name})"
        parent_object = instance_variable_get("@#{parent.instance_variable_name}")
        context_arr << "@#{parent.instance_variable_name}: #{parent_object.inspect}"
      end

      # parent = resource.try(:parent)

      # if parent
      #   context_arr << "parent: #{parent.name} (#{parent.class.name})"
      #   parent_object = instance_variable_get("@#{parent.instance_variable_name}")
      #   context_arr << "@#{parent.instance_variable_name}: #{parent_object.inspect}"
      # end

      puts context_arr.join("\n")
      puts e.message
    end
  end
end

#default_model_block ⇒ Object 



50
51
52
 
# File 'lib/nested/resource.rb', line 50

def default_model_block
  raise "implement me"
end

#initialize_serializer_factory ⇒ Object 



40
41
42
 
# File 'lib/nested/resource.rb', line 40

def initialize_serializer_factory
  Serializer.new([])
end

#instance_variable_name ⇒ Object 



112
113
114
 
# File 'lib/nested/resource.rb', line 112

def instance_variable_name
  @name
end

#parents ⇒ Object 



116
117
118
 
# File 'lib/nested/resource.rb', line 116

def parents
  (@parent ? @parent.parents + [@parent] : [])
end

#route(action = nil) ⇒ Object 



90
91
92
93
94
95
96
 
# File 'lib/nested/resource.rb', line 90

def route(action=nil)
  "".tap do |r|
    r << @parent.route if @parent
    r << to_route_part
    r << "/#{action}" if action
  end
end

#route_replace(route, args) ⇒ Object 



83
84
85
86
87
88
 
# File 'lib/nested/resource.rb', line 83

def route_replace(route, args)
  args.each do |k, v|
    route = route.gsub(":#{k}", "#{v}")
  end
  route
end

#self_and_parents ⇒ Object 



120
121
122
 
# File 'lib/nested/resource.rb', line 120

def self_and_parents
  (self.parents + [self]).reverse
end

#serialize(*args) ⇒ Object 



68
69
70
71
 
# File 'lib/nested/resource.rb', line 68

def serialize(*args)
  args.each {|arg| serializer + arg }
  self
end

#serialize_exclude_if(condition, *args) ⇒ Object 



78
79
80
81
 
# File 'lib/nested/resource.rb', line 78

def serialize_exclude_if(condition, *args)
  args.each {|arg| @serializer - SerializerField.new(arg, condition.is_a?(Symbol) ? @app.conditions[condition] : condition) }
  self
end

#serialize_include_if(condition, *args) ⇒ Object 



73
74
75
76
 
# File 'lib/nested/resource.rb', line 73

def serialize_include_if(condition, *args)
  args.each {|arg| @serializer + SerializerField.new(arg, condition.is_a?(Symbol) ? @app.conditions[condition] : condition) }
  self
end

#sinatra_errors_to_hash(errors) ⇒ Object 



232
233
234
235
236
237
 
# File 'lib/nested/resource.rb', line 232

def sinatra_errors_to_hash(errors)
  errors.to_hash.inject({}) do |memo, e|
    memo[e[0]] = e[1][0]
    memo
  end
end

#sinatra_exec_delete_block(sinatra, &block) ⇒ Object 



162
163
164
165
 
# File 'lib/nested/resource.rb', line 162

def sinatra_exec_delete_block(sinatra, &block)
  # sinatra_init_data(:delete, sinatra, &block)
  sinatra.instance_exec(*sinatra.instance_variable_get("@__data"), &block)
end

#sinatra_exec_get_block(sinatra, &block) ⇒ Object 



157
158
159
160
 
# File 'lib/nested/resource.rb', line 157

def sinatra_exec_get_block(sinatra, &block)
  # sinatra_init_data(:get, sinatra, &block)
  sinatra.instance_exec(*sinatra.instance_variable_get("@__data"), &block)
end

#sinatra_exec_post_block(sinatra, &block) ⇒ Object 



187
188
189
190
191
192
193
 
# File 'lib/nested/resource.rb', line 187

def sinatra_exec_post_block(sinatra, &block)
  # sinatra_init_data(:post, sinatra, &block)
  res = sinatra.instance_exec(*sinatra.instance_variable_get("@__data"), &block)
  sinatra.instance_variable_set("@#{self.instance_variable_name}", res)
  # TODO: do we need to check for existing variables here?
  # sinatra_set_instance_variable(sinatra, self.instance_variable_name, res)
end

#sinatra_exec_put_block(sinatra, &block) ⇒ Object

sinatra.instance_variable_set(“@__raw_data”, raw_data)

sinatra.instance_variable_set("@__data", raw_data.values_at(*block.parameters.map(&:last)))

end



182
183
184
185
 
# File 'lib/nested/resource.rb', line 182

def sinatra_exec_put_block(sinatra, &block)
  # sinatra_init_data(:put, sinatra, &block)
  sinatra.instance_exec(*sinatra.instance_variable_get("@__data"), &block)
end

#sinatra_init(sinatra) ⇒ Object 



131
132
133
134
135
136
137
138
139
 
# File 'lib/nested/resource.rb', line 131

def sinatra_init(sinatra)
  sinatra_init_set_resource(sinatra)

  raise "resource_if is false for resource: #{self.name} " unless sinatra.instance_exec(&@resource_if_block)

  sinatra_init_before(sinatra)
  sinatra_init_set_model(sinatra)
  sinatra_init_after(sinatra)
end

#sinatra_init_after(sinatra) ⇒ Object 



153
154
155
 
# File 'lib/nested/resource.rb', line 153

def sinatra_init_after(sinatra)
  @after_blocks.each{|e| sinatra.instance_exec(&e)}
end

#sinatra_init_before(sinatra) ⇒ Object 



149
150
151
 
# File 'lib/nested/resource.rb', line 149

def sinatra_init_before(sinatra)
  @before_blocks.each{|e| sinatra.instance_exec(&e)}
end

#sinatra_init_data(sinatra, method, &block) ⇒ Object 



248
249
250
251
252
253
254
255
256
 
# File 'lib/nested/resource.rb', line 248

def sinatra_init_data(sinatra, method, &block)
  if [:put, :post].include?(method)
    sinatra.request.body.rewind
    sinatra.params.merge! HashWithIndifferentAccess.new(sinatra_init_data_extract_body(sinatra))
  end

  sinatra.instance_variable_set("@__raw_data", HashWithIndifferentAccess.new(sinatra.params))
  sinatra.instance_variable_set("@__data", HashWithIndifferentAccess.new(sinatra.params).values_at(*block.parameters.map(&:last)))
end

#sinatra_init_data_extract_body(sinatra) ⇒ Object 



244
245
246
 
# File 'lib/nested/resource.rb', line 244

def sinatra_init_data_extract_body(sinatra)
  JSON.parse(sinatra.request.body.read)
end

#sinatra_init_set_model(sinatra) ⇒ Object 



145
146
147
 
# File 'lib/nested/resource.rb', line 145

def sinatra_init_set_model(sinatra)
  sinatra.instance_variable_set("@#{self.instance_variable_name}", sinatra.instance_exec(*(@model_block.parameters.empty? ? [] : [sinatra.instance_exec(&default_model_block)]), &@model_block))
end

#sinatra_init_set_resource(sinatra) ⇒ Object 



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

def sinatra_init_set_resource(sinatra)
  sinatra.instance_variable_set("@__resource", self)
end

#sinatra_response(sinatra, method) ⇒ Object 



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/nested/resource.rb', line 199

def sinatra_response(sinatra, method)
  response = if sinatra.errors.empty?
    sinatra.instance_variable_get("@#{self.instance_variable_name}")
  else
    sinatra.errors
  end

  response = self.send(:"sinatra_response_create_#{sinatra_response_type(response)}", sinatra, response, method)

  case response
    when Nested::Redirect then
      sinatra.redirect(response.url)
    when String then
      response
    else
      response.to_json
  end
end

#sinatra_response_create_data(sinatra, response, method) ⇒ Object 



222
223
224
225
226
227
228
229
230
 
# File 'lib/nested/resource.rb', line 222

def sinatra_response_create_data(sinatra, response, method)
  data = if response && (is_a?(Many) || response.is_a?(Array)) && method != :post
    response.to_a.map{|e| sinatra.instance_exec(e, &@serializer.serialize) }
  else
    sinatra.instance_exec(response, &@serializer.serialize)
  end

  {data: data, ok: true}
end

#sinatra_response_create_error(sinatra, response, method) ⇒ Object 



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

def sinatra_response_create_error(sinatra, response, method)
  errors = response.is_a?(ActiveModel::Errors) ? response : response.errors
  {data: sinatra_errors_to_hash(errors), ok: false}
end

#sinatra_response_create_redirect(sinatra, response, method) ⇒ Object 



218
219
220
 
# File 'lib/nested/resource.rb', line 218

def sinatra_response_create_redirect(sinatra, response, method)
  response
end

#sinatra_response_type(response) ⇒ Object 



195
196
197
 
# File 'lib/nested/resource.rb', line 195

def sinatra_response_type(response)
  (response.is_a?(ActiveModel::Errors) || (response.respond_to?(:errors) && !response.errors.empty?)) ? :error : (response.is_a?(Nested::Redirect) ? :redirect : :data)
end

#sinatra_set_instance_variable(sinatra, name, value) ⇒ Object 



126
127
128
129
 
# File 'lib/nested/resource.rb', line 126

def sinatra_set_instance_variable(sinatra, name, value)
  raise "variable @#{name} already defined" if sinatra.instance_variable_defined?(:"@#{name}")
  sinatra.instance_variable_set(:"@#{name}", value)
end

#to_route_part ⇒ Object 



54
55
56
 
# File 'lib/nested/resource.rb', line 54

def to_route_part
  "/#{@name}"
end