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.



24
25
26
 
# File 'lib/abstract_controller/base.rb', line 24

def abstract
  @abstract
end

Class Method Details

.abstract! ⇒ Object

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



29
30
31
 
# File 'lib/abstract_controller/base.rb', line 29

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.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# 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! ⇒ 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



82
83
84
 
# File 'lib/abstract_controller/base.rb', line 82

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



92
93
94
 
# File 'lib/abstract_controller/base.rb', line 92

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.



51
52
53
 
# File 'lib/abstract_controller/base.rb', line 51

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 methods declared on abstract classes are being removed. (ActionController::Metal and ActionController::Base are defined as abstract)



39
40
41
42
43
 
# 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) ⇒ Object 



96
97
98
99
 
# File 'lib/abstract_controller/base.rb', line 96

def method_added(name)
  super
  clear_action_methods!
end

Instance Method Details

#action_methods ⇒ Object 



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

def action_methods
  self.class.action_methods
end

#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 available action consider actions that are also available through other means, for example, implicit render ones.

Returns:

  • (Boolean) 


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

def available_action?(action_name)
  method_for_action(action_name).present?
end

#controller_path ⇒ Object

Delegates to the class’ #controller_path



125
126
127
 
# File 'lib/abstract_controller/base.rb', line 125

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



112
113
114
115
116
117
118
119
120
121
122
 
# 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