actionpack 2.1.2 → 2.2.2

data/lib/action_controller/components.rb

@@ -38,6 +38,7 @@ module ActionController #:nodoc:
     def self.included(base) #:nodoc:
       base.class_eval do
         include InstanceMethods
+        include ActiveSupport::Deprecation
         extend ClassMethods
         helper HelperMethods
 
@@ -64,7 +65,7 @@ module ActionController #:nodoc:
 
     module HelperMethods
       def render_component(options)
-        @controller.send!(:render_component_as_string, options)
+        @controller.__send__(:render_component_as_string, options)
       end
     end
 
@@ -82,6 +83,7 @@ module ActionController #:nodoc:
             render_for_text(component_response(options, true).body, response.headers["Status"])
           end
         end
+        deprecate :render_component => "Please install render_component plugin from http://github.com/rails/render_component/tree/master"
 
         # Returns the component response as a string
         def render_component_as_string(options) #:doc:
@@ -95,6 +97,7 @@ module ActionController #:nodoc:
             end
           end
         end
+        deprecate :render_component_as_string => "Please install render_component plugin from http://github.com/rails/render_component/tree/master"
 
         def flash_with_components(refresh = false) #:nodoc:
           if !defined?(@_flash) || refresh

data/lib/action_controller/cookies.rb

@@ -22,6 +22,16 @@ module ActionController #:nodoc:
   #
   #   cookies.delete :user_name
   #
+  # Please note that if you specify a :domain when setting a cookie, you must also specify the domain when deleting the cookie:
+  #
+  #  cookies[:key] = {
+  #    :value => 'a yummy cookie',
+  #    :expires => 1.year.from_now,
+  #    :domain => 'domain.com'
+  #  }
+  #
+  #  cookies.delete(:key, :domain => 'domain.com')
+  #
   # The option symbols for setting cookies are:
   #
   # * <tt>:value</tt> - The cookie's value or list of values (as an array).

data/lib/action_controller/dispatcher.rb

@@ -22,11 +22,15 @@ module ActionController
         end
 
         if defined?(ActiveRecord)
-          before_dispatch { ActiveRecord::Base.verify_active_connections! }
+          after_dispatch :checkin_connections
           to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers }
         end
 
-        after_dispatch :flush_logger if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush)
+        after_dispatch :flush_logger if Base.logger && Base.logger.respond_to?(:flush)
+
+        to_prepare do
+          I18n.reload!
+        end
       end
 
       # Backward-compatible class method takes CGI-specific args. Deprecated
@@ -38,7 +42,7 @@ module ActionController
       # Add a preparation callback. Preparation callbacks are run before every
       # request in development mode, and before the first request in production
       # mode.
-      # 
+      #
       # An optional identifier may be supplied for the callback. If provided,
       # to_prepare may be called again with the same identifier to replace the
       # existing callback. Passing an identifier is a suggested practice if the
@@ -46,7 +50,7 @@ module ActionController
       def to_prepare(identifier = nil, &block)
         @prepare_dispatch_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
         callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
-        @prepare_dispatch_callbacks | callback
+        @prepare_dispatch_callbacks.replace_or_append!(callback)
       end
 
       # If the block raises, send status code as a last-ditch response.
@@ -96,19 +100,27 @@ module ActionController
     include ActiveSupport::Callbacks
     define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
 
-    def initialize(output, request = nil, response = nil)
+    def initialize(output = $stdout, request = nil, response = nil)
       @output, @request, @response = output, request, response
     end
 
+    def dispatch_unlocked
+      begin
+        run_callbacks :before_dispatch
+        handle_request
+      rescue Exception => exception
+        failsafe_rescue exception
+      ensure
+        run_callbacks :after_dispatch, :enumerator => :reverse_each
+      end
+    end
+
     def dispatch
