actionpack 4.2.11.3 → 5.0.0.beta1

data/lib/action_dispatch/middleware/load_interlock.rb

@@ -0,0 +1,21 @@
+require 'active_support/dependencies'
+require 'rack/body_proxy'
+
+module ActionDispatch
+  class LoadInterlock
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      interlock = ActiveSupport::Dependencies.interlock
+      interlock.start_running
+      response = @app.call(env)
+      body = Rack::BodyProxy.new(response[2]) { interlock.done_running }
+      response[2] = body
+      response
+    ensure
+      interlock.done_running unless body
+    end
+  end
+end

data/lib/action_dispatch/middleware/params_parser.rb

@@ -1,60 +1,44 @@
-require 'active_support/core_ext/hash/conversions'
 require 'action_dispatch/http/request'
-require 'active_support/core_ext/hash/indifferent_access'
 
 module ActionDispatch
+  # ActionDispatch::ParamsParser works for all the requests having any Content-Length
+  # (like POST). It takes raw data from the request and puts it through the parser
+  # that is picked based on Content-Type header.
+  #
+  # In case of any error while parsing data ParamsParser::ParseError is raised.
   class ParamsParser
+    # Raised when raw data from the request cannot be parsed by the parser
+    # defined for request's content mime type.
     class ParseError < StandardError
-      attr_reader :original_exception
 
