Move AbstractController to a top-level component

1 files changed, 0 insertions, 159 deletions

diff --git a/actionpack/lib/action_controller/abstract/base.rb b/actionpack/lib/action_controller/abstract/base.rb
deleted file mode 100644
index b93e6ce634..0000000000
--- a/actionpack/lib/action_controller/abstract/base.rb
+++ /dev/null
@@ -1,159 +0,0 @@
-module AbstractController
-
-  class Base
-    attr_internal :response_body
-    attr_internal :action_name
-
-    class << self
-      attr_reader :abstract
-      alias_method :abstract?, :abstract
-
-      # Define a controller as abstract. See internal_methods for more
-      # details.
-      def abstract!
-        @abstract = true
-      end
-
-      def inherited(klass)
-        ::AbstractController::Base.descendants << klass.to_s
-        super
-      end
-
-      # A list of all descendents of AbstractController::Base. This is
-      # useful for initializers which need to add behavior to all controllers.
-      def descendants
-        @descendants ||= []
-      end
-
-      # 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)
-      def internal_methods
-        controller = self
-        controller = controller.superclass until controller.abstract?
-        controller.public_instance_methods(true)
-      end
-
-      # 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[String]:: An array of method names that should not be
-      #                 considered actions.
-      def hidden_actions
-        []
-      end
-
-      # 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[String]:: A list of all methods that should be considered
-      #                 actions.
-      def action_methods
-        @action_methods ||=
-          # All public instance methods of this class, including ancestors
-          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
-      end
-    end
-
-    abstract!
-
-    # 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
-    def process(action)
-      @_action_name = action_name = action.to_s
-
-      unless action_name = method_for_action(action_name)
-        raise ActionNotFound, "The action '#{action}' could not be found"
-      end
-
-      process_action(action_name)
-      self
-    end
-
-  private
-    # Returns true if the name can be considered an action. This can
-    # be overridden in subclasses to modify the semantics of what
-    # can be considered an action.
-    #
-    # ==== Parameters
-    # name<String>:: The name of an action to be tested
-    #
-    # ==== Returns
-    # TrueClass, FalseClass
-    def action_method?(name)
-      self.class.action_methods.include?(name)
-    end
-
-    # Call the action. Override this in a subclass to modify the
-    # behavior around processing an action. This, and not #process,
-    # is the intended way to override action dispatching.
-    def process_action(method_name)
-      send_action(method_name)
-    end
-
-    # Actually call the method associated with the action. Override
-    # this method if you wish to change how action methods are called,
-    # not to add additional behavior around it. For example, you would
-    # override #send_action if you want to inject arguments into the
-    # method.
-    alias send_action send
-
-    # If the action name was not found, but a method called "action_missing"
-    # was found, #method_for_action will return "_handle_action_missing".
-    # This method calls #action_missing with the current action name.
-    def _handle_action_missing
-      action_missing(@_action_name)
-    end
-
-    # Takes an action name and returns the name of the method that will
-    # handle the action. In normal cases, this method returns the same
-    # name as it receives. By default, if #method_for_action receives
-    # a name that is not an action, it will look for an #action_missing
-    # method and return "_handle_action_missing" if one is found.
-    #
-    # Subclasses may override this method to add additional conditions
-    # that should be considered an action. For instance, an HTTP controller
-    # with a template matching the action name is considered to exist.
-    #
-    # If you override this method to handle additional cases, you may
-    # also provide a method (like _handle_method_missing) to handle
-    # the case.
-    #
-    # If none of these conditions are true, and method_for_action
-    # returns nil, an ActionNotFound exception will be raised.
-    #
-    # ==== Parameters
-    # action_name<String>:: An action name to find a method name for
-    #
-    # ==== Returns
-    # String:: The name of the method that handles the action
-    # nil::    No method name could be found. Raise ActionNotFound.
-    def method_for_action(action_name)
-      if action_method?(action_name) then action_name
-      elsif respond_to?(:action_missing, true) then "_handle_action_missing"
-      end
-    end
-  end
-end