-      @@guard.synchronize do
-        begin
-          run_callbacks :before_dispatch
-          handle_request
-        rescue Exception => exception
-          failsafe_rescue exception
-        ensure
-          run_callbacks :after_dispatch, :enumerator => :reverse_each
+      if ActionController::Base.allow_concurrency
+        dispatch_unlocked
+      else
+        @@guard.synchronize do
+          dispatch_unlocked
         end
       end
     end
@@ -123,12 +135,19 @@ module ActionController
       failsafe_rescue exception
     end
 
+    def call(env)
+      @request = RackRequest.new(env)
+      @response = RackResponse.new(@request)
+      dispatch
+    end
+
     def reload_application
       # Run prepare callbacks before every request in development mode
       run_callbacks :prepare_dispatch
 
       Routing::Routes.reload
-      ActionView::TemplateFinder.reload! unless ActionView::Base.cache_template_loading
+      ActionController::Base.view_paths.reload!
+      ActionView::Helpers::AssetTagHelper::AssetTag::Cache.clear
     end
 
     # Cleanup the application by clearing out loaded classes so they can
@@ -140,7 +159,22 @@ module ActionController
     end
 
     def flush_logger
-      RAILS_DEFAULT_LOGGER.flush
+      Base.logger.flush
+    end
+
+    def mark_as_test_request!
+      @test_request = true
+      self
+    end
+
+    def test_request?
+      @test_request
+    end
+
+    def checkin_connections
+      # Don't return connection (and peform implicit rollback) if this request is a part of integration test
+      return if test_request?
+      ActiveRecord::Base.clear_active_connections!
     end
 
     protected

data/lib/action_controller/filters.rb

@@ -94,7 +94,7 @@ module ActionController #:nodoc:
           map! do |filter|
             if filters.include?(filter)
               new_filter = filter.dup
-              new_filter.options.merge!(options)
+              new_filter.update_options!(options)
               new_filter
             else
               filter
@@ -104,16 +104,34 @@ module ActionController #:nodoc:
     end
 
     class Filter < ActiveSupport::Callbacks::Callback #:nodoc:
+      def initialize(kind, method, options = {})
+        super
+        update_options! options
+      end
+
+      # override these to return true in appropriate subclass
       def before?
-        self.class == BeforeFilter
+        false
       end
 
       def after?
-        self.class == AfterFilter
+        false
       end
 
       def around?
-        self.class == AroundFilter
+        false
+      end
+
+      # Make sets of strings from :only/:except options
+      def update_options!(other)
+        if other
+          convert_only_and_except_options_to_sets_of_strings(other)
+          if other[:skip]
+            convert_only_and_except_options_to_sets_of_strings(other[:skip])
+          end
+        end
+
+        options.update(other)
       end
 
       private
@@ -127,9 +145,9 @@ module ActionController #:nodoc:
 
         def included_in_action?(controller, options)
           if options[:only]
-            Array(options[:only]).map(&:to_s).include?(controller.action_name)
+            options[:only].include?(controller.action_name)
           elsif options[:except]
-            !Array(options[:except]).map(&:to_s).include?(controller.action_name)
+            !options[:except].include?(controller.action_name)
           else
             true
           end
@@ -138,6 +156,14 @@ module ActionController #:nodoc:
         def should_run_callback?(controller)
           should_not_skip?(controller) && included_in_action?(controller, options) && super
         end
+
+        def convert_only_and_except_options_to_sets_of_strings(opts)
+          [:only, :except].each do |key|
+            if values = opts[key]
+              opts[key] = Array(values).map(&:to_s).to_set
+            end
+          end
+        end
     end
 
     class AroundFilter < Filter #:nodoc:
@@ -145,6 +171,10 @@ module ActionController #:nodoc:
         :around
       end
 
+      def around?
+        true
+      end
+
       def call(controller, &block)
         if should_run_callback?(controller)
           method = filter_responds_to_before_and_after? ? around_proc : self.method
@@ -169,8 +199,8 @@ module ActionController #:nodoc:
           Proc.new do |controller, action|
             method.before(controller)
 