-      def initialize(message, original_exception)
-        super(message)
-        @original_exception = original_exception
-      end
-    end
-
-    DEFAULT_PARSERS = { 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?
-
-        strategy = @parsers[request.content_mime_type]
-
-        return false unless strategy
+      def initialize(message = nil, original_exception = nil)
+        if message
+          ActiveSupport::Deprecation.warn("Passing #message is deprecated and has no effect. " \
+                                          "#{self.class} will automatically capture the message " \
+                                          "of the original exception.", caller)
+        end
 
-        case strategy
-        when Proc
-          strategy.call(request.raw_post)
-        when :json
-          data = ActiveSupport::JSON.decode(request.raw_post)
-          data = {:_json => data} unless data.is_a?(Hash)
-          Request::Utils.deep_munge(data).with_indifferent_access
-        else
-          false
+        if original_exception
+          ActiveSupport::Deprecation.warn("Passing #original_exception is deprecated and has no effect. " \
+                                          "Exceptions will automatically capture the original exception.", caller)
         end
-      rescue => e # JSON or Ruby code block errors
-        logger(env).debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
 
-        raise ParseError.new(e.message, e)
+        super($!.message)
       end
 
-      def logger(env)
-        env['action_dispatch.logger'] || ActiveSupport::Logger.new($stderr)
+      def original_exception
+        ActiveSupport::Deprecation.warn("#original_exception is deprecated. Use #cause instead.", caller)
+        cause
       end
+    end
+
+    # Create a new +ParamsParser+ middleware instance.
+    #
+    # The +parsers+ argument can take Hash of parsers where key is identifying
+    # content mime type, and value is a lambda that is going to process data.
+    def self.new(app, parsers = {})
+      ActionDispatch::Request.parameter_parsers = ActionDispatch::Request::DEFAULT_PARSERS.merge(parsers)
+      app
+    end
   end
 end

data/lib/action_dispatch/middleware/public_exceptions.rb

@@ -17,10 +17,10 @@ module ActionDispatch
     end
 
     def call(env)
-      status       = env["PATH_INFO"][1..-1]
       request      = ActionDispatch::Request.new(env)
+      status       = request.path_info[1..-1].to_i
       content_type = request.formats.first
-      body         = { :status => status, :error => Rack::Utils::HTTP_STATUS_CODES.fetch(status.to_i, Rack::Utils::HTTP_STATUS_CODES[500]) }
+      body         = { :status => status, :error => Rack::Utils::HTTP_STATUS_CODES.fetch(status, Rack::Utils::HTTP_STATUS_CODES[500]) }
 
       render(status, content_type, body)
     end

data/lib/action_dispatch/middleware/reloader.rb

@@ -1,5 +1,3 @@
-require 'active_support/deprecation/reporting'
-
 module ActionDispatch
   # ActionDispatch::Reloader provides prepare and cleanup callbacks,
   # intended to assist with code reloading during development.
@@ -11,9 +9,9 @@ module ActionDispatch
   # the response body. This is important for streaming responses such as the
   # following:
   #
-  #     self.response_body = lambda { |response, output|
+  #     self.response_body = -> (response, output) do
   #       # code here which refers to application models
-  #     }
+  #     end
   #
   # Cleanup callbacks will not be called until after the response_body lambda
   # is evaluated, ensuring that it can refer to application models and other

data/lib/action_dispatch/middleware/remote_ip.rb

@@ -43,7 +43,7 @@ module ActionDispatch
 
     # Create a new +RemoteIp+ middleware instance.
     #
-    # The +check_ip_spoofing+ option is on by default. When on, an exception
+    # The +ip_spoofing_check+ option is on by default. When on, an exception
     # is raised if it looks like the client is trying to lie about its own IP
     # address. It makes sense to turn off this check on sites aimed at non-IP
     # clients (like WAP devices), or behind proxies that set headers in an
@@ -57,9 +57,9 @@ module ActionDispatch
     # with your proxy servers after it. If your proxies aren't removed, pass
     # them in via the +custom_proxies+ parameter. That way, the middleware will
     # ignore those IP addresses, and return the one that you want.
-    def initialize(app, check_ip_spoofing = true, custom_proxies = nil)
+    def initialize(app, ip_spoofing_check = true, custom_proxies = nil)
       @app = app
-      @check_ip = check_ip_spoofing
+      @check_ip = ip_spoofing_check
       @proxies = if custom_proxies.blank?
         TRUSTED_PROXIES
       elsif custom_proxies.respond_to?(:any?)
@@ -74,18 +74,19 @@ module ActionDispatch
     # requests. For those requests that do need to know the IP, the
     # GetIp#calculate_ip method will calculate the memoized client IP address.
     def call(env)
-      env["action_dispatch.remote_ip"] = GetIp.new(env, self)
-      @app.call(env)
+      req = ActionDispatch::Request.new env
+      req.remote_ip = GetIp.new(req, check_ip, proxies)
+      @app.call(req.env)
     end
 
     # The GetIp class exists as a way to defer processing of the request data
     # into an actual IP address. If the ActionDispatch::Request#remote_ip method
     # is called, this class will calculate the value and then memoize it.
     class GetIp
-      def initialize(env, middleware)
-        @env      = env
-        @check_ip = middleware.check_ip
-        @proxies  = middleware.proxies
+      def initialize(req, check_ip, proxies)
+        @req      = req
+        @check_ip = check_ip
+        @proxies  = proxies
       end
 
       # Sort through the various IP address headers, looking for the IP most
@@ -108,23 +109,31 @@ module ActionDispatch
       # the last address left, which was presumably set by one of those proxies.
       def calculate_ip
         # Set by the Rack web server, this is a single value.
-        remote_addr = ips_from('REMOTE_ADDR').last
+        remote_addr = ips_from(@req.remote_addr).last
 
         # Could be a CSV list and/or repeated headers that were concatenated.
-        client_ips    = ips_from('HTTP_CLIENT_IP').reverse
-        forwarded_ips = ips_from('HTTP_X_FORWARDED_FOR').reverse
+        client_ips    = ips_from(@req.client_ip).reverse
+        forwarded_ips = ips_from(@req.x_forwarded_for).reverse
 
         # +Client-Ip+ and +X-Forwarded-For+ should not, generally, both be set.
-        # If they are both set, it means that this request passed through two
-        # proxies with incompatible IP header conventions, and there is no way
-        # for us to determine which header is the right one after the fact.
-        # Since we have no idea, we give up and explode.
+        # If they are both set, it means that either:
+        #
+        # 1) This request passed through two proxies with incompatible IP header
+        #    conventions.
+        # 2) The client passed one of +Client-Ip+ or +X-Forwarded-For+
+        #    (whichever the proxy servers weren't using) themselves.
+        #
+        # Either way, there is no way for us to determine which header is the
+        # right one after the fact. Since we have no idea, if we are concerned
+        # about IP spoofing we need to give up and explode. (If you're not
+        # concerned about IP spoofing you can turn the +ip_spoofing_check+
+        # option off.)
         should_check_ip = @check_ip && client_ips.last && forwarded_ips.last
         if should_check_ip && !forwarded_ips.include?(client_ips.last)
           # We don't know which came from the proxy, and which from the user
           raise IpSpoofAttackError, "IP spoofing attack?! " +
-            "HTTP_CLIENT_IP=#{@env['HTTP_CLIENT_IP'].inspect} " +
-            "HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}"
+            "HTTP_CLIENT_IP=#{@req.client_ip.inspect} " +
+            "HTTP_X_FORWARDED_FOR=#{@req.x_forwarded_for.inspect}"
         end
 
         # We assume these things about the IP headers:
@@ -147,8 +156,9 @@ module ActionDispatch
     protected
 
       def ips_from(header)
+        return [] unless header
         # Split the comma-separated list into an array of strings
-        ips = @env[header] ? @env[header].strip.split(/[,\s]+/) : []
+        ips = header.strip.split(/[,\s]+/)
         ips.select do |ip|
           begin
             # Only return IPs that are valid according to the IPAddr#new method

data/lib/action_dispatch/middleware/request_id.rb

@@ -3,7 +3,7 @@ require 'active_support/core_ext/string/access'
 
 module ActionDispatch
   # Makes a unique request id available to the action_dispatch.request_id env variable (which is then accessible through
-  # ActionDispatch::Request#uuid) and sends the same id to the client via the X-Request-Id header.
+  # ActionDispatch::Request#uuid or the alias ActionDispatch::Request#request_id) and sends the same id to the client via the X-Request-Id header.
   #
   # The unique request id is either based on the X-Request-Id header in the request, which would typically be generated
   # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
@@ -12,19 +12,24 @@ module ActionDispatch
   # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
   # from multiple pieces of the stack.
   class RequestId
+    X_REQUEST_ID = "X-Request-Id".freeze # :nodoc:
+
     def initialize(app)
       @app = app
     end
 
     def call(env)
-      env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id
-      @app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = env["action_dispatch.request_id"] }
+      req = ActionDispatch::Request.new env
+      req.request_id = make_request_id(req.x_request_id)
+      @app.call(env).tap { |_status, headers, _body| headers[X_REQUEST_ID] = req.request_id }
     end
 
     private
