actionpack 6.0.3.6 → 6.1.0.rc1

data/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -145,6 +145,7 @@ module ActionDispatch
 
       %w(edit new).each do |action|
         module_eval <<-EOT, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
           def #{action}_polymorphic_url(record_or_hash, options = {})
             polymorphic_url_for_action("#{action}", record_or_hash, options)
           end
@@ -173,15 +174,15 @@ module ActionDispatch
         end
 
         class HelperMethodBuilder # :nodoc:
-          CACHE = { "path" => {}, "url" => {} }
+          CACHE = { path: {}, url: {} }
 
           def self.get(action, type)
-            type = type.to_s
+            type = type.to_sym
             CACHE[type].fetch(action) { build action, type }
           end
 
-          def self.url;  CACHE["url"][nil]; end
-          def self.path; CACHE["path"][nil]; end
+          def self.url;  CACHE[:url][nil]; end
+          def self.path; CACHE[:path][nil]; end
 
           def self.build(action, type)
             prefix = action ? "#{action}_" : ""
@@ -227,9 +228,9 @@ module ActionDispatch
             end
 
             if options.empty?
-              recipient.send(method, *args)
+              recipient.public_send(method, *args)
             else
-              recipient.send(method, *args, options)
+              recipient.public_send(method, *args, options)
             end
           end
 
@@ -246,7 +247,7 @@ module ActionDispatch
           end
 
           def handle_string_call(target, str)
-            target.send get_method_for_string str
+            target.public_send get_method_for_string str
           end
 
           def handle_class(klass)
@@ -254,7 +255,7 @@ module ActionDispatch
           end
 
           def handle_class_call(target, klass)
-            target.send get_method_for_class klass
+            target.public_send get_method_for_class klass
           end
 
           def handle_model(record)
@@ -276,7 +277,7 @@ module ActionDispatch
               mapping.call(target, [record], suffix == "path")
             else
               method, args = handle_model(record)
-              target.send(method, *args)
+              target.public_send(method, *args)
             end
           end
 
@@ -340,8 +341,8 @@ module ActionDispatch
             end
 
             [nil, "new", "edit"].each do |action|
-              CACHE["url"][action]  = build action, "url"
-              CACHE["path"][action] = build action, "path"
+              CACHE[:url][action]  = build action, "url"
+              CACHE[:path][action] = build action, "path"
             end
         end
     end

data/lib/action_dispatch/routing/redirection.rb

@@ -65,15 +65,15 @@ module ActionDispatch
         end
 
         def escape(params)
-          Hash[params.map { |k, v| [k, Rack::Utils.escape(v)] }]
+          params.transform_values { |v| Rack::Utils.escape(v) }
         end
 
         def escape_fragment(params)
-          Hash[params.map { |k, v| [k, Journey::Router::Utils.escape_fragment(v)] }]
+          params.transform_values { |v| Journey::Router::Utils.escape_fragment(v) }
         end
 
         def escape_path(params)
-          Hash[params.map { |k, v| [k, Journey::Router::Utils.escape_path(v)] }]
+          params.transform_values { |v| Journey::Router::Utils.escape_path(v) }
         end
     end
 

data/lib/action_dispatch/routing/route_set.rb

@@ -110,8 +110,10 @@ module ActionDispatch
             @url_helpers_module.undef_method url_name
           end
           routes[key] = route
-          define_url_helper @path_helpers_module, route, path_name, route.defaults, name, PATH
-          define_url_helper @url_helpers_module,  route, url_name,  route.defaults, name, UNKNOWN
+
+          helper = UrlHelper.create(route, route.defaults, name)
+          define_url_helper @path_helpers_module, path_name, helper, PATH
+          define_url_helper @url_helpers_module, url_name, helper, UNKNOWN
 
           @path_helpers << path_name
           @url_helpers << url_name
@@ -169,30 +171,30 @@ module ActionDispatch
         end
 
         class UrlHelper
-          def self.create(route, options, route_name, url_strategy)
+          def self.create(route, options, route_name)
             if optimize_helper?(route)
-              OptimizedUrlHelper.new(route, options, route_name, url_strategy)
+              OptimizedUrlHelper.new(route, options, route_name)
             else
-              new route, options, route_name, url_strategy
+              new(route, options, route_name)
             end
           end
 
           def self.optimize_helper?(route)
