Class: AbstractController::Base

Inherits:
Object
  • Object
show all
Extended by:
ActiveSupport::DescendantsTracker
Includes:
ActiveSupport::Configurable
Defined in:
actionpack/lib/abstract_controller/base.rb

Overview

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.

Direct Known Subclasses

ActionController::Metal, ActionMailer::Base

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ActiveSupport::DescendantsTracker

clear, descendants, descendants, direct_descendants, direct_descendants, inherited, store_inherited, subclasses

Methods included from ActiveSupport::Configurable

#config

Methods included from ActiveSupport::Concern

#append_features, #class_methods, extended, #included, #prepend_features, #prepended

Class Attribute Details

.abstractObject (readonly) Also known as: abstract?

Returns the value of attribute abstract


64
65
66
# File 'actionpack/lib/abstract_controller/base.rb', line 64

def abstract
  @abstract
end

Class Method Details

.abstract!Object

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


69
70
71
# File 'actionpack/lib/abstract_controller/base.rb', line 69

def abstract!
  @abstract = true
end

.action_methodsObject

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.


103
104
105
106
107
108
109
110
111
112
113
114
115
116
# File 'actionpack/lib/abstract_controller/base.rb', line 103

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))

    methods.map!(&:to_s)

    methods.to_set
  end
end

.clear_action_methods!Object

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.


121
122
123
# File 'actionpack/lib/abstract_controller/base.rb', line 121

def clear_action_methods!
  @action_methods = nil
end

.controller_pathObject

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


135
136
137
# File 'actionpack/lib/abstract_controller/base.rb', line 135

def controller_path
  @controller_path ||= name.delete_suffix("Controller").underscore unless anonymous?
end

.inherited(klass) ⇒ Object

:nodoc:


73
74
75
76
77
78
79
80
# File 'actionpack/lib/abstract_controller/base.rb', line 73

def inherited(klass) # :nodoc:
  # Define the abstract ivar on subclasses so that we don't get
  # uninitialized ivar warnings
  unless klass.instance_variable_defined?(:@abstract)
    klass.instance_variable_set(:@abstract, false)
  end
  super
end

.internal_methodsObject

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)


88
89
90
91
92
93
# File 'actionpack/lib/abstract_controller/base.rb', line 88

def internal_methods
  controller = self

  controller = controller.superclass until controller.abstract?
  controller.public_instance_methods(true)
end

.method_added(name) ⇒ Object

Refresh the cached action_methods when a new action_method is added.


140
141
142
143
# File 'actionpack/lib/abstract_controller/base.rb', line 140

def method_added(name)
  super
  clear_action_methods!
end

.supports_path?Boolean

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.

Returns:

  • (Boolean)

203
204
205
# File 'actionpack/lib/abstract_controller/base.rb', line 203

def self.supports_path?
  true
end

Instance Method Details

#action_methodsObject

Delegates to the class' ::action_methods


174
175
176
# File 'actionpack/lib/abstract_controller/base.rb', line 174

def action_methods
  self.class.action_methods
end

#action_nameObject

Returns the name of the action this controller is processing.


54
# File 'actionpack/lib/abstract_controller/base.rb', line 54

attr_internal :action_name

#available_action?(action_name) ⇒ Boolean

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

Returns:

  • (Boolean)

188
189
190
# File 'actionpack/lib/abstract_controller/base.rb', line 188

def available_action?(action_name)
  _find_action_name(action_name)
end

#controller_pathObject

Delegates to the class' ::controller_path


169
170
171
# File 'actionpack/lib/abstract_controller/base.rb', line 169

def controller_path
  self.class.controller_path
end

#formatsObject

Returns the formats that can be processed by the controller.


58
# File 'actionpack/lib/abstract_controller/base.rb', line 58

attr_internal :formats

#performed?Boolean

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

Returns:

  • (Boolean)

195
196
197
# File 'actionpack/lib/abstract_controller/base.rb', line 195

def performed?
  response_body
end

#process(action, *args) ⇒ Object

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


156
157
158
159
160
161
162
163
164
165
166
# File 'actionpack/lib/abstract_controller/base.rb', line 156

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_bodyObject

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


50
# File 'actionpack/lib/abstract_controller/base.rb', line 50

attr_internal :response_body