class `AbstractController::Base`

Abstract Controller 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.

Inherits From

module ActiveSupport::Configurable

Attributes

[R]	`abstract`
[R]	`abstract?`

Public class methods

`abstract!()`

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

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 57
def abstract!
  @abstract = true
end

`action_methods()`

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.

Returns

Set - A set of all methods that should be considered actions.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 96
def action_methods
  @action_methods ||= begin
    # All public instance methods of this class, including ancestors
    # except for public instance methods of Base and its ancestors.
    methods = public_instance_methods(true) - internal_methods
    # Be sure to include shadowed public instance methods of this class.
    methods.concat(public_instance_methods(false))
    methods.map!(&:to_s)
    methods.to_set
  end
end

`clear_action_methods!()`

action_methods are cached and there is sometimes a need to refresh them. ::clear_action_methods! allows you to do that, so next time you run action_methods, they will be recalculated.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 111
def clear_action_methods!
  @action_methods = nil
end

`controller_path()`

Returns the full controller name, underscored, without the ending Controller.

class MyApp::MyPostsController < AbstractController::Base

end

MyApp::MyPostsController.controller_path # => "my_app/my_posts"

Returns

String

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 125
def controller_path
  @controller_path ||= name.delete_suffix("Controller").underscore unless anonymous?
end

`internal_methods()`

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)

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 76
def internal_methods
  controller = self
  methods = []

  until controller.abstract?
    methods += controller.public_instance_methods(false)
    controller = controller.superclass
  end

  controller.public_instance_methods(true) - methods
end

`method_added(name)`

Refresh the cached action_methods when a new action_method is added.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 130
def method_added(name)
  super
  clear_action_methods!
end

`supports_path?()`

Returns true if the given controller is capable of rendering a path. A subclass of AbstractController::Base may return false. An Email controller for example does not support paths, only full URLs.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 199
def self.supports_path?
  true
end

Public instance methods

`action_methods()`

Delegates to the class’s ::action_methods.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 170
def action_methods
  self.class.action_methods
end

`action_name`

Returns the name of the action this controller is processing.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 42
attr_internal :action_name

`available_action?(action_name)`

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 this method considers actions that are also available through other means, for example, implicit render ones.

Parameters

action_name - The name of an action to be tested

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 184
def available_action?(action_name)
  _find_action_name(action_name)
end

`controller_path()`

Delegates to the class’s ::controller_path.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 165
def controller_path
  self.class.controller_path
end

`formats`

Returns the formats that can be processed by the controller.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 46
attr_internal :formats

`performed?()`

Tests if a response body is set. Used to determine if the process_action callback needs to be terminated in AbstractController::Callbacks.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 191
def performed?
  response_body
end

`process(action, *args)`

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 AbstractController::ActionNotFound error is raised.

Returns

self

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 151
def process(action, *args)
  @_action_name = action.to_s

  unless action_name = _find_action_name(@_action_name)
    raise ActionNotFound.new("The action '#{action}' could not be found for #{self.class.name}", self, action)
  end

  @_response_body = nil

  process_action(action_name, *args)
end

`response_body`

Returns the body of the HTTP response sent by the controller.

Source code GitHub

# File actionpack/lib/abstract_controller/base.rb, line 38
attr_internal :response_body

Definition files

actionpack/lib/abstract_controller/base.rb

class AbstractController::Base

Inherits From

Attributes

Public class methods

abstract!()

action_methods()

Returns

clear_action_methods!()

controller_path()

Returns

internal_methods()

method_added(name)

supports_path?()

Public instance methods

action_methods()

action_name

available_action?(action_name)

Parameters

controller_path()

formats

performed?()

process(action, *args)

Returns

response_body

Definition files

class `AbstractController::Base`

`abstract!()`

`action_methods()`

`clear_action_methods!()`

`controller_path()`

`internal_methods()`

`method_added(name)`

`supports_path?()`

`action_methods()`

`action_name`

`available_action?(action_name)`

`controller_path()`

`formats`

`performed?()`

`process(action, *args)`

`response_body`