actionpack 2.2.3 → 2.3.2

data/lib/action_controller/cookies.rb

@@ -41,7 +41,7 @@ module ActionController #:nodoc:
   # * <tt>:expires</tt> - The time at which this cookie expires, as a Time object.
   # * <tt>:secure</tt> - Whether this cookie is a only transmitted to HTTPS servers.
   #   Default is +false+.
-  # * <tt>:http_only</tt> - Whether this cookie is accessible via scripting or
+  # * <tt>:httponly</tt> - Whether this cookie is accessible via scripting or
   #   only HTTP. Defaults to +false+.
   module Cookies
     def self.included(base)
@@ -64,43 +64,31 @@ module ActionController #:nodoc:
 
     # Returns the value of the cookie by +name+, or +nil+ if no such cookie exists.
     def [](name)
-      cookie = @cookies[name.to_s]
-      if cookie && cookie.respond_to?(:value)
-        cookie.size > 1 ? cookie.value : cookie.value[0]
-      end
+      super(name.to_s)
     end
 
     # Sets the cookie named +name+. The second argument may be the very cookie
     # value, or a hash of options as documented above.
-    def []=(name, options)
+    def []=(key, options)
       if options.is_a?(Hash)
-        options = options.inject({}) { |options, pair| options[pair.first.to_s] = pair.last; options }
-        options["name"] = name.to_s
+        options.symbolize_keys!
       else
-        options = { "name" => name.to_s, "value" => options }
+        options = { :value => options }
       end
 
-      set_cookie(options)
+      options[:path] = "/" unless options.has_key?(:path)
+      super(key.to_s, options[:value])
+      @controller.response.set_cookie(key, options)
     end
 
     # Removes the cookie on the client machine by setting the value to an empty string
     # and setting its expiration date into the past. Like <tt>[]=</tt>, you can pass in
     # an options hash to delete cookies with extra data such as a <tt>:path</tt>.
-    def delete(name, options = {})
-      options.stringify_keys!
-      set_cookie(options.merge("name" => name.to_s, "value" => "", "expires" => Time.at(0)))
+    def delete(key, options = {})
+      options.symbolize_keys!
+      options[:path] = "/" unless options.has_key?(:path)
+      super(key.to_s)
+      @controller.response.delete_cookie(key, options)
     end
-
-    private
-      # Builds a CGI::Cookie object and adds the cookie to the response headers.
-      #
-      # The path of the cookie defaults to "/" if there's none in +options+, and
-      # everything is passed to the CGI::Cookie constructor.
-      def set_cookie(options) #:doc:
-        options["path"] = "/" unless options["path"]
-        cookie = CGI::Cookie.new(options)
-        @controller.logger.info "Cookie set: #{cookie}" unless @controller.logger.nil?
-        @controller.response.headers["cookie"] << cookie
-      end
   end
 end

data/lib/action_controller/dispatcher.rb

@@ -2,29 +2,17 @@ module ActionController
   # Dispatches requests to the appropriate controller and takes care of
   # reloading the app after each request when Dependencies.load? is true.
   class Dispatcher
-    @@guard = Mutex.new
-
     class << self
       def define_dispatcher_callbacks(cache_classes)
         unless cache_classes
-          # Development mode callbacks
-          before_dispatch :reload_application
-          after_dispatch :cleanup_application
+          unless self.middleware.include?(Reloader)
+            self.middleware.insert_after(Failsafe, Reloader)
+          end
 
           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
         end
 
-        # Common callbacks
-        to_prepare :load_application_controller do
-          begin
-            require_dependency 'application' unless defined?(::ApplicationController)
-          rescue LoadError => error
-            raise unless error.message =~ /application\.rb/
-          end
-        end
-
         if defined?(ActiveRecord)
-          after_dispatch :checkin_connections
           to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers }
         end
 
@@ -35,8 +23,7 @@ module ActionController
         end
       end
 
