actionpack 2.3.18 → 3.0.0.beta

data/lib/{action_controller → action_dispatch/middleware}/flash.rb

@@ -1,4 +1,13 @@
-module ActionController #:nodoc:
+module ActionDispatch
+  class Request
+    # 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
+      session['flash'] ||= Flash::FlashHash.new
+    end
+  end
+
   # The flash provides a way to pass temporary objects between actions. Anything you place in the flash will be exposed
   # to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create
   # action that sets <tt>flash[:notice] = "Successfully created"</tt> before redirecting to a display action that can
@@ -25,20 +34,7 @@ module ActionController #:nodoc:
   # many as you like at a time too. Just remember: They'll be gone by the time the next action has been performed.
   #
   # See docs on the FlashHash class for more details about the flash.
-  module Flash
-    def self.included(base)
-      base.class_eval do
-        include InstanceMethods
-
-        alias_method_chain :perform_action, :flash
-        alias_method_chain :reset_session,  :flash
-        alias_method_chain :redirect_to,    :flash
-
-        helper_method :alert
-        helper_method :notice
-      end
-    end
-
+  class Flash
     class FlashNow #:nodoc:
       def initialize(flash)
         @flash = flash
@@ -58,7 +54,7 @@ module ActionController #:nodoc:
     class FlashHash < Hash
       def initialize #:nodoc:
         super
-        @used = {}
+        @used = Set.new
       end
 
       def []=(k, v) #:nodoc:
@@ -74,7 +70,7 @@ module ActionController #:nodoc:
       alias :merge! :update
 
       def replace(h) #:nodoc:
-        @used = {}
+        @used = Set.new
         super
       end
 
@@ -113,8 +109,8 @@ module ActionController #:nodoc:
       # This method is called automatically by filters, so you generally don't need to care about it.
       def sweep #:nodoc:
         keys.each do |k|
-          unless @used[k]
-            use(k)
+          unless @used.include?(k)
+            @used << k
           else
             delete(k)
             @used.delete(k)
@@ -122,12 +118,27 @@ module ActionController #:nodoc:
         end
 
         # 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) }
+        (@used - keys).each{ |k| @used.delete(k) }
+      end
+
+      # Convenience accessor for flash[:alert]
+      def alert
+        self[:alert]
       end
 
-      def store(session, key = "flash")
-        return if self.empty?
-        session[key] = self
+      # Convenience accessor for flash[:alert]=
+      def alert=(message)
+        self[:alert] = message
+      end
+
+      # Convenience accessor for flash[:notice]
+      def notice
+        self[:notice]
+      end
+
+      # Convenience accessor for flash[:notice]=
+      def notice=(message)
+        self[:notice] = message
       end
 
       private
@@ -136,78 +147,28 @@ module ActionController #:nodoc:
         #     use('msg')          # marks the "msg" entry as used
         #     use(nil, false)     # marks the entire flash as unused (keeps it around for one more action)
         #     use('msg', false)   # marks the "msg" entry as unused (keeps it around for one more action)
-        def use(k=nil, v=true)
-          unless k.nil?
-            @used[k] = v
-          else
-            keys.each{ |key| use(key, v) }
-          end
+        # Returns the single value for the key you asked to be marked (un)used or the FlashHash itself
+        # if no key is passed.
+        def use(key = nil, used = true)
+          Array(key || keys).each { |k| used ? @used << k : @used.delete(k) }
+          return key ? self[key] : self
         end
     end
 