-      def external_request_id(env)
-        if request_id = env["HTTP_X_REQUEST_ID"].presence
-          request_id.gsub(/[^\w\-]/, "").first(255)
+      def make_request_id(request_id)
+        if request_id.presence
+          request_id.gsub(/[^\w\-]/, "".freeze).first(255)
+        else
+          internal_request_id
         end
       end
 

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

@@ -7,14 +7,22 @@ require 'action_dispatch/request/session'
 module ActionDispatch
   module Session
     class SessionRestoreError < StandardError #:nodoc:
-      attr_reader :original_exception
 
-      def initialize(const_error)
-        @original_exception = const_error
+      def initialize(const_error = nil)
+        if const_error
+          ActiveSupport::Deprecation.warn("Passing #original_exception is deprecated and has no effect. " \
+                                          "Exceptions will automatically capture the original exception.", caller)
+        end
 
         super("Session contains objects whose class definition isn't available.\n" +
           "Remember to require the classes for all objects kept in the session.\n" +
-          "(Original exception: #{const_error.message} [#{const_error.class}])\n")
+          "(Original exception: #{$!.message} [#{$!.class}])\n")
+        set_backtrace $!.backtrace
+      end
+
+      def original_exception
+        ActiveSupport::Deprecation.warn("#original_exception is deprecated. Use #cause instead.", caller)
+        cause
       end
     end
 
@@ -36,6 +44,11 @@ module ActionDispatch
         @default_options.delete(:sidbits)
         @default_options.delete(:secure_random)
       end
+
+      private
+      def make_request(env)
+        ActionDispatch::Request.new env
+      end
     end
 
     module StaleSessionCheck
@@ -54,8 +67,8 @@ module ActionDispatch
           begin
             # Note that the regexp does not allow $1 to end with a ':'
             $1.constantize
-          rescue LoadError, NameError => e
-            raise ActionDispatch::Session::SessionRestoreError, e, e.backtrace
+          rescue LoadError, NameError
+            raise ActionDispatch::Session::SessionRestoreError
           end
           retry
         else
@@ -65,8 +78,8 @@ module ActionDispatch
     end
 
     module SessionObject # :nodoc:
-      def prepare_session(env)
-        Request::Session.create(self, env, @default_options)
+      def prepare_session(req)
+        Request::Session.create(self, req, @default_options)
       end
 
       def loaded_session?(session)
@@ -74,15 +87,14 @@ module ActionDispatch
       end
     end
 
-    class AbstractStore < Rack::Session::Abstract::ID
+    class AbstractStore < Rack::Session::Abstract::Persisted
       include Compatibility
       include StaleSessionCheck
       include SessionObject
 
       private
 
-      def set_cookie(env, session_id, cookie)
-        request = ActionDispatch::Request.new(env)
+      def set_cookie(request, session_id, cookie)
         request.cookie_jar[key] = cookie
       end
     end

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

@@ -2,12 +2,15 @@ require 'action_dispatch/middleware/session/abstract_store'
 
 module ActionDispatch
   module Session
-    # Session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
+    # A session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
     # if you don't store critical data in your sessions and you don't need them to live for extended periods
     # of time.
+    #
+    # ==== Options
+    # * <tt>cache</tt>         - The cache to use. If it is not specified, <tt>Rails.cache</tt> will be used.
+    # * <tt>expire_after</tt>  - The length of time a session will be stored before automatically expiring.
+    #   By default, the <tt>:expires_in</tt> option of the cache is used.
     class CacheStore < AbstractStore
