actionpack 5.0.0.1 → 5.0.1.rc1

data/lib/action_dispatch/middleware/static.rb

@@ -46,7 +46,7 @@ module ActionDispatch
     end
 
     def call(env)
-      serve ActionDispatch::Request.new env
+      serve(Rack::Request.new(env))
     end
 
     def serve(request)
@@ -82,7 +82,7 @@ module ActionDispatch
       end
 
       def gzip_encoding_accepted?(request)
-        request.accept_encoding =~ /\bgzip\b/i
+        request.accept_encoding.any? { |enc, quality| enc =~ /\bgzip\b/i }
       end
 
       def gzip_file_path(path)
@@ -123,7 +123,7 @@ module ActionDispatch
     end
 
     def call(env)
-      req = ActionDispatch::Request.new env
+      req = Rack::Request.new env
 
       if req.get? || req.head?
         path = req.path_info.chomp('/'.freeze)

data/lib/action_dispatch/routing/mapper.rb

@@ -716,11 +716,7 @@ module ActionDispatch
           def map_method(method, args, &block)
             options = args.extract_options!
             options[:via] = method
-            if options.key?(:defaults)
-              defaults(options.delete(:defaults)) { match(*args, options, &block) }
-            else
-              match(*args, options, &block)
-            end
+            match(*args, options, &block)
             self
           end
       end
@@ -1258,11 +1254,11 @@ module ActionDispatch
         # the plural):
         #
         #   GET       /profile/new
-        #   POST      /profile
         #   GET       /profile
         #   GET       /profile/edit
         #   PATCH/PUT /profile
         #   DELETE    /profile
+        #   POST      /profile
         #
         # === Options
         # Takes same options as +resources+.
@@ -1280,15 +1276,15 @@ module ActionDispatch
 
               concerns(options[:concerns]) if options[:concerns]
 
-              collection do
-                post :create
-              end if parent_resource.actions.include?(:create)
-
               new do
                 get :new
               end if parent_resource.actions.include?(:new)
 
               set_member_mappings_for_resource
+
+              collection do
+                post :create
+              end if parent_resource.actions.include?(:create)
             end
           end
 
@@ -1566,11 +1562,17 @@ module ActionDispatch
         #   match 'path' => 'controller#action', via: patch
         #   match 'path', to: 'controller#action', via: :post
         #   match 'path', 'otherpath', on: :member, via: :get
-        def match(path, *rest)
+        def match(path, *rest, &block)
           if rest.empty? && Hash === path
             options  = path
             path, to = options.find { |name, _value| name.is_a?(String) }
 
+            if path.nil?
+              ActiveSupport::Deprecation.warn 'Omitting the route path is deprecated. '\
+                'Specify the path with a String or a Symbol instead.'
+              path = ''
+            end
+
             case to
             when Symbol
               options[:action] = to
@@ -1591,55 +1593,11 @@ module ActionDispatch
             paths = [path] + rest
           end
 
-          if options[:on] && !VALID_ON_OPTIONS.include?(options[:on])
-            raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
-          end
-
-          if @scope[:to]
-            options[:to] ||= @scope[:to]
-          end
-
-          if @scope[:controller] && @scope[:action]
-            options[:to] ||= "#{@scope[:controller]}##{@scope[:action]}"
-          end
-
-          controller = options.delete(:controller) || @scope[:controller]
-          option_path = options.delete :path
-          to = options.delete :to
-          via = Mapping.check_via Array(options.delete(:via) {
-            @scope[:via]
-          })
-          formatted = options.delete(:format) { @scope[:format] }
-          anchor = options.delete(:anchor) { true }
-          options_constraints = options.delete(:constraints) || {}
-
-          path_types = paths.group_by(&:class)
-          path_types.fetch(String, []).each do |_path|
-            route_options = options.dup
-            if _path && option_path
-              ActiveSupport::Deprecation.warn <<-eowarn
-Specifying strings for both :path and the route path is deprecated. Change things like this:
-
-  match #{_path.inspect}, :path => #{option_path.inspect}
-
-to this:
-
-  match #{option_path.inspect}, :as => #{_path.inspect}, :action => #{path.inspect}
-              eowarn
-              route_options[:action] = _path
-              route_options[:as] = _path
-              _path = option_path
-            end
-            to = get_to_from_path(_path, to, route_options[:action])
-            decomposed_match(_path, controller, route_options, _path, to, via, formatted, anchor, options_constraints)
-          end
-
-          path_types.fetch(Symbol, []).each do |action|
-            route_options = options.dup
-            decomposed_match(action, controller, route_options, option_path, to, via, formatted, anchor, options_constraints)
+          if options.key?(:defaults)
+            defaults(options.delete(:defaults)) { map_match(paths, options, &block) }
+          else
+            map_match(paths, options, &block)
           end