-    module InstanceMethods #:nodoc:
-      protected
-        def perform_action_with_flash
-          perform_action_without_flash
-          if defined? @_flash
-            @_flash.store(session)
-            remove_instance_variable(:@_flash)
-          end
-        end
-
-        def reset_session_with_flash
-          reset_session_without_flash
-          remove_instance_variable(:@_flash) if defined? @_flash
-        end
-
-        def redirect_to_with_flash(options = {}, response_status_and_flash = {}) #:doc:
-          if alert = response_status_and_flash.delete(:alert)
-            flash[:alert] = alert
-          end
-
-          if notice = response_status_and_flash.delete(:notice)
-            flash[:notice] = notice
-          end
-          
-          if other_flashes = response_status_and_flash.delete(:flash)
-            flash.update(other_flashes)
-          end
-          
-          redirect_to_without_flash(options, response_status_and_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.
-        def flash #:doc:
-          if !defined?(@_flash)
-            @_flash = session["flash"] || FlashHash.new
-            @_flash.sweep
-          end
-
-          @_flash
-        end
+    def initialize(app)
+      @app = app
+    end
 
-        
-        # Convenience accessor for flash[:alert]
-        def alert
-          flash[:alert]
-        end
-        
-        # Convenience accessor for flash[:alert]=
-        def alert=(message)
-          flash[:alert] = message
-        end
+    def call(env)
+      if (session = env['rack.session']) && (flash = session['flash'])
+        flash.sweep
+      end
 
-        # Convenience accessor for flash[:notice]
-        def notice
-          flash[:notice]
-        end
-        
-        # Convenience accessor for flash[:notice]=
-        def notice=(message)
-          flash[:notice] = message
-        end
+      @app.call(env)
+    ensure
+      if (session = env['rack.session']) && (flash = session['flash']) && flash.empty?
+        session.delete('flash')
+      end
     end
   end
 end

data/lib/action_dispatch/middleware/head.rb

@@ -0,0 +1,18 @@
+module ActionDispatch
+  class Head
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["REQUEST_METHOD"] == "HEAD"
+        env["REQUEST_METHOD"] = "GET"
+        env["rack.methodoverride.original_method"] = "HEAD"
+        status, headers, body = @app.call(env)
+        [status, headers, []]
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/action_dispatch/middleware/params_parser.rb

@@ -0,0 +1,78 @@
+require 'active_support/json'
+require 'action_dispatch/http/request'
+
+module ActionDispatch
+  class ParamsParser
+    DEFAULT_PARSERS = {
+      Mime::XML => :xml_simple,
+      Mime::JSON => :json
+    }
+
+    def initialize(app, parsers = {})
+      @app, @parsers = app, DEFAULT_PARSERS.merge(parsers)
+    end
+
+    def call(env)
+      if params = parse_formatted_parameters(env)
+        env["action_dispatch.request.request_parameters"] = params
+      end
+
+      @app.call(env)
+    end
+
+    private
+      def parse_formatted_parameters(env)
+        request = Request.new(env)
+
+        return false if request.content_length.zero?
+
+        mime_type = content_type_from_legacy_post_data_format_header(env) || request.content_type
+        strategy = @parsers[mime_type]
+
+        return false unless strategy
+
+        case strategy
+        when Proc
+          strategy.call(request.raw_post)
+        when :xml_simple, :xml_node
+          request.body.size == 0 ? {} : Hash.from_xml(request.raw_post).with_indifferent_access
+        when :yaml
+          YAML.load(request.raw_post)
+        when :json
+          if request.body.size == 0
+            {}
+          else
+            data = ActiveSupport::JSON.decode(request.raw_post)
+            data = {:_json => data} unless data.is_a?(Hash)
+            data.with_indifferent_access
+          end
+        else
+          false
+        end
+      rescue Exception => e # YAML, XML or Ruby code block errors
+        logger.debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
+
+        raise
+          { "body"           => request.raw_post,
+            "content_type"   => request.content_type,
+            "content_length" => request.content_length,
+            "exception"      => "#{e.message} (#{e.class})",
+            "backtrace"      => e.backtrace }
+      end
+
+      def content_type_from_legacy_post_data_format_header(env)
+        if x_post_format = env['HTTP_X_POST_DATA_FORMAT']
+          case x_post_format.to_s.downcase
+          when 'yaml' then return Mime::YAML
+          when 'xml'  then return Mime::XML
+          end
+        end
+
+        nil
+      end
+
+      def logger
+        defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
+      end
+  end
+end

data/lib/action_dispatch/middleware/rescue.rb

@@ -0,0 +1,26 @@
+module ActionDispatch
+  class Rescue
+    def initialize(app, rescuers = {}, &block)
+      @app, @rescuers = app, {}
+      rescuers.each { |exception, rescuer| rescue_from(exception, rescuer) }
+      instance_eval(&block) if block_given?
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      if rescuer = @rescuers[exception.class.name]
+        env['action_dispatch.rescue.exception'] = exception
+        rescuer.call(env)
+      else
+        raise exception
+      end
+    end
+
+    protected
+      def rescue_from(exception, rescuer)
+        exception = exception.class.name if exception.is_a?(Exception)
+        @rescuers[exception.to_s] = rescuer
+      end
+  end
+end

data/lib/action_dispatch/middleware/session/abstract_store.rb

@@ -0,0 +1,209 @@
+require 'rack/utils'
+require 'rack/request'
+
+module ActionDispatch
+  module Session
+    class SessionRestoreError < StandardError #:nodoc:
+    end
+
+    class AbstractStore
+      ENV_SESSION_KEY = 'rack.session'.freeze
+      ENV_SESSION_OPTIONS_KEY = 'rack.session.options'.freeze
+
+      HTTP_COOKIE = 'HTTP_COOKIE'.freeze
+      SET_COOKIE = 'Set-Cookie'.freeze
+
+      class SessionHash < Hash
+        def initialize(by, env)
+          super()
+          @by = by
+          @env = env
+          @loaded = false
+        end
+
+        def session_id
+          ActiveSupport::Deprecation.warn(
+            "ActionDispatch::Session::AbstractStore::SessionHash#session_id " +
+            "has been deprecated. Please use request.session_options[:id] instead.", caller)
+          @env[ENV_SESSION_OPTIONS_KEY][:id]
+        end
+
+        def [](key)
+          load! unless @loaded
+          super(key.to_s)
+        end
+
+        def []=(key, value)
+          load! unless @loaded
+          super(key.to_s, value)
+        end
+
+        def to_hash
+          h = {}.replace(self)
+          h.delete_if { |k,v| v.nil? }
+          h
+        end
+
+        def update(hash = nil)
+          if hash.nil?
+            ActiveSupport::Deprecation.warn('use replace instead', caller)
+            replace({})
+          else
+            load! unless @loaded
+            super(hash.stringify_keys)
+          end
+        end
+
+        def delete(key = nil)
+          if key.nil?
+            ActiveSupport::Deprecation.warn('use clear instead', caller)
+            clear
+          else
+            load! unless @loaded
+            super(key.to_s)
+          end
+        end
+
+        def data
+         ActiveSupport::Deprecation.warn(
+           "ActionDispatch::Session::AbstractStore::SessionHash#data " +
+           "has been deprecated. Please use #to_hash instead.", caller)
+          to_hash
+        end
+
+        def close
+          ActiveSupport::Deprecation.warn('sessions should no longer be closed', caller)
+        end
+
+        def inspect
+          load! unless @loaded
+          super
+        end
+
+        private
+          def loaded?
+            @loaded
+          end
+
+          def load!
+            stale_session_check! do
+              id, session = @by.send(:load_session, @env)
+              (@env[ENV_SESSION_OPTIONS_KEY] ||= {})[:id] = id
+              replace(session.stringify_keys)
+              @loaded = true
+            end
+          end
+
+          def stale_session_check!
+            yield
+          rescue ArgumentError => argument_error
+            if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
+              begin
+                # Note that the regexp does not allow $1 to end with a ':'
+                $1.constantize
+              rescue LoadError, NameError => const_error
+                raise ActionDispatch::Session::SessionRestoreError, "Session contains objects whose class definition isn't available.\nRemember to require the classes for all objects kept in the session.\n(Original exception: #{const_error.message} [#{const_error.class}])\n"
+              end
+
+              retry
+            else
+              raise
+            end
+          end
+      end
+
+      DEFAULT_OPTIONS = {
+        :key =>           '_session_id',
+        :path =>          '/',
+        :domain =>        nil,
+        :expire_after =>  nil,
+        :secure =>        false,
+        :httponly =>      true,
+        :cookie_only =>   true
+      }
+
+      def initialize(app, options = {})
+        # Process legacy CGI options
+        options = options.symbolize_keys
+        if options.has_key?(:session_path)
+          options[:path] = options.delete(:session_path)
+        end
+        if options.has_key?(:session_key)
+          options[:key] = options.delete(:session_key)
+        end
+        if options.has_key?(:session_http_only)
+          options[:httponly] = options.delete(:session_http_only)
+        end
+
+        @app = app
+        @default_options = DEFAULT_OPTIONS.merge(options)
+        @key = @default_options[:key]
+        @cookie_only = @default_options[:cookie_only]
+      end
+
+      def call(env)
+        session = SessionHash.new(self, env)
+
+        env[ENV_SESSION_KEY] = session
+        env[ENV_SESSION_OPTIONS_KEY] = @default_options.dup
+
+        response = @app.call(env)
+
+        session_data = env[ENV_SESSION_KEY]
+        options = env[ENV_SESSION_OPTIONS_KEY]
+
+        if !session_data.is_a?(AbstractStore::SessionHash) || session_data.send(:loaded?) || options[:expire_after]
+          session_data.send(:load!) if session_data.is_a?(AbstractStore::SessionHash) && !session_data.send(:loaded?)
+
+          sid = options[:id] || generate_sid
+
+          unless set_session(env, sid, session_data.to_hash)
+            return response
+          end
+
+          cookie = Rack::Utils.escape(@key) + '=' + Rack::Utils.escape(sid)
+          cookie << "; domain=#{options[:domain]}" if options[:domain]
+          cookie << "; path=#{options[:path]}" if options[:path]
+          if options[:expire_after]
+            expiry = Time.now + options[:expire_after]
+            cookie << "; expires=#{expiry.httpdate}"
+          end
+          cookie << "; Secure" if options[:secure]
+          cookie << "; HttpOnly" if options[:httponly]
+
+          headers = response[1]
+          unless headers[SET_COOKIE].blank?
+            headers[SET_COOKIE] << "\n#{cookie}"
+          else
+            headers[SET_COOKIE] = cookie
+          end
+        end
+
+        response
+      end
+
+      private
+        def generate_sid
+          ActiveSupport::SecureRandom.hex(16)
+        end
+
+        def load_session(env)
+          request = Rack::Request.new(env)
+          sid = request.cookies[@key]
+          unless @cookie_only
+            sid ||= request.params[@key]
+          end
+          sid, session = get_session(env, sid)
+          [sid, session]
+        end
+
+        def get_session(env, sid)
+          raise '#get_session needs to be implemented.'
+        end
+
+        def set_session(env, sid, session_data)
+          raise '#set_session needs to be implemented.'
+        end
+    end
+  end
+end