-            !route.glob? && route.path.requirements.empty?
+            route.path.requirements.empty? && !route.glob?
           end
 
-          attr_reader :url_strategy, :route_name
+          attr_reader :route_name
 
           class OptimizedUrlHelper < UrlHelper
             attr_reader :arg_size
 
-            def initialize(route, options, route_name, url_strategy)
+            def initialize(route, options, route_name)
               super
               @required_parts = @route.required_parts
               @arg_size       = @required_parts.size
             end
 
-            def call(t, args, inner_options)
+            def call(t, method_name, args, inner_options, url_strategy)
               if args.size == arg_size && !inner_options && optimize_routes_generation?(t)
                 options = t.url_options.merge @options
                 options[:path] = optimized_helper(args)
@@ -249,15 +251,14 @@ module ActionDispatch
               end
           end
 
-          def initialize(route, options, route_name, url_strategy)
+          def initialize(route, options, route_name)
             @options      = options
             @segment_keys = route.segment_keys.uniq
             @route        = route
-            @url_strategy = url_strategy
             @route_name   = route_name
           end
 
-          def call(t, args, inner_options)
+          def call(t, method_name, args, inner_options, url_strategy)
             controller_options = t.url_options
             options = controller_options.merge @options
             hash = handle_positional_args(controller_options,
@@ -266,7 +267,7 @@ module ActionDispatch
                                           options,
                                           @segment_keys)
 
-            t._routes.url_for(hash, route_name, url_strategy)
+            t._routes.url_for(hash, route_name, url_strategy, method_name)
           end
 
           def handle_positional_args(controller_options, inner_options, args, result, path_params)
@@ -312,8 +313,7 @@ module ActionDispatch
           #
           #   foo_url(bar, baz, bang, sort_by: 'baz')
           #
-          def define_url_helper(mod, route, name, opts, route_key, url_strategy)
-            helper = UrlHelper.create(route, opts, route_key, url_strategy)
+          def define_url_helper(mod, name, helper, url_strategy)
             mod.define_method(name) do |*args|
               last = args.last
               options = \
@@ -323,7 +323,7 @@ module ActionDispatch
                 when ActionController::Parameters
                   args.pop.to_h
                 end
-              helper.call self, args, options
+              helper.call(self, name, args, options, url_strategy)
             end
           end
       end
@@ -334,7 +334,7 @@ module ActionDispatch
 
       attr_accessor :formatter, :set, :named_routes, :default_scope, :router
       attr_accessor :disable_clear_and_finalize, :resources_path_names
-      attr_accessor :default_url_options
+      attr_accessor :default_url_options, :draw_paths
       attr_reader :env_key, :polymorphic_mappings
 
       alias :routes :set
@@ -366,6 +366,7 @@ module ActionDispatch
         self.named_routes = NamedRouteCollection.new
         self.resources_path_names = self.class.default_resources_path_names
         self.default_url_options = {}
+        self.draw_paths = []
 
         @config                     = config
         @append                     = []
@@ -476,6 +477,14 @@ module ActionDispatch
       end
 
       def url_helpers(supports_path = true)
+        if supports_path
+          @url_helpers_with_paths ||= generate_url_helpers(true)
+        else
+          @url_helpers_without_paths ||= generate_url_helpers(false)
+        end
+      end
+
+      def generate_url_helpers(supports_path)
         routes = self
 
         Module.new do
@@ -588,14 +597,14 @@ module ActionDispatch
         if route.segment_keys.include?(:controller)
           ActiveSupport::Deprecation.warn(<<-MSG.squish)
             Using a dynamic :controller segment in a route is deprecated and
-            will be removed in Rails 6.1.
+            will be removed in Rails 6.2.
           MSG
         end
 
         if route.segment_keys.include?(:action)
           ActiveSupport::Deprecation.warn(<<-MSG.squish)
             Using a dynamic :action segment in a route is deprecated and
-            will be removed in Rails 6.1.
+            will be removed in Rails 6.2.
           MSG
         end
 
@@ -641,14 +650,6 @@ module ActionDispatch
       end
 
       class Generator
-        PARAMETERIZE = lambda do |name, value|
-          if name == :controller
-            value
-          else
-            value.to_param
-          end
-        end
-
         attr_reader :options, :recall, :set, :named_route
 
         def initialize(named_route, options, recall, set)
