Parent

Included Modules

Class/Module 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]
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 29
def abstract!
  @abstract = true
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 internal_methods), adding back in any methods that are internal, but still exist on the class itself. Finally, hidden_actions are removed.

Returns

  • 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
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 82
def clear_action_methods!
  @action_methods = nil
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 92
def controller_path
  @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
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 51
def hidden_actions
  []
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 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
method_added(name) click to toggle source
# File lib/abstract_controller/base.rb, line 96
def method_added(name)
  super
  clear_action_methods!
end

Public Instance Methods

action_methods() click to toggle source
# File lib/abstract_controller/base.rb, line 129
def action_methods
  self.class.action_methods
end
available_action?(action_name) click to toggle source

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
controller_path() click to toggle source

Delegates to the class’ controller_path

# File lib/abstract_controller/base.rb, line 125
def controller_path
  self.class.controller_path
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 method_for_action. If no method can handle the action, then an ActionNotFound error is raised.

Returns

  • 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

[Validate]

Generated with the Darkfish Rdoc Generator 2.