-      # Create a new store. The cache to use can be passed in the <tt>:cache</tt> option. If it is
-      # not specified, <tt>Rails.cache</tt> will be used.
       def initialize(app, options = {})
         @cache = options[:cache] || Rails.cache
         options[:expire_after] ||= @cache.options[:expires_in]
@@ -15,7 +18,7 @@ module ActionDispatch
       end
 
       # Get a session from the cache.
-      def get_session(env, sid)
+      def find_session(env, sid)
         unless sid and session = @cache.read(cache_key(sid))
           sid, session = generate_sid, {}
         end
@@ -23,7 +26,7 @@ module ActionDispatch
       end
 
       # Set a session in the cache.
-      def set_session(env, sid, session, options)
+      def write_session(env, sid, session, options)
         key = cache_key(sid)
         if session
           @cache.write(key, session, :expires_in => options[:expire_after])
@@ -34,7 +37,7 @@ module ActionDispatch
       end
 
       # Remove a session from the cache.
-      def destroy_session(env, sid, options)
+      def delete_session(env, sid, options)
         @cache.delete(cache_key(sid))
         generate_sid
       end

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

@@ -36,7 +36,7 @@ module ActionDispatch
     #   development:
     #     secret_key_base: 'secret key'
     #
-    # To generate a secret key for an existing application, run `rake secret`.
+    # To generate a secret key for an existing application, run `rails secret`.
     #
     # If you are upgrading an existing Rails 3 app, you should leave your
     # existing secret_token in place and simply add the new secret_key_base.
@@ -52,25 +52,31 @@ module ActionDispatch
     # JavaScript before upgrading.
     #
     # Note that changing the secret key will invalidate all existing sessions!
-    class CookieStore < Rack::Session::Abstract::ID
-      include Compatibility
-      include StaleSessionCheck
-      include SessionObject
-
+    #
+    # Because CookieStore extends Rack::Session::Abstract::Persisted, many of the
+    # options described there can be used to customize the session cookie that
+    # is generated. For example:
+    #
+    #   Rails.application.config.session_store :cookie_store, expire_after: 14.days
+    #
+    # would set the session cookie to expire automatically 14 days after creation.
+    # Other useful options include <tt>:key</tt>, <tt>:secure</tt> and
+    # <tt>:httponly</tt>.
+    class CookieStore < AbstractStore
       def initialize(app, options={})
         super(app, options.merge!(:cookie_only => true))
       end
 
-      def destroy_session(env, session_id, options)
+      def delete_session(req, session_id, options)
         new_sid = generate_sid unless options[:drop]
         # Reset hash and Assign the new session id
-        env["action_dispatch.request.unsigned_session_cookie"] = new_sid ? { "session_id" => new_sid } : {}
+        req.set_header("action_dispatch.request.unsigned_session_cookie", new_sid ? { "session_id" => new_sid } : {})
         new_sid
       end
 
-      def load_session(env)
+      def load_session(req)
         stale_session_check! do
-          data = unpacked_cookie_data(env)
+          data = unpacked_cookie_data(req)
           data = persistent_session_id!(data)
           [data["session_id"], data]
         end
@@ -78,20 +84,21 @@ module ActionDispatch
 
       private
 
-      def extract_session_id(env)
+      def extract_session_id(req)
         stale_session_check! do
-          unpacked_cookie_data(env)["session_id"]
+          unpacked_cookie_data(req)["session_id"]
         end
       end
 
-      def unpacked_cookie_data(env)
-        env["action_dispatch.request.unsigned_session_cookie"] ||= begin
-          stale_session_check! do
-            if data = get_cookie(env)
+      def unpacked_cookie_data(req)
+        req.fetch_header("action_dispatch.request.unsigned_session_cookie") do |k|
+          v = stale_session_check! do
+            if data = get_cookie(req)
               data.stringify_keys!
             end
             data || {}
           end
+          req.set_header k, v
         end
       end
 
@@ -101,21 +108,20 @@ module ActionDispatch
         data
       end
 
-      def set_session(env, sid, session_data, options)
+      def write_session(req, sid, session_data, options)
         session_data["session_id"] = sid
         session_data
       end
 
-      def set_cookie(env, session_id, cookie)
-        cookie_jar(env)[@key] = cookie
+      def set_cookie(request, session_id, cookie)
+        cookie_jar(request)[@key] = cookie
       end
 
-      def get_cookie(env)
-        cookie_jar(env)[@key]
+      def get_cookie(req)
+        cookie_jar(req)[@key]
       end
 
-      def cookie_jar(env)
-        request = ActionDispatch::Request.new(env)
+      def cookie_jar(request)
         request.cookie_jar.signed_or_encrypted
       end
     end