-      # Backward-compatible class method takes CGI-specific args. Deprecated
-      # in favor of Dispatcher.new(output, request, response).dispatch.
+      # DEPRECATE: Remove CGI support
       def dispatch(cgi = nil, session_options = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
         new(output).dispatch_cgi(cgi, session_options)
       end
@@ -55,143 +42,77 @@ module ActionController
         @prepare_dispatch_callbacks.replace_or_append!(callback)
       end
 
-      # If the block raises, send status code as a last-ditch response.
-      def failsafe_response(fallback_output, status, originating_exception = nil)
-        yield
-      rescue Exception => exception
-        begin
-          log_failsafe_exception(status, originating_exception || exception)
-          body = failsafe_response_body(status)
-          fallback_output.write "Status: #{status}\r\nContent-Type: text/html\r\n\r\n#{body}"
-          nil
-        rescue Exception => failsafe_error # Logger or IO errors
-          $stderr.puts "Error during failsafe response: #{failsafe_error}"
-          $stderr.puts "(originally #{originating_exception})" if originating_exception
+      def run_prepare_callbacks
+        if defined?(Rails) && Rails.logger
+          logger = Rails.logger
+        else
+          logger = Logger.new($stderr)
         end
+
+        new(logger).send :run_callbacks, :prepare_dispatch
       end
 
-      private
-        def failsafe_response_body(status)
-          error_path = "#{error_file_path}/#{status.to_s[0..3]}.html"
+      def reload_application
+        # Run prepare callbacks before every request in development mode
+        run_prepare_callbacks
 
-          if File.exist?(error_path)
-            File.read(error_path)
-          else
-            "<html><body><h1>#{status}</h1></body></html>"
-          end
-        end
-
-        def log_failsafe_exception(status, exception)
-          message = "/!\\ FAILSAFE /!\\  #{Time.now}\n  Status: #{status}\n"
-          message << "  #{exception}\n    #{exception.backtrace.join("\n    ")}" if exception
-          failsafe_logger.fatal message
-        end
+        Routing::Routes.reload
+      end
 
-        def failsafe_logger
-          if defined?(::RAILS_DEFAULT_LOGGER) && !::RAILS_DEFAULT_LOGGER.nil?
-            ::RAILS_DEFAULT_LOGGER
-          else
-            Logger.new($stderr)
-          end
-        end
+      def cleanup_application
+        # Cleanup the application before processing the current request.
+        ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
+        ActiveSupport::Dependencies.clear
+        ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
+      end
     end
 
-    cattr_accessor :error_file_path
-    self.error_file_path = Rails.public_path if defined?(Rails.public_path)
+    cattr_accessor :middleware
+    self.middleware = MiddlewareStack.new do |middleware|
+      middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
+      middleware.instance_eval(File.read(middlewares))
+    end
 
     include ActiveSupport::Callbacks
     define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
 
+    # DEPRECATE: Remove arguments, since they are only used by CGI
     def initialize(output = $stdout, request = nil, response = nil)
-      @output, @request, @response = output, request, response
+      @output = output
+      @app = @@middleware.build(lambda { |env| self.dup._call(env) })
     end
 
-    def dispatch_unlocked
+    def dispatch
       begin
         run_callbacks :before_dispatch
-        handle_request
+        Routing::Routes.call(@env)
       rescue Exception => exception
-        failsafe_rescue exception
+        if controller ||= (::ApplicationController rescue Base)
+          controller.call_with_exception(@env, exception).to_a
+        else
+          raise exception
+        end
       ensure
         run_callbacks :after_dispatch, :enumerator => :reverse_each
       end
     end
 
-    def dispatch
-      if ActionController::Base.allow_concurrency
-        dispatch_unlocked
-      else
-        @@guard.synchronize do
-          dispatch_unlocked
-        end
-      end
-    end
-
+    # DEPRECATE: Remove CGI support
     def dispatch_cgi(cgi, session_options)
-      if cgi ||= self.class.failsafe_response(@output, '400 Bad Request') { CGI.new }
-        @request = CgiRequest.new(cgi, session_options)
-        @response = CgiResponse.new(cgi)
-        dispatch
-      end
-    rescue Exception => exception
-      failsafe_rescue exception
+      CGIHandler.dispatch_cgi(self, cgi, @output)
     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
-      ActionController::Base.view_paths.reload!
+      @app.call(env)
     end
 
-    # Cleanup the application by clearing out loaded classes so they can
-    # be reloaded on the next request without restarting the server.
-    def cleanup_application
-      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-      ActiveSupport::Dependencies.clear
-      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
+    def _call(env)
+      @env = env
+      dispatch
     end
 
     def flush_logger
       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
-      def handle_request
-        @controller = Routing::Routes.recognize(@request)
-        @controller.process(@request, @response).out(@output)
-      end
-
-      def failsafe_rescue(exception)
-        self.class.failsafe_response(@output, '500 Internal Server Error', exception) do
-          if @controller ||= defined?(::ApplicationController) ? ::ApplicationController : Base
-            @controller.process_with_exception(@request, @response, exception).out(@output)
-          else
-            raise exception
-          end
-        end
-      end
   end
 end

data/lib/action_controller/failsafe.rb

@@ -0,0 +1,52 @@
+module ActionController
+  class Failsafe
+    cattr_accessor :error_file_path
+    self.error_file_path = Rails.public_path if defined?(Rails.public_path)
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      # Reraise exception in test environment
+      if env["rack.test"]
+        raise exception
+      else
+        failsafe_response(exception)
+      end
+    end
+
+    private
+      def failsafe_response(exception)
+        log_failsafe_exception(exception)
+        [500, {'Content-Type' => 'text/html'}, failsafe_response_body]
+      rescue Exception => failsafe_error # Logger or IO errors
+        $stderr.puts "Error during failsafe response: #{failsafe_error}"
+      end
+
+      def failsafe_response_body
+        error_path = "#{self.class.error_file_path}/500.html"
+        if File.exist?(error_path)
+          File.read(error_path)
+        else
+          "<html><body><h1>500 Internal Server Error</h1></body></html>"
+        end
+      end
+
+      def log_failsafe_exception(exception)
+        message = "/!\\ FAILSAFE /!\\  #{Time.now}\n  Status: 500 Internal Server Error\n"
+        message << "  #{exception}\n    #{exception.backtrace.join("\n    ")}" if exception
+        failsafe_logger.fatal(message)
+      end
+
+      def failsafe_logger
+        if defined?(Rails) && Rails.logger
+          Rails.logger
+        else
+          Logger.new($stderr)
+        end
+      end
+  end
+end

data/lib/action_controller/flash.rb

@@ -4,20 +4,22 @@ module ActionController #:nodoc:
   # action that sets <tt>flash[:notice] = "Successfully created"</tt> before redirecting to a display action that can
   # then expose the flash to its template. Actually, that exposure is automatically done. Example:
   #
-  #   class WeblogController < ActionController::Base
+  #   class PostsController < ActionController::Base
   #     def create
   #       # save post
   #       flash[:notice] = "Successfully created post"
-  #       redirect_to :action => "display", :params => { :id => post.id }
+  #       redirect_to posts_path(@post)
   #     end
   #
-  #     def display
+  #     def show
   #       # doesn't need to assign the flash notice to the template, that's done automatically
   #     end
   #   end
   #
-  #   display.erb
-  #     <% if flash[:notice] %><div class="notice"><%= flash[:notice] %></div><% end %>
+  #   show.html.erb
+  #     <% if flash[:notice] %>
+  #       <div class="notice"><%= flash[:notice] %></div>
+  #     <% end %>
   #
   # This example just places a string in the flash, but you can put any object in there. And of course, you can put as
   # many as you like at a time too. Just remember: They'll be gone by the time the next action has been performed.
@@ -27,55 +29,54 @@ module ActionController #:nodoc:
     def self.included(base)
       base.class_eval do
         include InstanceMethods
-        alias_method_chain :assign_shortcuts, :flash
-        alias_method_chain :reset_session,    :flash
+        alias_method_chain :perform_action, :flash
+        alias_method_chain :reset_session,  :flash
       end
     end
-    
-    
+
     class FlashNow #:nodoc:
       def initialize(flash)
         @flash = flash
       end
-      
+
       def []=(k, v)
         @flash[k] = v
         @flash.discard(k)
         v
       end
-      
+
       def [](k)
         @flash[k]
       end
     end
-    
+
     class FlashHash < Hash
       def initialize #:nodoc:
         super
         @used = {}
       end
-      
+
       def []=(k, v) #:nodoc:
         keep(k)
         super
       end
-      
+
       def update(h) #:nodoc:
         h.keys.each { |k| keep(k) }
         super
       end
-      
+
       alias :merge! :update
-      
+
       def replace(h) #:nodoc:
         @used = {}
         super
       end
-    
+
       # Sets a flash that will not be available to the next action, only to the current.
       #
       #     flash.now[:message] = "Hello current action"
-      # 
+      #
       # This method enables you to use the flash as a central messaging system in your app.
       # When you need to pass an object to the next action, you use the standard flash assign (<tt>[]=</tt>).
       # When you need to pass an object to the current action, you use <tt>now</tt>, and your object will
@@ -85,7 +86,7 @@ module ActionController #:nodoc:
       def now
         FlashNow.new(self)
       end
-    
+
       # Keeps either the entire current flash or a specific flash entry available for the next action:
       #
       #    flash.keep            # keeps the entire flash
@@ -93,7 +94,7 @@ module ActionController #:nodoc:
       def keep(k = nil)
         use(k, false)
       end
-    
+
       # Marks the entire flash or a single flash entry to be discarded by the end of the current action:
       #
       #     flash.discard              # discard the entire flash at the end of the current action
@@ -101,12 +102,12 @@ module ActionController #:nodoc:
       def discard(k = nil)
         use(k)
       end
-    
+
       # Mark for removal entries that were kept, and delete unkept ones.
       #
       # This method is called automatically by filters, so you generally don't need to care about it.
       def sweep #:nodoc:
-        keys.each do |k| 
+        keys.each do |k|
           unless @used[k]
             use(k)
           else
@@ -118,7 +119,7 @@ module ActionController #:nodoc:
         # clean up after keys that could have been left over by calling reject! or shift on the flash
         (@used.keys - keys).each{ |k| @used.delete(k) }
       end
-    
+
       private
         # Used internally by the <tt>keep</tt> and <tt>discard</tt> methods
         #     use()               # marks the entire flash as used
@@ -136,37 +137,27 @@ module ActionController #:nodoc:
 
     module InstanceMethods #:nodoc:
       protected
+        def perform_action_with_flash
+          perform_action_without_flash
+          remove_instance_variable(:@_flash) if defined? @_flash
+        end
+
         def reset_session_with_flash
           reset_session_without_flash
-          remove_instance_variable(:@_flash)
-          flash(:refresh)
+          remove_instance_variable(:@_flash) if defined? @_flash
         end
-      
-        # Access the contents of the flash. Use <tt>flash["notice"]</tt> to read a notice you put there or 
-        # <tt>flash["notice"] = "hello"</tt> to put a new one.
-        # Note that if sessions are disabled only flash.now will work.
-        def flash(refresh = false) #:doc:
-          if !defined?(@_flash) || refresh
-            @_flash =
-              if session.is_a?(Hash)
-                # don't put flash in session if disabled
-                FlashHash.new
-              else
-                # otherwise, session is a CGI::Session or a TestSession
-                # so make sure it gets retrieved from/saved to session storage after request processing
-                session["flash"] ||= FlashHash.new
-              end
+
+        # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
+        # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
+        # to put a new one.
+        def flash #:doc:
+          unless defined? @_flash
+            @_flash = session["flash"] ||= FlashHash.new
+            @_flash.sweep
           end
 
           @_flash
         end
-
-      private
-        def assign_shortcuts_with_flash(request, response) #:nodoc:
-          assign_shortcuts_without_flash(request, response)
-          flash(:refresh)
-          flash.sweep if @_session && !component_request?
-        end
     end
   end
 end