@@ -732,10 +733,10 @@ module ActionDispatch
           end
         end
 
-        # Generates a path from routes, returns [path, params].
-        # If no route is generated the formatter will raise ActionController::UrlGenerationError
+        # Generates a path from routes, returns a RouteWithParams or MissingRoute.
+        # MissingRoute will raise ActionController::UrlGenerationError.
         def generate
-          @set.formatter.generate(named_route, options, recall, PARAMETERIZE)
+          @set.formatter.generate(named_route, options, recall)
         end
 
         def different_controller?
@@ -760,13 +761,18 @@ module ActionDispatch
       end
 
       def generate_extras(options, recall = {})
-        route_key = options.delete :use_route
-        path, params = generate(route_key, options, recall)
-        return path, params.keys
+        if recall
+          options = options.merge(_recall: recall)
+        end
+
+        route_name = options.delete :use_route
+        generator = generate(route_name, options, recall)
+        path_info = path_for(options, route_name, [])
+        [URI(path_info).path, generator.params.except(:_recall).keys]
       end
 
-      def generate(route_key, options, recall = {})
-        Generator.new(route_key, options, recall, self).generate
+      def generate(route_name, options, recall = {}, method_name = nil)
+        Generator.new(route_name, options, recall, self).generate
       end
       private :generate
 
@@ -786,12 +792,12 @@ module ActionDispatch
         options.delete(:relative_url_root) || relative_url_root
       end
 
-      def path_for(options, route_name = nil)
-        url_for(options, route_name, PATH)
+      def path_for(options, route_name = nil, reserved = RESERVED_OPTIONS)
+        url_for(options, route_name, PATH, nil, reserved)
       end
 
       # The +options+ argument must be a hash whose keys are *symbols*.
-      def url_for(options, route_name = nil, url_strategy = UNKNOWN)
+      def url_for(options, route_name = nil, url_strategy = UNKNOWN, method_name = nil, reserved = RESERVED_OPTIONS)
         options = default_url_options.merge options
 
         user = password = nil
@@ -811,9 +817,11 @@ module ActionDispatch
         end
 
         path_options = options.dup
-        RESERVED_OPTIONS.each { |ro| path_options.delete ro }
+        reserved.each { |ro| path_options.delete ro }
 
-        path, params = generate(route_name, path_options, recall)
+        route_with_params = generate(route_name, path_options, recall)
+        path = route_with_params.path(method_name)
+        params = route_with_params.params
 
         if options.key? :params
           params.merge! options[:params]
@@ -855,7 +863,7 @@ module ActionDispatch
           params.each do |key, value|
             if value.is_a?(String)
               value = value.dup.force_encoding(Encoding::BINARY)
-              params[key] = URI.parser.unescape(value)
+              params[key] = URI::DEFAULT_PARSER.unescape(value)
             end
           end
           req.path_parameters = params

data/lib/action_dispatch/routing/url_for.rb

@@ -107,6 +107,7 @@ module ActionDispatch
         @_routes = nil
         super
       end
+      ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
 
       # Hook overridden in controller to add request information
       # with +default_url_options+. Application logic should not

data/lib/action_dispatch/system_test_case.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-gem "capybara", ">= 2.15"
+gem "capybara", ">= 3.26"
 
 require "capybara/dsl"
 require "capybara/minitest"
-require "selenium/webdriver"
 require "action_controller"
 require "action_dispatch/system_testing/driver"
 require "action_dispatch/system_testing/browser"
@@ -27,7 +26,7 @@ module ActionDispatch
   #
   # Here is an example system test:
   #
-  #   require 'application_system_test_case'
+  #   require "application_system_test_case"
   #
   #   class Users::CreateTest < ApplicationSystemTestCase
   #     test "adding a new user" do
@@ -120,18 +119,6 @@ module ActionDispatch
       super
       self.class.driven_by(:selenium) unless self.class.driver?
       self.class.driver.use
-      @proxy_route = if ActionDispatch.test_app
-        Class.new do
-          include ActionDispatch.test_app.routes.url_helpers
-          include ActionDispatch.test_app.routes.mounted_helpers
-
-          def url_options
-            default_url_options.merge(host: Capybara.app_host)
-          end
-        end.new
-      else
-        nil
-      end
     end
 
     def self.start_application # :nodoc:
