Object
AbstractController::Base is a low-level API. Nobody should be using it directly, and subclasses (like ActionController::Base) are expected to provide their own render method, since rendering means different things depending on the context.
Define a controller as abstract. See internal_methods for more details.
# File lib/abstract_controller/base.rb, line 29 29: def abstract! 30: @abstract = true 31: end
A list of method names that should be considered actions. This includes all public instance methods on a controller, less any internal methods (see #), adding back in any methods that are internal, but still exist on the class itself. Finally, # are removed.
array - A list of all methods that should be considered actions.
# File lib/abstract_controller/base.rb, line 63 63: def action_methods 64: @action_methods ||= begin 65: # All public instance methods of this class, including ancestors 66: methods = (public_instance_methods(true) - 67: # Except for public instance methods of Base and its ancestors 68: internal_methods + 69: # Be sure to include shadowed public instance methods of this class 70: public_instance_methods(false)).uniq.map { |x| x.to_s } - 71: # And always exclude explicitly hidden actions 72: hidden_actions.to_a 73: 74: # Clear out AS callback method pollution 75: methods.reject { |method| method =~ /_one_time_conditions/ } 76: end 77: end
action_methods are cached and there is sometimes need to refresh them. clear_action_methods! allows you to do that, so next time you run action_methods, they will be recalculated
# File lib/abstract_controller/base.rb, line 82 82: def clear_action_methods! 83: @action_methods = nil 84: end
Returns the full controller name, underscored, without the ending Controller. For instance, MyApp::MyPostsController would return “my_app/my_posts“ for controller_name.
string
# File lib/abstract_controller/base.rb, line 92 92: def controller_path 93: @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous? 94: end
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 methods declared on abstract classes are being removed. (ActionController::Metal and ActionController::Base are defined as abstract)
# File lib/abstract_controller/base.rb, line 39 39: def internal_methods 40: controller = self 41: controller = controller.superclass until controller.abstract? 42: controller.public_instance_methods(true) 43: end
# File lib/abstract_controller/base.rb, line 129 129: def action_methods 130: self.class.action_methods 131: end
Returns true if a method for the action is available and can be dispatched, false otherwise.
Notice that action_methods.include?("foo") may return false and available_action?("foo") returns true because available action consider actions that are also available through other means, for example, implicit render ones.
# File lib/abstract_controller/base.rb, line 140 140: def available_action?(action_name) 141: method_for_action(action_name).present? 142: end
Delegates to the class’ #
# File lib/abstract_controller/base.rb, line 125 125: def controller_path 126: self.class.controller_path 127: end
Calls the action going through the entire action dispatch stack.
The actual method that is called is determined by calling #. If no method can handle the action, then an ActionNotFound error is raised.
self
# File lib/abstract_controller/base.rb, line 112 112: def process(action, *args) 113: @_action_name = action_name = action.to_s 114: 115: unless action_name = method_for_action(action_name) 116: raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}" 117: end 118: 119: @_response_body = nil 120: 121: process_action(action_name, *args) 122: end
If the action name was not found, but a method called “action_missing“ was found, # will return “_handle_action_missing“. This method calls # with the current action name.
# File lib/abstract_controller/base.rb, line 180 180: def _handle_action_missing(*args) 181: action_missing(@_action_name, *args) 182: end
Returns true if the name can be considered an action because it has a method defined in the controller.
name - The name of an action to be tested
TrueClass, FalseClass
:api: private
# File lib/abstract_controller/base.rb, line 156 156: def action_method?(name) 157: self.class.action_methods.include?(name) 158: 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 # receives a name that is not an action, it will look for an # 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.
action_name - An action name to find a method name for
string - The name of the method that handles the action
nil - No method name could be found. Raise ActionNotFound.
# File lib/abstract_controller/base.rb, line 207 207: def method_for_action(action_name) 208: if action_method?(action_name) then action_name 209: elsif respond_to?(:action_missing, true) then "_handle_action_missing" 210: end 211: end
Call the action. Override this in a subclass to modify the behavior around processing an action. This, and not #, is the intended way to override action dispatching.
Notice that the first argument is the method to be dispatched which is not necessarily the same as the action name.
# File lib/abstract_controller/base.rb, line 166 166: def process_action(method_name, *args) 167: send_action(method_name, *args) 168: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.