-
-          self
         end
 
         def get_to_from_path(path, to, action)
@@ -1915,6 +1873,7 @@ to this:
           def api_only?
             @set.api_only?
           end
+
         private
 
         def path_scope(path)
@@ -1924,9 +1883,63 @@ to this:
           @scope = @scope.parent
         end
 
+        def map_match(paths, options)
+          if options[:on] && !VALID_ON_OPTIONS.include?(options[:on])
+            raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
+          end
+
+          if @scope[:to]
+            options[:to] ||= @scope[:to]
+          end
+
+          if @scope[:controller] && @scope[:action]
+            options[:to] ||= "#{@scope[:controller]}##{@scope[:action]}"
+          end
+
+          controller = options.delete(:controller) || @scope[:controller]
+          option_path = options.delete :path
+          to = options.delete :to
+          via = Mapping.check_via Array(options.delete(:via) {
+            @scope[:via]
+          })
+          formatted = options.delete(:format) { @scope[:format] }
+          anchor = options.delete(:anchor) { true }
+          options_constraints = options.delete(:constraints) || {}
+
+          path_types = paths.group_by(&:class)
+          path_types.fetch(String, []).each do |_path|
+            route_options = options.dup
+            if _path && option_path
+              ActiveSupport::Deprecation.warn <<-eowarn
+Specifying strings for both :path and the route path is deprecated. Change things like this:
+
+match #{_path.inspect}, :path => #{option_path.inspect}
+
+to this:
+
+match #{option_path.inspect}, :as => #{_path.inspect}, :action => #{_path.inspect}
+              eowarn
+              route_options[:action] = _path
+              route_options[:as] = _path
+              _path = option_path
+            end
+            to = get_to_from_path(_path, to, route_options[:action])
+            decomposed_match(_path, controller, route_options, _path, to, via, formatted, anchor, options_constraints)
+          end
+
+          path_types.fetch(Symbol, []).each do |action|
+            route_options = options.dup
+            decomposed_match(action, controller, route_options, option_path, to, via, formatted, anchor, options_constraints)
+          end
+
+          self
+        end
+
         def match_root_route(options)
-          name = has_named_route?(:root) ? nil : :root
-          match '/', { :as => name, :via => :get }.merge!(options)
+          name = has_named_route?(name_for_action(:root, nil)) ? nil : :root
+          args = ["/", { as: name, via: :get }.merge!(options)]
+
+          match(*args)
         end
       end
 

data/lib/action_dispatch/routing/redirection.rb

@@ -22,7 +22,6 @@ module ActionDispatch
       end
 
       def serve(req)
-        req.check_path_parameters!
         uri = URI.parse(path(req.path_parameters, req))
 
         unless uri.host

data/lib/action_dispatch/testing/integration.rb

@@ -6,65 +6,40 @@ require 'active_support/core_ext/string/strip'
 require 'rack/test'
 require 'minitest'
 
+require 'action_dispatch/testing/request_encoder'
+
 module ActionDispatch
   module Integration #:nodoc:
     module RequestHelpers
