Class: AbstractController::Base

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

Overview

# 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.

Direct Known Subclasses

ActionController::Metal

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Class Attribute Details

.abstract ⇒ Object (readonly) Also known as: abstract?

Returns the value of attribute abstract.



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

def abstract
  @abstract
end

Class Method Details

.abstract! ⇒ Object

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



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

def abstract!
  @abstract = true
end

.action_methods ⇒ Object

A ‘Set` 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.



93
94
95
96
97
98
99
100
101
 
# File 'lib/abstract_controller/base.rb', line 93

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
    methods.map!(&:name)
    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.



106
107
108
 
# File 'lib/abstract_controller/base.rb', line 106

def clear_action_methods!
  @action_methods = nil
end

.configure {|config| ... } ⇒ Object

:nodoc:

Yields:



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

def configure # :nodoc:
  yield config
end

.controller_path ⇒ Object

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

class MyApp::MyPostsController < AbstractController::Base

end

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



118
119
120
 
# File 'lib/abstract_controller/base.rb', line 118

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

.eager_load! ⇒ Object

:nodoc:



132
133
134
135
 
# File 'lib/abstract_controller/base.rb', line 132

def eager_load! # :nodoc:
  action_methods
  nil
end

.inherited(klass) ⇒ Object

:nodoc:



61
62
63
64
65
66
67
68
69
 
# File 'lib/abstract_controller/base.rb', line 61

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
  klass.config = ActiveSupport::InheritableOptions.new(config)
  super
end

.internal_methods ⇒ Object

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)



77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/abstract_controller/base.rb', line 77

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

Refresh the cached action_methods when a new action_method is added.



127
128
129
130
 
# File 'lib/abstract_controller/base.rb', line 127

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) 


191
192
193
 
# File 'lib/abstract_controller/base.rb', line 191

def self.supports_path?
  true
end

Instance Method Details

#action_methods ⇒ Object

Delegates to the class’s ::action_methods.



163
164
165
 
# File 'lib/abstract_controller/base.rb', line 163

def action_methods
  self.class.action_methods
end

#action_name ⇒ Object

Returns the name of the action this controller is processing.



43
 
# File 'lib/abstract_controller/base.rb', line 43

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) 


178
179
180
 
# File 'lib/abstract_controller/base.rb', line 178

def available_action?(action_name)
  _find_action_name(action_name)
end

#config ⇒ Object

:nodoc:



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

def config # :nodoc:
  @_config ||= self.class.config.inheritable_copy
end

#controller_path ⇒ Object

Delegates to the class’s ::controller_path.



158
159
160
 
# File 'lib/abstract_controller/base.rb', line 158

def controller_path
  self.class.controller_path
end

#formats ⇒ Object

Returns the formats that can be processed by the controller.



47
 
# File 'lib/abstract_controller/base.rb', line 47

attr_internal :formats

#inspect ⇒ Object

:nodoc:



199
200
201
 
# File 'lib/abstract_controller/base.rb', line 199

def inspect # :nodoc:
  "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
end

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


184
185
186
 
# File 'lib/abstract_controller/base.rb', line 184

def performed?
  response_body
end

#process(action) ⇒ 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.



145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/abstract_controller/base.rb', line 145

def process(action, ...)
  @_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, ...)
end

#response_body ⇒ Object

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



39
 
# File 'lib/abstract_controller/base.rb', line 39

attr_internal :response_body