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(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
 
# File 'lib/nested/resource.rb', line 7

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

  @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 



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

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

#before(&block) ⇒ Object 



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

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

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



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

def child_resource(name, clazz, resource_if_block, model_block, &block)
   clazz.new(@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 



238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
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
 
# File 'lib/nested/resource.rb', line 238

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.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 << "resource: #{resource.name} (#{resource.class.name})"
      resource_object = instance_variable_get("@#{resource.instance_variable_name}")
      context_arr << "@#{resource.instance_variable_name}: #{resource_object.inspect}"

      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")
      raise e
    end
  end
end

#default_model_block ⇒ Object 



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

def default_model_block
  raise "implement me"
end

#initialize_serializer_factory ⇒ Object 



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

def initialize_serializer_factory
  Serializer.new([])
end

#instance_variable_name ⇒ Object 



107
108
109
 
# File 'lib/nested/resource.rb', line 107

def instance_variable_name
  @name
end

#parents ⇒ Object 



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

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

#route(action = nil) ⇒ Object 



85
86
87
88
89
90
91
 
# File 'lib/nested/resource.rb', line 85

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 



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

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

#self_and_parents ⇒ Object 



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

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

#serialize(*args) ⇒ Object 



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

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

#serialize_exclude_if(condition, *args) ⇒ Object 



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

def serialize_exclude_if(condition, *args)
  args.each {|arg| @serializer - SerializerField.new(arg, condition) }
  self
end

#serialize_include_if(condition, *args) ⇒ Object 



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

def serialize_include_if(condition, *args)
  args.each {|arg| @serializer + SerializerField.new(arg, condition) }
  self
end

#sinatra_errors_to_hash(errors) ⇒ Object 



226
227
228
229
230
231
 
# File 'lib/nested/resource.rb', line 226

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 



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

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 



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

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 



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

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 



176
177
178
179
 
# File 'lib/nested/resource.rb', line 176

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 



126
127
128
129
130
131
132
133
134
 
# File 'lib/nested/resource.rb', line 126

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 



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

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

#sinatra_init_before(sinatra) ⇒ Object 



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

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

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



162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/nested/resource.rb', line 162

def sinatra_init_data(method, sinatra, &block)
  raw_data = if [:put, :post].include?(method)
    sinatra.request.body.rewind
    HashWithIndifferentAccess.new(JSON.parse(sinatra.request.body.read))
  elsif [:get, :delete].include?(method)
    sinatra.params
  else
    {}
  end

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

#sinatra_init_set_model(sinatra) ⇒ Object 



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

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 



136
137
138
 
# File 'lib/nested/resource.rb', line 136

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

#sinatra_response(sinatra, method) ⇒ Object 



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/nested/resource.rb', line 193

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 



216
217
218
219
220
221
222
223
224
 
# File 'lib/nested/resource.rb', line 216

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 



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

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 



212
213
214
 
# File 'lib/nested/resource.rb', line 212

def sinatra_response_create_redirect(sinatra, response, method)
  response
end

#sinatra_response_type(response) ⇒ Object 



189
190
191
 
# File 'lib/nested/resource.rb', line 189

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 



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

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 



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

def to_route_part
  "/#{@name}"
end