-            if controller.send!(:performed?)
-              controller.send!(:halt_filter_chain, method, :rendered_or_redirected)
+            if controller.__send__(:performed?)
+              controller.__send__(:halt_filter_chain, method, :rendered_or_redirected)
             else
               begin
                 action.call
@@ -187,10 +217,14 @@ module ActionController #:nodoc:
         :before
       end
 
+      def before?
+        true
+      end
+
       def call(controller, &block)
         super
-        if controller.send!(:performed?)
-          controller.send!(:halt_filter_chain, method, :rendered_or_redirected)
+        if controller.__send__(:performed?)
+          controller.__send__(:halt_filter_chain, method, :rendered_or_redirected)
         end
       end
     end
@@ -199,6 +233,10 @@ module ActionController #:nodoc:
       def type
         :after
       end
+
+      def after?
+        true
+      end
     end
 
     # Filters enable controllers to run shared pre- and post-processing code for its actions. These filters can be used to do

data/lib/action_controller/headers.rb

@@ -1,31 +1,33 @@
+require 'active_support/memoizable'
+
 module ActionController
   module Http
     class Headers < ::Hash
-      
-      def initialize(constructor = {})
-         if constructor.is_a?(Hash)
+      extend ActiveSupport::Memoizable
+
+      def initialize(*args)
+         if args.size == 1 && args[0].is_a?(Hash)
            super()
-           update(constructor)
+           update(args[0])
          else
-           super(constructor)
+           super
          end
        end
-      
+
       def [](header_name)
         if include?(header_name)
-          super 
+          super
         else
-          super(normalize_header(header_name))
+          super(env_name(header_name))
         end
       end
-      
-      
+
       private
-        # Takes an HTTP header name and returns it in the 
-        # format 
-        def normalize_header(header_name)
+        # Converts a HTTP header name to an environment variable name.
+        def env_name(header_name)
           "HTTP_#{header_name.upcase.gsub(/-/, '_')}"
         end
+        memoize :env_name
     end
   end
-end
+end

data/lib/action_controller/helpers.rb

@@ -204,8 +204,8 @@ module ActionController #:nodoc:
 
           begin
             child.master_helper_module = Module.new
-            child.master_helper_module.send! :include, master_helper_module
-            child.send! :default_helper_module!
+            child.master_helper_module.__send__ :include, master_helper_module
+            child.__send__ :default_helper_module!
           rescue MissingSourceFile => e
             raise unless e.is_missing?("helpers/#{child.controller_path}_helper")
           end

data/lib/action_controller/http_authentication.rb

@@ -117,7 +117,7 @@ module ActionController
 
       def authentication_request(controller, realm)
         controller.headers["WWW-Authenticate"] = %(Basic realm="#{realm.gsub(/"/, "")}")
-        controller.send! :render, :text => "HTTP Basic: Access denied.\n", :status => :unauthorized
+        controller.__send__ :render, :text => "HTTP Basic: Access denied.\n", :status => :unauthorized
       end
     end
   end

data/lib/action_controller/integration.rb

@@ -1,9 +1,10 @@
-require 'stringio'
-require 'uri'
-
+require 'active_support/test_case'
 require 'action_controller/dispatcher'
 require 'action_controller/test_process'
 
+require 'stringio'
+require 'uri'
+
 module ActionController
   module Integration #:nodoc:
     # An integration Session instance represents a set of requests and responses
@@ -100,7 +101,7 @@ module ActionController
         @https = flag
       end
 
-      # Return +true+ if the session is mimicing a secure HTTPS request.
+      # Return +true+ if the session is mimicking a secure HTTPS request.
       #
       #   if session.https?
       #     ...
@@ -164,11 +165,19 @@ module ActionController
         status/100 == 3
       end
 
