Class: AbstractController::Base

Inherits:
Object
  • Object
show all
Extended by:
ActiveSupport::DescendantsTracker
Includes:
ActiveSupport::Configurable
Defined in:
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

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.



21
22
23
 
# File 'lib/abstract_controller/base.rb', line 21

def abstract
  @abstract
end

Class Method Details

.abstract! ⇒ Object

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



26
27
28
 
# File 'lib/abstract_controller/base.rb', line 26

def abstract!
  @abstract = true
end

.action_methods ⇒ Object

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.



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/abstract_controller/base.rb', line 61

def action_methods
  @action_methods ||= begin
    # All public instance methods of this class, including ancestors
    methods = public_instance_methods(true).map { |m| m.to_s }.to_set -
      # Except for public instance methods of Base and its ancestors
      internal_methods.map { |m| m.to_s } +
      # Be sure to include shadowed public instance methods of this class
      public_instance_methods(false).map { |m| m.to_s } -
      # And always exclude explicitly hidden actions
      hidden_actions

    # Clear out AS callback method pollution
    methods.reject { |method| method =~ /_one_time_conditions/ }
  end
end

.clear_action_methods! ⇒ Object

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



80
81
82
 
# File 'lib/abstract_controller/base.rb', line 80

def clear_action_methods!
  @action_methods = nil
end

.controller_path ⇒ Object

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



90
91
92
 
# File 'lib/abstract_controller/base.rb', line 90

def controller_path
  @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
end

.hidden_actions ⇒ Object

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.



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

def hidden_actions
  []
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 we are removing those methods on classes declared as abstract (ActionController::Metal and ActionController::Base are defined as abstract)



37
38
39
40
41
 
# File 'lib/abstract_controller/base.rb', line 37

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

.method_added(name) ⇒ Object 



94
95
96
97
 
# File 'lib/abstract_controller/base.rb', line 94

def method_added(name)
  super
  clear_action_methods!
end

Instance Method Details

#action_methods ⇒ Object 



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

def action_methods
  self.class.action_methods
end

#controller_path ⇒ Object

Delegates to the class’ #controller_path



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

def controller_path
  self.class.controller_path
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 ActionNotFound error is raised.

Returns

  • self



110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/abstract_controller/base.rb', line 110

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