-      # Performs a GET request with the given parameters.
-      #
-      # - +path+: The URI (as a String) on which you want to perform a GET
-      #   request.
-      # - +params+: 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 headers to pass, as a Hash. The headers will be
-      #   merged into the Rack env hash.
-      # - +env+: Additional env to pass, as a Hash. The headers will be
-      #   merged into the Rack env hash.
-      #
-      # This method returns a Response object, which one can use to
-      # inspect the details of the response. Furthermore, if this method was
-      # called from an ActionDispatch::IntegrationTest object, then that
-      # object's <tt>@response</tt> instance variable will point to the same
-      # response object.
-      #
-      # You can also perform POST, PATCH, PUT, DELETE, and HEAD requests with
-      # +#post+, +#patch+, +#put+, +#delete+, and +#head+.
-      #
-      # Example:
-      #
-      #   get '/feed', params: { since: 201501011400 }
-      #   post '/profile', headers: { "X-Test-Header" => "testvalue" }
       def get(path, *args)
         process_with_kwargs(:get, path, *args)
       end
 
-      # Performs a POST request with the given parameters. See +#get+ for more
+      # Performs a POST request with the given parameters. See +#process+ for more
       # details.
       def post(path, *args)
         process_with_kwargs(:post, path, *args)
       end
 
-      # Performs a PATCH request with the given parameters. See +#get+ for more
+      # Performs a PATCH request with the given parameters. See +#process+ for more
       # details.
       def patch(path, *args)
         process_with_kwargs(:patch, path, *args)
       end
 
-      # Performs a PUT request with the given parameters. See +#get+ for more
+      # Performs a PUT request with the given parameters. See +#process+ for more
       # details.
       def put(path, *args)
         process_with_kwargs(:put, path, *args)
       end
 
-      # Performs a DELETE request with the given parameters. See +#get+ for
+      # Performs a DELETE request with the given parameters. See +#process+ for
       # more details.
       def delete(path, *args)
         process_with_kwargs(:delete, path, *args)
       end
 
-      # Performs a HEAD request with the given parameters. See +#get+ for more
+      # Performs a HEAD request with the given parameters. See +#process+ for more
       # details.
       def head(path, *args)
         process_with_kwargs(:head, path, *args)
@@ -79,26 +54,14 @@ module ActionDispatch
       #
       # Example:
       #
-      #   xhr :get, '/feed', params: { since: 201501011400 }
-      def xml_http_request(request_method, path, *args)
-        if kwarg_request?(args)
-          params, headers, env = args.first.values_at(:params, :headers, :env)
-        else
-          params = args[0]
-          headers = args[1]
-          env = {}
-
-          if params.present? || headers.present?
-            non_kwarg_request_warning
-          end
-        end
-
+      #   xhr :get, '/feed', since: 201501011400
+      def xml_http_request(request_method, path, parameters = nil, headers_or_env = nil)
         ActiveSupport::Deprecation.warn(<<-MSG.strip_heredoc)
-          xhr and xml_http_request methods are deprecated in favor of
-          `get "/posts", xhr: true` and `post "/posts/1", xhr: true`.
+          `xhr` and `xml_http_request` are deprecated and will be removed in Rails 5.1.
+          Switch to e.g. `post comments_path, params: { comment: { body: 'Honey bunny' } }, xhr: true`.
         MSG
 
-        process(request_method, path, params: params, headers: headers, xhr: true)
+        process(request_method, path, params: parameters, headers: headers_or_env, xhr: true)
       end
       alias xhr :xml_http_request
 
@@ -177,7 +140,7 @@ module ActionDispatch
       DEFAULT_HOST = "www.example.com"
 
       include Minitest::Assertions
-      include TestProcess, RequestHelpers, Assertions
+      include RequestHelpers, Assertions
 
       %w( status status_message headers body redirect? ).each do |method|
         delegate method, :to => :response, :allow_nil => true
@@ -281,6 +244,108 @@ module ActionDispatch
         @https
       end
 