-      # Performs a GET request with the given parameters. The parameters may
-      # be +nil+, a Hash, or a string that is appropriately encoded
-      # (<tt>application/x-www-form-urlencoded</tt> or <tt>multipart/form-data</tt>).
-      # The headers should be a hash. The keys will automatically be upcased, with the
-      # prefix 'HTTP_' added if needed.
+      # Performs a GET request with the given parameters.
+      #
+      # - +path+: The URI (as a String) on which you want to perform a GET request.
+      # - +parameters+: The HTTP parameters that you want to pass. This may be +nil+,
+      #   a Hash, or a String that is appropriately encoded
+      #   (<tt>application/x-www-form-urlencoded</tt> or <tt>multipart/form-data</tt>).
+      # - +headers+: Additional HTTP headers to pass, as a Hash. The keys will
+      #   automatically be upcased, with the prefix 'HTTP_' added if needed.
+      #
+      # This method returns an AbstractResponse object, which one can use to inspect
+      # the details of the response. Furthermore, if this method was called from an
+      # ActionController::IntegrationTest object, then that object's <tt>@response</tt>
+      # instance variable will point to the same response object.
       #
       # You can also perform POST, PUT, DELETE, and HEAD requests with +post+,
       # +put+, +delete+, and +head+.
@@ -219,21 +228,6 @@ module ActionController
       end
 
       private
-        class StubCGI < CGI #:nodoc:
-          attr_accessor :stdinput, :stdoutput, :env_table
-
-          def initialize(env, stdinput = nil)
-            self.env_table = env
-            self.stdoutput = StringIO.new
-
-            super
-
-            stdinput.set_encoding(Encoding::BINARY) if stdinput.respond_to?(:set_encoding)
-            stdinput.force_encoding(Encoding::BINARY) if stdinput.respond_to?(:force_encoding)
-            @stdinput = stdinput.is_a?(IO) ? stdinput : StringIO.new(stdinput || '')
-          end
-        end
-
         # Tailors the session based on the given URI, setting the HTTPS value
         # and the hostname.
         def interpret_uri(path)
@@ -281,9 +275,8 @@ module ActionController
 
           ActionController::Base.clear_last_instantiation!
 
-          cgi = StubCGI.new(env, data)
-          ActionController::Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, cgi.stdoutput)
-          @result = cgi.stdoutput.string
+          env['rack.input'] = data.is_a?(IO) ? data : StringIO.new(data || '')
+          @status, @headers, result_body = ActionController::Dispatcher.new.mark_as_test_request!.call(env)
           @request_count += 1
 
           @controller = ActionController::Base.last_instantiation
@@ -297,32 +290,34 @@ module ActionController
 
           @html_document = nil
 
-          parse_result
-          return status
-        rescue MultiPartNeededException
-          boundary = "----------XnJLe9ZIbbGUYtzPQJ16u1"
-          status = process(method, path, multipart_body(parameters, boundary), (headers || {}).merge({"CONTENT_TYPE" => "multipart/form-data; boundary=#{boundary}"}))
-          return status
-        end
+          # Inject status back in for backwords compatibility with CGI
+          @headers['Status'] = @status
 
-        # Parses the result of the response and extracts the various values,
-        # like cookies, status, headers, etc.
-        def parse_result
-          response_headers, result_body = @result.split(/\r\n\r\n/, 2)
+          @status, @status_message = @status.split(/ /)
+          @status = @status.to_i
 
-          @headers = Hash.new { |h,k| h[k] = [] }
-          response_headers.to_s.each_line do |line|
-            key, value = line.strip.split(/:\s*/, 2)
-            @headers[key.downcase] << value
+          cgi_headers = Hash.new { |h,k| h[k] = [] }
+          @headers.each do |key, value|
+            cgi_headers[key.downcase] << value
           end
+          cgi_headers['set-cookie'] = cgi_headers['set-cookie'].first
+          @headers = cgi_headers
 
-          (@headers['set-cookie'] || [] ).each do |string|
-            name, value = string.match(/^([^=]*)=([^;]*);/)[1,2]
+          @response.headers['cookie'] ||= []
+          (@headers['set-cookie'] || []).each do |cookie|
+            name, value = cookie.match(/^([^=]*)=([^;]*);/)[1,2]
             @cookies[name] = value
