2010-03-04 00:29:26 -05:00
|
|
|
require 'active_support/ordered_options'
|
|
|
|
|
2009-02-24 20:25:21 -05:00
|
|
|
module AbstractController
|
2009-12-12 19:48:34 -05:00
|
|
|
class Error < StandardError; end
|
|
|
|
class ActionNotFound < StandardError; end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-02-24 20:25:21 -05:00
|
|
|
class Base
|
|
|
|
attr_internal :response_body
|
2009-02-27 14:42:13 -05:00
|
|
|
attr_internal :action_name
|
2009-04-30 18:13:40 -04:00
|
|
|
|
|
|
|
class << self
|
2009-05-28 10:49:02 -04:00
|
|
|
attr_reader :abstract
|
2009-06-08 19:14:38 -04:00
|
|
|
alias_method :abstract?, :abstract
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-06-08 19:14:38 -04:00
|
|
|
# Define a controller as abstract. See internal_methods for more
|
|
|
|
# details.
|
2009-04-30 18:13:40 -04:00
|
|
|
def abstract!
|
|
|
|
@abstract = true
|
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-05-14 18:30:35 -04:00
|
|
|
def inherited(klass)
|
2009-06-08 19:14:38 -04:00
|
|
|
::AbstractController::Base.descendants << klass.to_s
|
2009-05-14 18:30:35 -04:00
|
|
|
super
|
|
|
|
end
|
|
|
|
|
2009-06-08 19:14:38 -04:00
|
|
|
# A list of all descendents of AbstractController::Base. This is
|
|
|
|
# useful for initializers which need to add behavior to all controllers.
|
|
|
|
def descendants
|
|
|
|
@descendants ||= []
|
2009-05-14 18:30:35 -04:00
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2010-03-03 22:45:08 -05:00
|
|
|
def config
|
|
|
|
@config ||= ActiveSupport::InheritableOptions.new(superclass < Base ? superclass.config : {})
|
|
|
|
end
|
|
|
|
|
2010-03-04 03:52:10 -05:00
|
|
|
def configure
|
|
|
|
yield config
|
|
|
|
end
|
|
|
|
|
2009-06-08 19:14:38 -04:00
|
|
|
# A list of all internal methods for a controller. This finds the first
|
|
|
|
# abstract superclass of a controller, and gets a list of all public
|
|
|
|
# instance methods on that abstract class. Public instance methods of
|
|
|
|
# a controller would normally be considered action methods, so we
|
|
|
|
# are removing those methods on classes declared as abstract
|
2009-08-06 18:50:22 -04:00
|
|
|
# (ActionController::Metal and ActionController::Base are defined
|
2009-06-08 19:14:38 -04:00
|
|
|
# as abstract)
|
2009-04-30 18:13:40 -04:00
|
|
|
def internal_methods
|
|
|
|
controller = self
|
|
|
|
controller = controller.superclass until controller.abstract?
|
|
|
|
controller.public_instance_methods(true)
|
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-06-08 19:14:38 -04:00
|
|
|
# The list of hidden actions to an empty Array. Defaults to an
|
|
|
|
# empty Array. This can be modified by other modules or subclasses
|
|
|
|
# to specify particular actions as hidden.
|
|
|
|
#
|
|
|
|
# ==== Returns
|
|
|
|
# Array[String]:: An array of method names that should not be
|
|
|
|
# considered actions.
|
2009-04-30 18:13:40 -04:00
|
|
|
def hidden_actions
|
|
|
|
[]
|
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-06-08 19:14:38 -04:00
|
|
|
# A list of method names that should be considered actions. This
|
|
|
|
# includes all public instance methods on a controller, less
|
|
|
|
# any internal methods (see #internal_methods), adding back in
|
|
|
|
# any methods that are internal, but still exist on the class
|
|
|
|
# itself. Finally, #hidden_actions are removed.
|
|
|
|
#
|
|
|
|
# ==== Returns
|
|
|
|
# Array[String]:: A list of all methods that should be considered
|
|
|
|
# actions.
|
2009-04-30 18:13:40 -04:00
|
|
|
def action_methods
|
2010-01-17 23:06:28 -05:00
|
|
|
@action_methods ||= begin
|
2009-04-30 18:13:40 -04:00
|
|
|
# All public instance methods of this class, including ancestors
|
2010-01-17 23:06:28 -05:00
|
|
|
methods = public_instance_methods(true).map { |m| m.to_s }.to_set -
|
|
|
|
# Except for public instance methods of Base and its ancestors
|
|
|
|
internal_methods.map { |m| m.to_s } +
|
|
|
|
# Be sure to include shadowed public instance methods of this class
|
|
|
|
public_instance_methods(false).map { |m| m.to_s } -
|
|
|
|
# And always exclude explicitly hidden actions
|
|
|
|
hidden_actions
|
|
|
|
|
|
|
|
# Clear out AS callback method pollution
|
|
|
|
methods.reject { |method| method =~ /_one_time_conditions/ }
|
|
|
|
end
|
2009-04-30 18:13:40 -04:00
|
|
|
end
|
2009-12-30 19:33:54 -05:00
|
|
|
|
|
|
|
# Returns the full controller name, underscored, without the ending Controller.
|
|
|
|
# For instance, MyApp::MyPostsController would return "my_app/my_posts" for
|
|
|
|
# controller_name.
|
|
|
|
#
|
|
|
|
# ==== Returns
|
|
|
|
# String
|
|
|
|
def controller_path
|
2010-02-26 05:51:21 -05:00
|
|
|
@controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
|
2009-12-30 19:33:54 -05:00
|
|
|
end
|
2009-02-24 20:25:21 -05:00
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-04-30 18:13:40 -04:00
|
|
|
abstract!
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2010-03-03 22:45:08 -05:00
|
|
|
def config
|
2010-03-04 00:32:05 -05:00
|
|
|
@config ||= ActiveSupport::InheritableOptions.new(self.class.config)
|
2010-03-03 22:45:08 -05:00
|
|
|
end
|
|
|
|
|
2009-06-08 19:14:38 -04:00
|
|
|
# Calls the action going through the entire action dispatch stack.
|
2009-12-12 19:48:34 -05:00
|
|
|
#
|
2009-06-08 19:14:38 -04:00
|
|
|
# The actual method that is called is determined by calling
|
|
|
|
# #method_for_action. If no method can handle the action, then an
|
|
|
|
# ActionNotFound error is raised.
|
|
|
|
#
|
|
|
|
# ==== Returns
|
|
|
|
# self
|
2009-12-22 14:17:27 -05:00
|
|
|
def process(action, *args)
|
2009-05-23 03:39:32 -04:00
|
|
|
@_action_name = action_name = action.to_s
|
2009-05-14 20:25:10 -04:00
|
|
|
|
2009-05-15 18:57:12 -04:00
|
|
|
unless action_name = method_for_action(action_name)
|
2009-05-23 03:39:32 -04:00
|
|
|
raise ActionNotFound, "The action '#{action}' could not be found"
|
2009-03-17 21:04:22 -04:00
|
|
|
end
|
2009-05-15 18:57:12 -04:00
|
|
|
|
2009-12-14 17:07:46 -05:00
|
|
|
@_response_body = nil
|
|
|
|
|
2009-12-22 14:17:27 -05:00
|
|
|
process_action(action_name, *args)
|
2009-02-24 20:25:21 -05:00
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2009-12-30 19:33:54 -05:00
|
|
|
# Delegates to the class' #controller_path
|
|
|
|
def controller_path
|
|
|
|
self.class.controller_path
|
|
|
|
end
|
|
|
|
|
2010-01-17 22:51:07 -05:00
|
|
|
def action_methods
|
|
|
|
self.class.action_methods
|
2009-05-14 20:25:10 -04:00
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
|
2010-01-17 22:51:07 -05:00
|
|
|
private
|
|
|
|
# Returns true if the name can be considered an action. This can
|
|
|
|
# be overridden in subclasses to modify the semantics of what
|
|
|
|
# can be considered an action.
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# name<String>:: The name of an action to be tested
|
|
|
|
#
|
|
|
|
# ==== Returns
|
|
|
|
# TrueClass, FalseClass
|
|
|
|
def action_method?(name)
|
|
|
|
self.class.action_methods.include?(name)
|
|
|
|
end
|
2009-05-15 18:57:12 -04:00
|
|
|
|
2010-01-17 22:51:07 -05:00
|
|
|
# Call the action. Override this in a subclass to modify the
|
|
|
|
# behavior around processing an action. This, and not #process,
|
|
|
|
# is the intended way to override action dispatching.
|
|
|
|
def process_action(method_name, *args)
|
|
|
|
send_action(method_name, *args)
|
|
|
|
end
|
2009-05-15 18:57:12 -04:00
|
|
|
|
2010-01-17 22:51:07 -05:00
|
|
|
# Actually call the method associated with the action. Override
|
|
|
|
# this method if you wish to change how action methods are called,
|
|
|
|
# not to add additional behavior around it. For example, you would
|
|
|
|
# override #send_action if you want to inject arguments into the
|
|
|
|
# method.
|
|
|
|
alias send_action send
|
|
|
|
|
|
|
|
# If the action name was not found, but a method called "action_missing"
|
|
|
|
# was found, #method_for_action will return "_handle_action_missing".
|
|
|
|
# This method calls #action_missing with the current action name.
|
|
|
|
def _handle_action_missing
|
|
|
|
action_missing(@_action_name)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Takes an action name and returns the name of the method that will
|
|
|
|
# handle the action. In normal cases, this method returns the same
|
|
|
|
# name as it receives. By default, if #method_for_action receives
|
|
|
|
# a name that is not an action, it will look for an #action_missing
|
|
|
|
# method and return "_handle_action_missing" if one is found.
|
|
|
|
#
|
|
|
|
# Subclasses may override this method to add additional conditions
|
|
|
|
# that should be considered an action. For instance, an HTTP controller
|
|
|
|
# with a template matching the action name is considered to exist.
|
|
|
|
#
|
|
|
|
# If you override this method to handle additional cases, you may
|
|
|
|
# also provide a method (like _handle_method_missing) to handle
|
|
|
|
# the case.
|
|
|
|
#
|
|
|
|
# If none of these conditions are true, and method_for_action
|
|
|
|
# returns nil, an ActionNotFound exception will be raised.
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# action_name<String>:: An action name to find a method name for
|
|
|
|
#
|
|
|
|
# ==== Returns
|
|
|
|
# String:: The name of the method that handles the action
|
|
|
|
# nil:: No method name could be found. Raise ActionNotFound.
|
|
|
|
def method_for_action(action_name)
|
|
|
|
if action_method?(action_name) then action_name
|
|
|
|
elsif respond_to?(:action_missing, true) then "_handle_action_missing"
|
|
|
|
end
|
2009-05-15 18:57:12 -04:00
|
|
|
end
|
2009-02-24 20:25:21 -05:00
|
|
|
end
|
2009-05-28 10:49:02 -04:00
|
|
|
end
|