+      # Performs the actual request.
+      #
+      # - +method+: The HTTP method (GET, POST, PATCH, PUT, DELETE, HEAD, OPTIONS)
+      #   as a symbol.
+      # - +path+: The URI (as a String) on which you want to perform the
+      #   request.
+      # - +params+: 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 headers to pass, as a Hash. The headers will be
+      #   merged into the Rack env hash.
+      # - +env+: Additional env to pass, as a Hash. The headers will be
+      #   merged into the Rack env hash.
+      #
+      # This method is rarely used directly. Use +#get+, +#post+, or other standard
+      # HTTP methods in integration tests. +#process+ is only required when using a
+      # request method that doesn't have a method defined in the integrations tests.
+      #
+      # This method returns a Response object, which one can use to
+      # inspect the details of the response. Furthermore, if this method was
+      # called from an ActionDispatch::IntegrationTest object, then that
+      # object's <tt>@response</tt> instance variable will point to the same
+      # response object.
+      #
+      # Example:
+      #
+      #   process :get, '/author', params: { since: 201501011400 }
+      def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: nil)
+        request_encoder = RequestEncoder.encoder(as)
+        headers ||= {}
+
+        if method == :get && as == :json && params
+          headers['X-Http-Method-Override'] = 'GET'
+          method = :post
+        end
+
+        if path =~ %r{://}
+          location = URI.parse(path)
+          https! URI::HTTPS === location if location.scheme
+          if url_host = location.host
+            default = Rack::Request::DEFAULT_PORTS[location.scheme]
+            url_host += ":#{location.port}" if default != location.port
+            host! url_host
+          end
+          path = location.query ? "#{location.path}?#{location.query}" : location.path
+        end
+
+        hostname, port = host.split(':')
+
+        request_env = {
+          :method => method,
+          :params => request_encoder.encode_params(params),
+
+          "SERVER_NAME"     => hostname,
+          "SERVER_PORT"     => port || (https? ? "443" : "80"),
+          "HTTPS"           => https? ? "on" : "off",
+          "rack.url_scheme" => https? ? "https" : "http",
+
+          "REQUEST_URI"    => path,
+          "HTTP_HOST"      => host,
+          "REMOTE_ADDR"    => remote_addr,
+          "CONTENT_TYPE"   => request_encoder.content_type,
+          "HTTP_ACCEPT"    => request_encoder.accept_header || accept
+        }
+
+        wrapped_headers = Http::Headers.from_hash({})
+        wrapped_headers.merge!(headers) if headers
+
+        if xhr
+          wrapped_headers["HTTP_X_REQUESTED_WITH"] = "XMLHttpRequest"
+          wrapped_headers["HTTP_ACCEPT"] ||= [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(", ")
+        end
+
+        # this modifies the passed request_env directly
+        if wrapped_headers.present?
+          Http::Headers.from_hash(request_env).merge!(wrapped_headers)
+        end
+        if env.present?
+          Http::Headers.from_hash(request_env).merge!(env)
+        end
+
+        session = Rack::Test::Session.new(_mock_session)
+
+        # NOTE: rack-test v0.5 doesn't build a default uri correctly
+        # Make sure requested path is always a full uri
+        session.request(build_full_uri(path, request_env), request_env)
+
+        @request_count += 1
+        @request = ActionDispatch::Request.new(session.last_request.env)
+        response = _mock_session.last_response
+        @response = ActionDispatch::TestResponse.from_response(response)
+        @response.request = @request
+        @html_document = nil
+        @url_options = nil
+
+        @controller = @request.controller_instance
+
+        response.status
+      end
+
       # Set the host name to use in the next request.
       #
       #   session.host! "www.example.com"
@@ -307,144 +372,20 @@ module ActionDispatch
 
         def non_kwarg_request_warning
           ActiveSupport::Deprecation.warn(<<-MSG.strip_heredoc)
-            ActionDispatch::IntegrationTest HTTP request methods will accept only
-            the following keyword arguments in future Rails versions:
-            #{REQUEST_KWARGS.join(', ')}
-
-            Examples:
-
-            get '/profile',
-              params: { id: 1 },
-              headers: { 'X-Extra-Header' => '123' },
-              env: { 'action_dispatch.custom' => 'custom' },
-              xhr: true,
-              as: :json
-          MSG
-        end
-
-        # Performs the actual request.
-        def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: nil)
-          request_encoder = RequestEncoder.encoder(as)
-
-          if path =~ %r{://}
-            location = URI.parse(path)
-            https! URI::HTTPS === location if location.scheme
-            if url_host = location.host
-              default = Rack::Request::DEFAULT_PORTS[location.scheme]
-              url_host += ":#{location.port}" if default != location.port
-              host! url_host
-            end
-            path = request_encoder.append_format_to location.path
-            path = location.query ? "#{path}?#{location.query}" : path
-          else
-            path = request_encoder.append_format_to path
-          end
-
-          hostname, port = host.split(':')
-
-          request_env = {
-            :method => method,
-            :params => request_encoder.encode_params(params),
-
-            "SERVER_NAME"     => hostname,
-            "SERVER_PORT"     => port || (https? ? "443" : "80"),
-            "HTTPS"           => https? ? "on" : "off",
-            "rack.url_scheme" => https? ? "https" : "http",
-
-            "REQUEST_URI"    => path,
-            "HTTP_HOST"      => host,
-            "REMOTE_ADDR"    => remote_addr,
-            "CONTENT_TYPE"   => request_encoder.content_type,
-            "HTTP_ACCEPT"    => accept
-          }
-
-          if xhr
-            headers ||= {}
-            headers['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
-            headers['HTTP_ACCEPT'] ||= [Mime[:js], Mime[:html], Mime[:xml], 'text/xml', '*/*'].join(', ')
-          end
-
-          # this modifies the passed request_env directly
-          if headers.present?
-            Http::Headers.from_hash(request_env).merge!(headers)
-          end
-          if env.present?
-            Http::Headers.from_hash(request_env).merge!(env)
-          end
-
-          session = Rack::Test::Session.new(_mock_session)
-
-          # NOTE: rack-test v0.5 doesn't build a default uri correctly
-          # Make sure requested path is always a full uri
-          session.request(build_full_uri(path, request_env), request_env)
-
-          @request_count += 1
-          @request  = ActionDispatch::Request.new(session.last_request.env)
-          response = _mock_session.last_response
-          @response = ActionDispatch::TestResponse.from_response(response)
-          @response.request = @request
-          @response.response_parser = RequestEncoder.parser(@response.content_type)
-          @html_document = nil
-          @url_options = nil
+            Using positional arguments in integration tests has been deprecated,
+            in favor of keyword arguments, and will be removed in Rails 5.1.
 
-          @controller = @request.controller_instance
+            Deprecated style:
+            get "/profile", { id: 1 }, { "X-Extra-Header" => "123" }
 
-          response.status
+            New keyword style:
+            get "/profile", params: { id: 1 }, headers: { "X-Extra-Header" => "123" }
+          MSG
         end
 
         def build_full_uri(path, env)
           "#{env['rack.url_scheme']}://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{path}"
         end
-
-        class RequestEncoder # :nodoc:
-          @encoders = {}
-
-          attr_reader :response_parser
-
-          def initialize(mime_name, param_encoder, response_parser, url_encoded_form = false)
-            @mime = Mime[mime_name]
-
-            unless @mime
-              raise ArgumentError, "Can't register a request encoder for " \
-                "unregistered MIME Type: #{mime_name}. See `Mime::Type.register`."
-            end
-
-            @url_encoded_form = url_encoded_form
-            @path_format      = ".#{@mime.symbol}" unless @url_encoded_form
-            @response_parser  = response_parser || -> body { body }
-            @param_encoder    = param_encoder   || :"to_#{@mime.symbol}".to_proc
-          end
-
-          def append_format_to(path)
-            path << @path_format unless @url_encoded_form
-            path
-          end
-
-          def content_type
-            @mime.to_s
-          end
-
-          def encode_params(params)
-            @param_encoder.call(params)
-          end
-
-          def self.parser(content_type)
-            mime = Mime::Type.lookup(content_type)
-            encoder(mime ? mime.ref : nil).response_parser
-          end
-
-          def self.encoder(name)
-            @encoders[name] || WWWFormEncoder
-          end
-
-          def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil)
-            @encoders[mime_name] = new(mime_name, param_encoder, response_parser)
-          end
-
-          register_encoder :json, response_parser: -> body { JSON.parse(body) }
-
-          WWWFormEncoder = new(:url_encoded_form, -> params { params }, nil, true)
-        end
     end
 
     module Runner
@@ -512,6 +453,7 @@ module ActionDispatch
       # simultaneously.
       def open_session
         dup.tap do |session|
+          session.reset!
           yield session if block_given?
         end
       end
@@ -701,42 +643,50 @@ module ActionDispatch
   #       end
   #   end
   #
+  # See the {request helpers documentation}[rdoc-ref:ActionDispatch::Integration::RequestHelpers] for help on how to
+  # use +get+, etc.
+  #
+  # === Changing the request encoding
+  #
   # You can also test your JSON API easily by setting what the request should
   # be encoded as:
   #
-  #   require 'test_helper'
+  #   require "test_helper"
   #
   #   class ApiTest < ActionDispatch::IntegrationTest
-  #     test 'creates articles' do
+  #     test "creates articles" do
   #       assert_difference -> { Article.count } do
-  #         post articles_path, params: { article: { title: 'Ahoy!' } }, as: :json
+  #         post articles_path, params: { article: { title: "Ahoy!" } }, as: :json
   #       end
   #
   #       assert_response :success
-  #       assert_equal({ id: Arcticle.last.id, title: 'Ahoy!' }, response.parsed_body)
+  #       assert_equal({ id: Arcticle.last.id, title: "Ahoy!" }, response.parsed_body)
   #     end
   #   end
   #
-  # The `as` option sets the format to JSON, sets the content type to
-  # 'application/json' and encodes the parameters as JSON.
+  # The +as+ option passes an "application/json" Accept header (thereby setting
+  # the request format to JSON unless overridden), sets the content type to
+  # "application/json" and encodes the parameters as JSON.
   #
-  # Calling `parsed_body` on the response parses the response body as what
-  # the last request was encoded as. If the request wasn't encoded `as` something,
-  # it's the same as calling `body`.
+  # Calling +parsed_body+ on the response parses the response body based on the
+  # last response MIME type.
   #
-  # For any custom MIME Types you've registered, you can even add your own encoders with:
+  # Out of the box, only <tt>:json</tt> is supported. But for any custom MIME
+  # types you've registered, you can add your own encoders with:
   #
   #   ActionDispatch::IntegrationTest.register_encoder :wibble,
   #     param_encoder: -> params { params.to_wibble },
   #     response_parser: -> body { body }
   #
-  # Where `param_encoder` defines how the params should be encoded and
-  # `response_parser` defines how the response body should be parsed through
-  # `parsed_body`.
+  # Where +param_encoder+ defines how the params should be encoded and
+  # +response_parser+ defines how the response body should be parsed through
+  # +parsed_body+.
   #
   # Consult the Rails Testing Guide for more.
 
   class IntegrationTest < ActiveSupport::TestCase
+    include TestProcess
+
     module UrlOptions
       extend ActiveSupport::Concern
       def url_options
@@ -759,7 +709,11 @@ module ActionDispatch
 
       module ClassMethods
         def app
-          defined?(@@app) ? @@app : ActionDispatch.test_app
+          if defined?(@@app) && @@app
+            @@app
+          else
+            ActionDispatch.test_app
+          end
         end
 
         def app=(app)
@@ -767,7 +721,7 @@ module ActionDispatch
         end
 
         def register_encoder(*args)
-          Integration::Session::RequestEncoder.register_encoder(*args)
+          RequestEncoder.register_encoder(*args)
         end
       end