+
+            # Fake CGI cookie header
+            # DEPRECATE: Use response.headers["Set-Cookie"] instead
+            @response.headers['cookie'] << CGI::Cookie::new("name" => name, "value" => value)
           end
 
-          @status, @status_message = @headers["status"].first.to_s.split(/ /)
-          @status = @status.to_i
+          return status
+        rescue MultiPartNeededException
+          boundary = "----------XnJLe9ZIbbGUYtzPQJ16u1"
+          status = process(method, path, multipart_body(parameters, boundary), (headers || {}).merge({"CONTENT_TYPE" => "multipart/form-data; boundary=#{boundary}"}))
+          return status
         end
 
         # Encode the cookies hash in a format suitable for passing to a
@@ -335,13 +330,15 @@ module ActionController
 
         # Get a temporary URL writer object
         def generic_url_rewriter
-          cgi = StubCGI.new('REQUEST_METHOD' => "GET",
-                            'QUERY_STRING'   => "",
-                            "REQUEST_URI"    => "/",
-                            "HTTP_HOST"      => host,
-                            "SERVER_PORT"    => https? ? "443" : "80",
-                            "HTTPS"          => https? ? "on" : "off")
-          ActionController::UrlRewriter.new(ActionController::CgiRequest.new(cgi), {})
+          env = {
+            'REQUEST_METHOD' => "GET",
+            'QUERY_STRING'   => "",
+            "REQUEST_URI"    => "/",
+            "HTTP_HOST"      => host,
+            "SERVER_PORT"    => https? ? "443" : "80",
+            "HTTPS"          => https? ? "on" : "off"
+          }
+          ActionController::UrlRewriter.new(ActionController::RackRequest.new(env), {})
         end
 
         def name_with_prefix(prefix, name)
@@ -442,12 +439,12 @@ EOF
       end
 
       %w(get post put head delete cookies assigns
-         xml_http_request get_via_redirect post_via_redirect).each do |method|
+         xml_http_request xhr get_via_redirect post_via_redirect).each do |method|
         define_method(method) do |*args|
           reset! unless @integration_session
           # reset the html_document variable, but only for new get/post calls
           @html_document = nil unless %w(cookies assigns).include?(method)
-          returning @integration_session.send!(method, *args) do
+          returning @integration_session.__send__(method, *args) do
             copy_session_variables!
           end
         end
@@ -472,12 +469,12 @@ EOF
           self.class.fixture_table_names.each do |table_name|
             name = table_name.tr(".", "_")
             next unless respond_to?(name)
-            extras.send!(:define_method, name) { |*args| delegate.send(name, *args) }
+            extras.__send__(:define_method, name) { |*args| delegate.send(name, *args) }
           end
         end
 
         # delegate add_assertion to the test case
-        extras.send!(:define_method, :add_assertion) { test_result.add_assertion }
+        extras.__send__(:define_method, :add_assertion) { test_result.add_assertion }
         session.extend(extras)
         session.delegate = self
         session.test_result = @_result
@@ -491,14 +488,14 @@ EOF
       def copy_session_variables! #:nodoc:
         return unless @integration_session
         %w(controller response request).each do |var|
-          instance_variable_set("@#{var}", @integration_session.send!(var))
+          instance_variable_set("@#{var}", @integration_session.__send__(var))
         end
       end
 
       # Delegate unhandled messages to the current session instance.
       def method_missing(sym, *args, &block)
         reset! unless @integration_session
-        returning @integration_session.send!(sym, *args, &block) do
+        returning @integration_session.__send__(sym, *args, &block) do
           copy_session_variables!
         end
       end
@@ -580,7 +577,7 @@ EOF
   #         end
   #       end
   #   end
-  class IntegrationTest < Test::Unit::TestCase
+  class IntegrationTest < ActiveSupport::TestCase
     include Integration::Runner
 
     # Work around a bug in test/unit caused by the default test being named