actionpack 3.0.20 → 3.1.0.beta1

data/lib/abstract_controller/callbacks.rb

@@ -14,7 +14,7 @@ module AbstractController
     # Override AbstractController::Base's process_action to run the
     # process_action callbacks around the normal behavior.
     def process_action(method_name, *args)
-      run_callbacks(:process_action, action_name) do
+      run_callbacks(:process_action, method_name) do
         super
       end
     end
@@ -29,7 +29,7 @@ module AbstractController
       #
       # ==== Options
       # * <tt>only</tt>   - The callback should be run only for this action
-      # * <tt>except<tt>  - The callback should be run for all actions except this action
+      # * <tt>except</tt>  - The callback should be run for all actions except this action
       def _normalize_callback_options(options)
         if only = options[:only]
           only = Array(only).map {|o| "action_name == '#{o}'"}.join(" || ")
@@ -81,29 +81,29 @@ module AbstractController
         class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
           # Append a before, after or around filter. See _insert_callbacks
           # for details on the allowed parameters.
-          def #{filter}_filter(*names, &blk)                                                    # def before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options}
-              options[:if]=(Array.wrap(options[:if]) << "!halted") if #{filter == :after}
-              set_callback(:process_action, :#{filter}, name, options)                          #     set_callback(:process_action, :before_filter, name, options)
-            end                                                                                 #   end
-          end                                                                                   # end
+          def #{filter}_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|
+              options[:if] = (Array.wrap(options[:if]) << "!halted") if #{filter == :after}
+              set_callback(:process_action, :#{filter}, name, options)
+            end
+          end
 
           # Prepend a before, after or around filter. See _insert_callbacks
           # for details on the allowed parameters.
-          def prepend_#{filter}_filter(*names, &blk)                                            # def prepend_before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options|
-              options[:if]=(Array.wrap(options[:if]) << "!halted") if #{filter == :after}
-              set_callback(:process_action, :#{filter}, name, options.merge(:prepend => true))  #     set_callback(:process_action, :before, name, options.merge(:prepend => true))
-            end                                                                                 #   end
-          end                                                                                   # end
+          def prepend_#{filter}_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|
+              options[:if] = (Array.wrap(options[:if]) << "!halted") if #{filter == :after}
+              set_callback(:process_action, :#{filter}, name, options.merge(:prepend => true))
+            end
+          end
 
           # Skip a before, after or around filter. See _insert_callbacks
           # for details on the allowed parameters.
-          def skip_#{filter}_filter(*names, &blk)                                               # def skip_before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options|
-              skip_callback(:process_action, :#{filter}, name, options)                         #     skip_callback(:process_action, :before, name, options)
-            end                                                                                 #   end
-          end                                                                                   # end
+          def skip_#{filter}_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|
+              skip_callback(:process_action, :#{filter}, name, options)
+            end
+          end
 
           # *_filter is the same as append_*_filter
           alias_method :append_#{filter}_filter, :#{filter}_filter

data/lib/abstract_controller/helpers.rb

@@ -4,8 +4,6 @@ module AbstractController
   module Helpers
     extend ActiveSupport::Concern
 
-    include Rendering
-
     included do
       class_attribute :_helpers
       self._helpers = Module.new
@@ -112,17 +110,6 @@ module AbstractController
         default_helper_module! unless anonymous?
       end
 
-      private
-      # Makes all the (instance) methods in the helper module available to templates
-      # rendered through this controller.
-      #
-      # ==== Parameters
-      # * <tt>module</tt> - The module to include into the current helper module
-      #   for the class
-      def add_template_helper(mod)
-        _helpers.module_eval { include mod }
-      end
-
       # Returns a list of modules, normalized from the acceptable kinds of
       # helpers with the following behavior:
       #
@@ -155,6 +142,17 @@ module AbstractController
         end
       end
 
+      private
+      # Makes all the (instance) methods in the helper module available to templates
+      # rendered through this controller.
+      #
+      # ==== Parameters
+      # * <tt>module</tt> - The module to include into the current helper module
+      #   for the class
+      def add_template_helper(mod)
+        _helpers.module_eval { include mod }
+      end
+
       def default_helper_module!
         module_name = name.sub(/Controller$/, '')
         module_path = module_name.underscore

data/lib/abstract_controller/layouts.rb

@@ -265,11 +265,11 @@ module AbstractController
           raise ArgumentError, "Layouts must be specified as a String, Symbol, false, or nil"
         when nil
           if name
-            _prefix = "layouts" unless _implied_layout_name =~ /\blayouts/
+            _prefixes = _implied_layout_name =~ /\blayouts/ ? [] : ["layouts"]
 
             self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def _layout
-                if template_exists?("#{_implied_layout_name}", #{_prefix.inspect})
+                if template_exists?("#{_implied_layout_name}", #{_prefixes.inspect})
                   "#{_implied_layout_name}"
                 else
                   super
@@ -334,7 +334,7 @@ module AbstractController
     # ==== Parameters
     # * <tt>details</tt> - A list of details to restrict the search by. This
     #   might include details like the format or locale of the template.
-    # * <tt>require_logout</tt> - If this is true, raise an ArgumentError
+    # * <tt>require_layout</tt> - If this is true, raise an ArgumentError
     #   with details about the fact that the exception could not be
     #   found (defaults to false)
     #
@@ -344,8 +344,7 @@ module AbstractController
       begin
         layout_name = _layout if action_has_layout?
       rescue NameError => e
-        raise NoMethodError,
-          "You specified #{@_layout.inspect} as the layout, but no such method was found"
+        raise e, "Could not render layout: #{e.message}"
       end
 
       if require_layout && action_has_layout? && !layout_name

data/lib/abstract_controller/railties/routes_helpers.rb

@@ -0,0 +1,18 @@
+module AbstractController
+  module Railties
+    module RoutesHelpers
+      def self.with(routes)
+        Module.new do
+          define_method(:inherited) do |klass|
+            super(klass)
+            if namespace = klass.parents.detect {|m| m.respond_to?(:_railtie) }
+              klass.send(:include, namespace._railtie.routes.url_helpers)
+            else
+              klass.send(:include, routes.url_helpers)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abstract_controller/rendering.rb

@@ -1,5 +1,6 @@
 require "abstract_controller/base"
 require "action_view"
+require "active_support/core_ext/object/instance_variables"
 
 module AbstractController
   class DoubleRenderError < Error
@@ -12,7 +13,6 @@ module AbstractController
 
   # This is a class to fix I18n global state. Whenever you provide I18n.locale during a request,
   # it will trigger the lookup_context and consequently expire the cache.
-  # TODO Add some deprecation warnings to remove I18n.locale from controllers
   class I18nProxy < ::I18n::Config #:nodoc:
     attr_reader :original_config, :lookup_context
 
@@ -46,19 +46,9 @@ module AbstractController
     module ClassMethods
       def view_context_class
         @view_context_class ||= begin
-          controller = self
-          Class.new(ActionView::Base) do
-            if controller.respond_to?(:_routes)
-              include controller._routes.url_helpers
-            end
-
-            if controller.respond_to?(:_helpers)
-              include controller._helpers
-
-              # TODO: Fix RJS to not require this
-              self.helpers = controller._helpers
-            end
-          end
+          routes  = _routes  if respond_to?(:_routes)
+          helpers = _helpers if respond_to?(:_helpers)
+          ActionView::Base.prepare(routes, helpers)
         end
       end
     end
@@ -84,21 +74,26 @@ module AbstractController
     #
     # Override this method in a module to change the default behavior.
     def view_context
-      view_context_class.new(lookup_context, view_assigns, self)
+      view_context_class.new(view_renderer, view_assigns, self)
+    end
+
+    # Returns an object that is able to render templates.
+    def view_renderer
+      @view_renderer ||= ActionView::Renderer.new(lookup_context)
     end
 
     # Normalize arguments, options and then delegates render_to_body and
     # sticks the result in self.response_body.
     def render(*args, &block)
-      self.response_body = render_to_string(*args, &block)
+      options = _normalize_render(*args, &block)
+      self.response_body = render_to_body(options)
     end
 
     # Raw rendering of a template to a string. Just convert the results of
-    # render_to_body into a String.
+    # render_response into a String.
     # :api: plugin
     def render_to_string(*args, &block)
-      options = _normalize_args(*args, &block)
-      _normalize_options(options)
+      options = _normalize_render(*args, &block)
       render_to_body(options)
     end
 
@@ -112,15 +107,10 @@ module AbstractController
     # Find and renders a template based on the options given.
     # :api: private
     def _render_template(options) #:nodoc:
-      view_context.render(options)
+      view_renderer.render(view_context, options)
     end
 
-    # The prefix used in render "foo" shortcuts.
-    def _prefix
-      controller_path
-    end
-
-  private
+    private
 
     # This method should return a hash with assigns.
     # You can overwrite this configuration per controller.
@@ -129,41 +119,54 @@ module AbstractController
       hash = {}
       variables  = instance_variable_names
       variables -= protected_instance_variables if respond_to?(:protected_instance_variables)
-      variables.each { |name| hash[name.to_s[1..-1]] = instance_variable_get(name) }
+      variables.each { |name| hash[name.to_s[1, name.length]] = instance_variable_get(name) }
       hash
     end
 
-    # Normalize options by converting render "foo" to render :action => "foo" and
+    # Normalize args and options.
+    # :api: private
+    def _normalize_render(*args, &block)
+      options = _normalize_args(*args, &block)
+      _normalize_options(options)
+      options
+    end
+
+    # Normalize args by converting render "foo" to render :action => "foo" and
     # render "foo/bar" to render :file => "foo/bar".
+    # :api: plugin
     def _normalize_args(action=nil, options={})
       case action
       when NilClass
       when Hash
-        options, action = action, nil
+        options = action
       when String, Symbol
         action = action.to_s
         key = action.include?(?/) ? :file : :action
         options[key] = action
       else
-        options.merge!(:partial => action)
+        options[:partial] = action
       end
 
       options
     end
 
+    # Normalize options.
+    # :api: plugin
     def _normalize_options(options)
       if options[:partial] == true
         options[:partial] = action_name
       end
 
       if (options.keys & [:partial, :file, :template]).empty?
-        options[:prefix] ||= _prefix
+        options[:prefixes] ||= _prefixes
       end
 
       options[:template] ||= (options[:action] || action_name).to_s
       options
     end
 
+    # Process extra options.
+    # :api: plugin
     def _process_options(options)
     end
   end

data/lib/abstract_controller/url_for.rb

@@ -0,0 +1,27 @@
+module AbstractController
+  module UrlFor
+    extend ActiveSupport::Concern
+    include ActionDispatch::Routing::UrlFor
+
+    def _routes
+      raise "In order to use #url_for, you must include routing helpers explicitly. " \
+            "For instance, `include Rails.application.routes.url_helpers"
+    end
+
+    module ClassMethods
+      def _routes
+        nil
+      end
+
+      def action_methods
+        @action_methods ||= begin
+          if _routes
+            super - _routes.named_routes.helper_names
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abstract_controller/view_paths.rb

@@ -11,11 +11,36 @@ module AbstractController
     delegate :find_template, :template_exists?, :view_paths, :formats, :formats=,
              :locale, :locale=, :to => :lookup_context
 
+    module ClassMethods
+      def parent_prefixes
+        @parent_prefixes ||= begin
+          parent_controller = superclass
+          prefixes = []
+
+          until parent_controller.abstract?
+            prefixes << parent_controller.controller_path
+            parent_controller = parent_controller.superclass
+          end
+
+          prefixes
+        end
+      end
+    end
+
+    # The prefixes used in render "foo" shortcuts.
+    def _prefixes
+      @_prefixes ||= begin
+        parent_prefixes = self.class.parent_prefixes
+        parent_prefixes.dup.unshift(controller_path)
+      end
+    end
+
     # LookupContext is the object responsible to hold all information required to lookup
     # templates, i.e. view paths and details. Check ActionView::LookupContext for more
     # information.
     def lookup_context
-      @lookup_context ||= ActionView::LookupContext.new(self.class._view_paths, details_for_lookup)
+      @lookup_context ||=
+        ActionView::LookupContext.new(self.class._view_paths, details_for_lookup, _prefixes)
     end
 
     def details_for_lookup
@@ -36,7 +61,7 @@ module AbstractController
       # ==== Parameters
       # * <tt>path</tt> - If a String is provided, it gets converted into
       #   the default view path. You may also provide a custom view path
-      #   (see ActionView::ViewPathSet for more information)
+      #   (see ActionView::PathSet for more information)
       def append_view_path(path)
         self.view_paths = view_paths.dup + Array(path)
       end
@@ -46,7 +71,7 @@ module AbstractController
       # ==== Parameters
       # * <tt>path</tt> - If a String is provided, it gets converted into
       #   the default view path. You may also provide a custom view path
-      #   (see ActionView::ViewPathSet for more information)
+      #   (see ActionView::PathSet for more information)
       def prepend_view_path(path)
         self.view_paths = Array(path) + view_paths.dup
       end
@@ -59,12 +84,12 @@ module AbstractController
       # Set the view paths.
       #
       # ==== Parameters
-      # * <tt>paths</tt> - If a ViewPathSet is provided, use that;
-      #   otherwise, process the parameter into a ViewPathSet.
+      # * <tt>paths</tt> - If a PathSet is provided, use that;
+      #   otherwise, process the parameter into a PathSet.
       def view_paths=(paths)
         self._view_paths = ActionView::Base.process_view_paths(paths)
         self._view_paths.freeze
       end
     end
   end
-end
+end

data/lib/action_controller.rb

@@ -13,7 +13,9 @@ module ActionController
     autoload :Compatibility
     autoload :ConditionalGet
     autoload :Cookies
+    autoload :DataStreaming
     autoload :Flash
+    autoload :ForceSSL
     autoload :Head
     autoload :Helpers
     autoload :HideActions
@@ -21,6 +23,7 @@ module ActionController
     autoload :ImplicitRender
     autoload :Instrumentation
     autoload :MimeResponds
+    autoload :ParamsWrapper
     autoload :RackDelegation
     autoload :Redirecting
     autoload :Renderers
@@ -34,12 +37,10 @@ module ActionController
     autoload :UrlFor
   end
 
-  autoload :Dispatcher,      'action_controller/deprecated/dispatcher'
-  autoload :UrlWriter,       'action_controller/deprecated/url_writer'
-  autoload :UrlRewriter,     'action_controller/deprecated/url_writer'
   autoload :Integration,     'action_controller/deprecated/integration_test'
   autoload :IntegrationTest, 'action_controller/deprecated/integration_test'
   autoload :PerformanceTest, 'action_controller/deprecated/performance_test'
+  autoload :UrlWriter,       'action_controller/deprecated'
   autoload :Routing,         'action_controller/deprecated'
   autoload :TestCase,        'action_controller/test_case'
 
@@ -74,4 +75,5 @@ require 'active_support/core_ext/load_error'
 require 'active_support/core_ext/module/attr_internal'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/name_error'
+require 'active_support/core_ext/uri'
 require 'active_support/inflector'

data/lib/action_controller/base.rb

@@ -24,7 +24,7 @@ module ActionController
   #
   # Actions, by default, render a template in the <tt>app/views</tt> directory corresponding to the name of the controller and action
   # after executing code in the action. For example, the +index+ action of the PostsController would render the
-  # template <tt>app/views/posts/index.erb</tt> by default after populating the <tt>@posts</tt> instance variable.
+  # template <tt>app/views/posts/index.html.erb</tt> by default after populating the <tt>@posts</tt> instance variable.
   #
   # Unlike index, the create action will not render a template. After performing its main purpose (creating a
   # new post), it initiates a redirect instead. This redirect works by returning an external
@@ -93,9 +93,9 @@ module ActionController
   # * ActiveRecord::SessionStore - Sessions are stored in your database, which works better than PStore with multiple app servers and,
   #   unlike CookieStore, hides your session contents from the user. To use ActiveRecord::SessionStore, set
   #
-  #     config.action_controller.session_store = :active_record_store
+  #     MyApplication::Application.config.session_store :active_record_store
   #
-  #   in your <tt>config/environment.rb</tt> and run <tt>rake db:sessions:create</tt>.
+  #   in your <tt>config/initializers/session_store.rb</tt> and run <tt>script/rails g session_migration</tt>.
   #
   # == Responses
   #
@@ -105,7 +105,7 @@ module ActionController
   # == Renders
   #
   # Action Controller sends content to the user by using one of five rendering methods. The most versatile and common is the rendering
-  # of a template. Included in the Action Pack is the Action View, which enables rendering of ERb templates. It's automatically configured.
+  # of a template. Included in the Action Pack is the Action View, which enables rendering of ERB templates. It's automatically configured.
   # The controller passes objects to the view by assigning instance variables:
   #
   #   def show
@@ -128,7 +128,7 @@ module ActionController
   #     end
   #   end
   #
-  # Read more about writing ERb and Builder templates in ActionView::Base.
+  # Read more about writing ERB and Builder templates in ActionView::Base.
   #
   # == Redirects
   #
@@ -198,7 +198,9 @@ module ActionController
       Cookies,
       Flash,
       RequestForgeryProtection,
+      ForceSSL,
       Streaming,
+      DataStreaming,
       RecordIdentifier,
       HttpAuthentication::Basic::ControllerMethods,
       HttpAuthentication::Digest::ControllerMethods,
@@ -208,12 +210,16 @@ module ActionController
       # also include them at the bottom.
       AbstractController::Callbacks,
 
-      # The same with rescue, append it at the end to wrap as much as possible.
-      Rescue,
-
       # Add instrumentations hooks at the bottom, to ensure they instrument
       # all the methods properly.
-      Instrumentation
+      Instrumentation,
+
+      # Params wrapper should come before instrumentation so they are
+      # properly showed in logs
+      ParamsWrapper,
+
+      # The same with rescue, append it at the end to wrap as much as possible.
+      Rescue
     ]
 
     MODULES.each do |mod|
@@ -223,13 +229,6 @@ module ActionController
     # Rails 2.x compatibility
     include ActionController::Compatibility
 
-    def self.inherited(klass)
-      super
-      klass.helper :all if klass.superclass == ActionController::Base
-    end
-
-    require "action_controller/deprecated/base"
     ActiveSupport.run_load_hooks(:action_controller, self)
   end
 end
-