Parent

Included Modules

Class Index [+]

Quicksearch

AbstractController::Base

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.

Attributes

abstract[R]

Public Class Methods

abstract!() click to toggle source

Define a controller as abstract. See internal_methods for more details.

    # File lib/abstract_controller/base.rb, line 27
27:       def abstract!
28:         @abstract = true
29:       end
action_methods() click to toggle source

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.

Returns

  • array - A list of all methods that should be considered actions.

    # File lib/abstract_controller/base.rb, line 62
62:       def action_methods
63:         @action_methods ||= begin
64:           # All public instance methods of this class, including ancestors
65:           methods = public_instance_methods(true).map { |m| m.to_s }.to_set -
66:             # Except for public instance methods of Base and its ancestors
67:             internal_methods.map { |m| m.to_s } +
68:             # Be sure to include shadowed public instance methods of this class
69:             public_instance_methods(false).map { |m| m.to_s } -
70:             # And always exclude explicitly hidden actions
71:             hidden_actions
72: 
73:           # Clear out AS callback method pollution
74:           methods.reject { |method| method =~ /_one_time_conditions/ }
75:         end
76:       end
clear_action_methods!() click to toggle source

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 81
81:       def clear_action_methods!
82:         @action_methods = nil
83:       end
controller_path() click to toggle source

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

    # File lib/abstract_controller/base.rb, line 91
91:       def controller_path
92:         @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
93:       end
hidden_actions() click to toggle source

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 - An array of method names that should not be considered actions.

    # File lib/abstract_controller/base.rb, line 50
50:       def hidden_actions
51:         []
52:       end
internal_methods() click to toggle source

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 (ActionController::Metal and ActionController::Base are defined as abstract)

    # File lib/abstract_controller/base.rb, line 38
38:       def internal_methods
39:         controller = self
40:         controller = controller.superclass until controller.abstract?
41:         controller.public_instance_methods(true)
42:       end
method_added(name) click to toggle source
    # File lib/abstract_controller/base.rb, line 95
95:       def method_added(name)
96:         super
97:         clear_action_methods!
98:       end

Public Instance Methods

action_methods() click to toggle source
     # File lib/abstract_controller/base.rb, line 128
128:     def action_methods
129:       self.class.action_methods
130:     end
controller_path() click to toggle source

Delegates to the class’ #

     # File lib/abstract_controller/base.rb, line 124
124:     def controller_path
125:       self.class.controller_path
126:     end
process(action, *args) click to toggle source

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.

Returns

  • self

     # File lib/abstract_controller/base.rb, line 111
111:     def process(action, *args)
112:       @_action_name = action_name = action.to_s
113: 
114:       unless action_name = method_for_action(action_name)
115:         raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
116:       end
117: 
118:       @_response_body = nil
119: 
120:       process_action(action_name, *args)
121:     end

Private Instance Methods

_handle_action_missing() click to toggle source

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 164
164:       def _handle_action_missing
165:         action_missing(@_action_name)
166:       end
action_method?(name) click to toggle source

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 - The name of an action to be tested

Returns

  • TrueClass, FalseClass

     # File lib/abstract_controller/base.rb, line 143
143:       def action_method?(name)
144:         self.class.action_methods.include?(name)
145:       end
method_for_action(action_name) click to toggle source

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.

Parameters

  • action_name - 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.

     # File lib/abstract_controller/base.rb, line 191
191:       def method_for_action(action_name)
192:         if action_method?(action_name) then action_name
193:         elsif respond_to?(:action_missing, true) then "_handle_action_missing"
194:         end
195:       end
process_action(method_name, *args) click to toggle source

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.

     # File lib/abstract_controller/base.rb, line 150
150:       def process_action(method_name, *args)
151:         send_action(method_name, *args)
152:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.