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 def abstract! @abstract = true 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 internal_methods), adding back in any methods that are internal, but still exist on the class itself. Finally, hidden_actions are removed.
array - A list of all methods that should be considered actions.
# File lib/abstract_controller/base.rb, line 63 def action_methods @action_methods ||= begin # All public instance methods of this class, including ancestors methods = (public_instance_methods(true) - # Except for public instance methods of Base and its ancestors internal_methods + # Be sure to include shadowed public instance methods of this class public_instance_methods(false)).uniq.map { |x| x.to_s } - # And always exclude explicitly hidden actions hidden_actions.to_a # Clear out AS callback method pollution methods.reject { |method| method =~ /_one_time_conditions/ } end 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 def clear_action_methods! @action_methods = nil 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 def controller_path @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous? 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 def internal_methods controller = self controller = controller.superclass until controller.abstract? controller.public_instance_methods(true) end
# File lib/abstract_controller/base.rb, line 129 def action_methods self.class.action_methods 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 def available_action?(action_name) method_for_action(action_name).present? end
Delegates to the class’ controller_path
# File lib/abstract_controller/base.rb, line 125 def controller_path self.class.controller_path end
Calls the action going through the entire action dispatch stack.
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.
self
# File lib/abstract_controller/base.rb, line 112 def process(action, *args) @_action_name = action_name = action.to_s unless action_name = method_for_action(action_name) raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}" end @_response_body = nil process_action(action_name, *args) end
Generated with the Darkfish Rdoc Generator 2.