@@ -170,16 +157,34 @@ module ActionDispatch
       self.driver = SystemTesting::Driver.new(driver, **driver_options, &capabilities)
     end
 
-    def method_missing(method, *args, &block)
-      if @proxy_route.respond_to?(method)
-        @proxy_route.send(method, *args, &block)
-      else
-        super
+    private
+      def url_helpers
+        @url_helpers ||=
+          if ActionDispatch.test_app
+            Class.new do
+              include ActionDispatch.test_app.routes.url_helpers
+              include ActionDispatch.test_app.routes.mounted_helpers
+
+              def url_options
+                default_url_options.reverse_merge(host: Capybara.app_host || Capybara.current_session.server_url)
+              end
+            end.new
+          end
       end
-    end
 
-    ActiveSupport.run_load_hooks(:action_dispatch_system_test_case, self)
-  end
+      def method_missing(name, *args, &block)
+        if url_helpers.respond_to?(name)
+          url_helpers.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
 
-  SystemTestCase.start_application
+      def respond_to_missing?(name, include_private = false)
+        url_helpers.respond_to?(name)
+      end
+  end
 end
+
+ActiveSupport.run_load_hooks :action_dispatch_system_test_case, ActionDispatch::SystemTestCase
+ActionDispatch::SystemTestCase.start_application

data/lib/action_dispatch/system_testing/browser.rb

@@ -3,10 +3,11 @@
 module ActionDispatch
   module SystemTesting
     class Browser # :nodoc:
-      attr_reader :name
+      attr_reader :name, :options
 
       def initialize(name)
         @name = name
+        set_default_options
       end
 
       def type
@@ -20,23 +21,9 @@ module ActionDispatch
         end
       end
 
-      def options
-        case name
-        when :headless_chrome
-          headless_chrome_browser_options
-        when :headless_firefox
-          headless_firefox_browser_options
-        end
-      end
-
-      def capabilities
-        @option ||=
-          case type
-          when :chrome
-            ::Selenium::WebDriver::Chrome::Options.new
-          when :firefox
-            ::Selenium::WebDriver::Firefox::Options.new
-          end
+      def configure
+        initialize_options
+        yield options if block_given? && options
       end
 
       # driver_path can be configured as a proc. The webdrivers gem uses this
@@ -47,14 +34,14 @@ module ActionDispatch
         case type
         when :chrome
           if ::Selenium::WebDriver::Service.respond_to? :driver_path=
-            ::Selenium::WebDriver::Chrome::Service.driver_path.try(:call)
+            ::Selenium::WebDriver::Chrome::Service.driver_path&.call
           else
             # Selenium <= v3.141.0
             ::Selenium::WebDriver::Chrome.driver_path
           end
         when :firefox
           if ::Selenium::WebDriver::Service.respond_to? :driver_path=
-            ::Selenium::WebDriver::Firefox::Service.driver_path.try(:call)
+            ::Selenium::WebDriver::Firefox::Service.driver_path&.call
           else
             # Selenium <= v3.141.0
             ::Selenium::WebDriver::Firefox.driver_path
@@ -63,17 +50,36 @@ module ActionDispatch
       end
 
       private
-        def headless_chrome_browser_options
-          capabilities.args << "--headless"
-          capabilities.args << "--disable-gpu" if Gem.win_platform?
+        def initialize_options
+          @options ||=
+            case type
+            when :chrome
+              ::Selenium::WebDriver::Chrome::Options.new
+            when :firefox
+              ::Selenium::WebDriver::Firefox::Options.new
+            end
+        end
 
-          capabilities
+        def set_default_options
+          case name
+          when :headless_chrome
+            set_headless_chrome_browser_options
+          when :headless_firefox
+            set_headless_firefox_browser_options
+          end
         end
 
-        def headless_firefox_browser_options
-          capabilities.args << "-headless"
+        def set_headless_chrome_browser_options
+          configure do |capabilities|
+            capabilities.args << "--headless"
+            capabilities.args << "--disable-gpu" if Gem.win_platform?
+          end
+        end
 
-          capabilities
+        def set_headless_firefox_browser_options
+          configure do |capabilities|
+            capabilities.args << "-headless"
+          end
         end
     end
   end