1
2
3
4
5
6
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
module ActionController #:nodoc:
# Renderer is responsible to expose a resource for different mime requests,
# usually depending on the HTTP verb. The renderer is triggered when
# respond_with is called. The simplest case to study is a GET request:
#
# class PeopleController < ApplicationController
# respond_to :html, :xml, :json
#
# def index
# @people = Person.find(:all)
# respond_with(@people)
# end
# end
#
# When a request comes, for example with format :xml, three steps happen:
#
# 1) respond_with searches for a template at people/index.xml;
#
# 2) if the template is not available, it will create a renderer, passing
# the controller and the resource and invoke :to_xml on it;
#
# 3) if the renderer does not respond_to :to_xml, call to_format on it.
#
# === Builtin HTTP verb semantics
#
# Rails default renderer holds semantics for each HTTP verb. Depending on the
# content type, verb and the resource status, it will behave differently.
#
# Using Rails default renderer, a POST request for creating an object could
# be written as:
#
# def create
# @user = User.new(params[:user])
# flash[:notice] = 'User was successfully created.' if @user.save
# respond_with(@user)
# end
#
# Which is exactly the same as:
#
# def create
# @user = User.new(params[:user])
#
# respond_to do |format|
# if @user.save
# flash[:notice] = 'User was successfully created.'
# format.html { redirect_to(@user) }
# format.xml { render :xml => @user, :status => :created, :location => @user }
# else
# format.html { render :action => "new" }
# format.xml { render :xml => @user.errors, :status => :unprocessable_entity }
# end
# end
# end
#
# The same happens for PUT and DELETE requests.
#
# === Nested resources
#
# You can given nested resource as you do in form_for and polymorphic_url.
# Consider the project has many tasks example. The create action for
# TasksController would be like:
#
# def create
# @project = Project.find(params[:project_id])
# @task = @project.comments.build(params[:task])
# flash[:notice] = 'Task was successfully created.' if @task.save
# respond_with([@project, @task])
# end
#
# Giving an array of resources, you ensure that the renderer will redirect to
# project_task_url instead of task_url.
#
# Namespaced and singleton resources requires a symbol to be given, as in
# polymorphic urls. If a project has one manager which has many tasks, it
# should be invoked as:
#
# respond_with([@project, :manager, @task])
#
# Check polymorphic_url documentation for more examples.
#
class Renderer
attr_reader :controller, :request, :format, :resource, :resource_location, :options
def initialize(controller, resource, options={})
@controller = controller
@request = controller.request
@format = controller.formats.first
@resource = resource.is_a?(Array) ? resource.last : resource
@resource_location = options[:location] || resource
@options = options
end
delegate :head, :render, :redirect_to, :to => :controller
delegate :get?, :post?, :put?, :delete?, :to => :request
# Undefine :to_json since it's defined on Object
undef_method :to_json
# Initializes a new renderer an invoke the proper format. If the format is
# not defined, call to_format.
#
def self.call(*args)
renderer = new(*args)
method = :"to_#{renderer.format}"
renderer.respond_to?(method) ? renderer.send(method) : renderer.to_format
end
# HTML format does not render the resource, it always attempt to render a
# template.
#
def to_html
if get?
render
elsif has_errors?
render :action => default_action
else
redirect_to resource_location
end
end
# All others formats try to render the resource given instead. For this
# purpose a helper called display as a shortcut to render a resource with
# the current format.
#
def to_format
return render unless resourceful?
if get?
display resource
elsif has_errors?
display resource.errors, :status => :unprocessable_entity
elsif post?
display resource, :status => :created, :location => resource_location
else
head :ok
end
end
protected
# Checks whether the resource responds to the current format or not.
#
def resourceful?
resource.respond_to?(:"to_#{format}")
end
# display is just a shortcut to render a resource with the current format.
#
# display @user, :status => :ok
#
# For xml request is equivalent to:
#
# render :xml => @user, :status => :ok
#
# Options sent by the user are also used:
#
# respond_with(@user, :status => :created)
# display(@user, :status => :ok)
#
# Results in:
#
# render :xml => @user, :status => :created
#
def display(resource, given_options={})
render given_options.merge!(options).merge!(format => resource)
end
# Check if the resource has errors or not.
#
def has_errors?
resource.respond_to?(:errors) && !resource.errors.empty?
end
# By default, render the :edit action for html requests with failure, unless
# the verb is post.
#
def default_action
request.post? ? :new : :edit
end
end
end
|
