actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_dispatch/journey/formatter.rb

@@ -1,11 +1,15 @@
-require 'action_controller/metal/exceptions'
-require 'active_support/deprecation'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_controller/metal/exceptions"
 
 module ActionDispatch
+  # :stopdoc:
   module Journey
     # The Formatter class is used for formatting URLs. For example, parameters
-    # passed to +url_for+ in Rails will eventually call Formatter#generate.
-    class Formatter # :nodoc:
+    # passed to `url_for` in Rails will eventually call Formatter#generate.
+    class Formatter
       attr_reader :routes
 
       def initialize(routes)
@@ -13,63 +17,121 @@ module ActionDispatch
         @cache  = nil
       end
 
-      def generate(name, options, path_parameters, parameterize = nil)
+      class RouteWithParams
+        attr_reader :params
+
+        def initialize(route, parameterized_parts, params)
+          @route = route
+          @parameterized_parts = parameterized_parts
+          @params = params
+        end
+
+        def path(_)
+          @route.format(@parameterized_parts)
+        end
+      end
+
+      class MissingRoute
+        attr_reader :routes, :name, :constraints, :missing_keys, :unmatched_keys
+
+        def initialize(constraints, missing_keys, unmatched_keys, routes, name)
+          @constraints = constraints
+          @missing_keys = missing_keys
+          @unmatched_keys = unmatched_keys
+          @routes = routes
+          @name = name
+        end
+
+        def path(method_name)
+          raise ActionController::UrlGenerationError.new(message, routes, name, method_name)
+        end
+
+        def params
+          path("unknown")
+        end
+
+        def message
+          message = +"No route matches #{Hash[constraints.sort_by { |k, v| k.to_s }].inspect}"
+          message << ", missing required keys: #{missing_keys.sort.inspect}" if missing_keys && !missing_keys.empty?
+          message << ", possible unmatched constraints: #{unmatched_keys.sort.inspect}" if unmatched_keys && !unmatched_keys.empty?
+          message
+        end
+      end
+
+      def generate(name, options, path_parameters)
+        original_options = options.dup
+        path_params = options.delete(:path_params) || {}
+        options = path_params.merge(options)
         constraints = path_parameters.merge(options)
-        missing_keys = []
+        missing_keys = nil
 
         match_route(name, constraints) do |route|
-          parameterized_parts = extract_parameterized_parts(route, options, path_parameters, parameterize)
+          parameterized_parts = extract_parameterized_parts(route, options, path_parameters)
 
-          # Skip this route unless a name has been provided or it is a
-          # standard Rails route since we can't determine whether an options
-          # hash passed to url_for matches a Rack application or a redirect.
+          # Skip this route unless a name has been provided or it is a standard Rails
+          # route since we can't determine whether an options hash passed to url_for
+          # matches a Rack application or a redirect.
           next unless name || route.dispatcher?
 
           missing_keys = missing_keys(route, parameterized_parts)
-          next unless missing_keys.empty?
-          params = options.dup.delete_if do |key, _|
-            parameterized_parts.key?(key) || route.defaults.key?(key)
+          next if missing_keys && !missing_keys.empty?
+          params = options.delete_if do |key, _|
+            # top-level params' normal behavior of generating query_params should be
+            # preserved even if the same key is also a bind_param
+            parameterized_parts.key?(key) || route.defaults.key?(key) ||
+              (path_params.key?(key) && !original_options.key?(key))
           end
 
           defaults       = route.defaults
           required_parts = route.required_parts
-          parameterized_parts.delete_if do |key, value|
-            value.to_s == defaults[key].to_s && !required_parts.include?(key)
+
+          route.parts.reverse_each do |key|
+            break if defaults[key].nil? && parameterized_parts[key].present?
+            next if parameterized_parts[key].to_s != defaults[key].to_s
+            break if required_parts.include?(key)
+
+            parameterized_parts.delete(key)
           end
 
-          return [route.format(parameterized_parts), params]
+          return RouteWithParams.new(route, parameterized_parts, params)
         end
 
-        message = "No route matches #{Hash[constraints.sort_by{|k,v| k.to_s}].inspect}"
-        message << " missing required keys: #{missing_keys.sort.inspect}" unless missing_keys.empty?
+        unmatched_keys = (missing_keys || []) & constraints.keys
+        missing_keys = (missing_keys || []) - unmatched_keys
 
-        raise ActionController::UrlGenerationError, message
+        MissingRoute.new(constraints, missing_keys, unmatched_keys, routes, name)
       end
 
       def clear
         @cache = nil
       end
 
-      private
+      def eager_load!
+        cache
+        nil
+      end
 
-        def extract_parameterized_parts(route, options, recall, parameterize = nil)
+      private
+        def extract_parameterized_parts(route, options, recall)
           parameterized_parts = recall.merge(options)
 
-          keys_to_keep = route.parts.reverse.drop_while { |part|
-            !options.key?(part) || (options[part] || recall[part]).nil?
+          keys_to_keep = route.parts.reverse_each.drop_while { |part|
+            !(options.key?(part) || route.scope_options.key?(part)) || (options[part].nil? && recall[part].nil?)
           } | route.required_parts
 
-          (parameterized_parts.keys - keys_to_keep).each do |bad_key|
-            parameterized_parts.delete(bad_key)
+          parameterized_parts.delete_if do |bad_key, _|
+            !keys_to_keep.include?(bad_key)
           end
 
-          if parameterize
-            parameterized_parts.each do |k, v|
-              parameterized_parts[k] = parameterize.call(k, v)
+          parameterized_parts.each do |k, v|
+            if k == :controller
+              parameterized_parts[k] = v
+            else
+              parameterized_parts[k] = v.to_param
             end
           end
 
-          parameterized_parts.keep_if { |_, v| v }
+          parameterized_parts.compact!
           parameterized_parts
         end
 
@@ -81,28 +143,18 @@ module ActionDispatch
           if named_routes.key?(name)
             yield named_routes[name]
           else
-            # Make sure we don't show the deprecation warning more than once
-            warned = false
-
             routes = non_recursive(cache, options)
 
-            hash = routes.group_by { |_, r| r.score(options) }
+            supplied_keys = options.each_with_object({}) do |(k, v), h|
+              h[k.to_s] = true if v
+            end
+
+            hash = routes.group_by { |_, r| r.score(supplied_keys) }
 
             hash.keys.sort.reverse_each do |score|
               break if score < 0
 
               hash[score].sort_by { |i, _| i }.each do |_, route|
-                if name && !warned
-                  ActiveSupport::Deprecation.warn <<-MSG.squish
-                    You are trying to generate the URL for a named route called
-                    #{name.inspect} but no such route was found. In the future,
-                    this will result in an `ActionController::UrlGenerationError`
-                    exception.
-                  MSG
-
-                  warned = true
-                end
-
                 yield route
               end
             end
@@ -127,13 +179,20 @@ module ActionDispatch
 
         # Returns an array populated with missing keys if any are present.
         def missing_keys(route, parts)
-          missing_keys = []
-          tests = route.path.requirements
+          missing_keys = nil
+          tests = route.path.requirements_for_missing_keys_check
           route.required_parts.each { |key|
-            if tests.key?(key)
-              missing_keys << key unless /\A#{tests[key]}\Z/ === parts[key]
+            case tests[key]
+            when nil
+              unless parts[key]
+                missing_keys ||= []
+                missing_keys << key
+              end
             else
-              missing_keys << key unless parts[key]
+              unless tests[key].match?(parts[key])
+                missing_keys ||= []
+                missing_keys << key
+              end
             end
           }
           missing_keys
@@ -149,7 +208,7 @@ module ActionDispatch
 
         def build_cache
           root = { ___routes: [] }
-          routes.each_with_index do |route, i|
+          routes.routes.each_with_index do |route, i|
             leaf = route.required_defaults.inject(root) do |h, tuple|
               h[tuple] ||= {}
             end
@@ -163,4 +222,5 @@ module ActionDispatch
         end
     end
   end
+  # :startdoc:
 end

data/lib/action_dispatch/journey/gtg/builder.rb

@@ -1,55 +1,58 @@
-require 'action_dispatch/journey/gtg/transition_table'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/journey/gtg/transition_table"
 
 module ActionDispatch
   module Journey # :nodoc:
     module GTG # :nodoc:
       class Builder # :nodoc:
-        DUMMY = Nodes::Dummy.new
+        DUMMY_END_NODE = Nodes::Dummy.new
 
         attr_reader :root, :ast, :endpoints
 
         def initialize(root)
           @root      = root
-          @ast       = Nodes::Cat.new root, DUMMY
-          @followpos = nil
+          @ast       = Nodes::Cat.new root, DUMMY_END_NODE
+          @followpos = build_followpos
         end
 
         def transition_table
           dtrans   = TransitionTable.new
-          marked   = {}
-          state_id = Hash.new { |h,k| h[k] = h.length }
+          marked   = {}.compare_by_identity
+          state_id = Hash.new { |h, k| h[k] = h.length }.compare_by_identity
+          dstates  = [firstpos(root)]
 
-          start   = firstpos(root)
-          dstates = [start]
           until dstates.empty?
             s = dstates.shift
             next if marked[s]
             marked[s] = true # mark s
 
             s.group_by { |state| symbol(state) }.each do |sym, ps|
-              u = ps.flat_map { |l| followpos(l) }
+              u = ps.flat_map { |l| @followpos[l] }.uniq
               next if u.empty?
 
-              if u.uniq == [DUMMY]
-                from = state_id[s]
-                to   = state_id[Object.new]
-                dtrans[from, to] = sym
+              from = state_id[s]
 
+              if u.all? { |pos| pos == DUMMY_END_NODE }
+                to = state_id[Object.new]
+                dtrans[from, to] = sym
                 dtrans.add_accepting(to)
+
                 ps.each { |state| dtrans.add_memo(to, state.memo) }
               else
-                dtrans[state_id[s], state_id[u]] = sym
-
-                if u.include?(DUMMY)
-                  to = state_id[u]
-
-                  accepting = ps.find_all { |l| followpos(l).include?(DUMMY) }
+                to = state_id[u]
+                dtrans[from, to] = sym
 
-                  accepting.each { |accepting_state|
-                    dtrans.add_memo(to, accepting_state.memo)
-                  }
+                if u.include?(DUMMY_END_NODE)
+                  ps.each do |state|
+                    if @followpos[state].include?(DUMMY_END_NODE)
+                      dtrans.add_memo(to, state.memo)
+                    end
+                  end
 
-                  dtrans.add_accepting(state_id[u])
+                  dtrans.add_accepting(to)
                 end
               end
 
@@ -65,7 +68,9 @@ module ActionDispatch
           when Nodes::Group
             true
           when Nodes::Star
-            true
+            # the default star regex is /(.+)/ which is NOT nullable but since different
+            # constraints can be provided we must actually check if this is the case or not.
+            node.regexp.match?("")
           when Nodes::Or
             node.children.any? { |c| nullable?(c) }
           when Nodes::Cat
@@ -75,7 +80,7 @@ module ActionDispatch
           when Nodes::Unary
             nullable?(node.left)
           else
-            raise ArgumentError, 'unknown nullable: %s' % node.class.name
+            raise ArgumentError, "unknown nullable: %s" % node.class.name
           end
         end
 
@@ -90,22 +95,22 @@ module ActionDispatch
               firstpos(node.left)
             end
           when Nodes::Or
-            node.children.flat_map { |c| firstpos(c) }.uniq
+            node.children.flat_map { |c| firstpos(c) }.tap(&:uniq!)
           when Nodes::Unary
             firstpos(node.left)
           when Nodes::Terminal
             nullable?(node) ? [] : [node]
           else
-            raise ArgumentError, 'unknown firstpos: %s' % node.class.name
+            raise ArgumentError, "unknown firstpos: %s" % node.class.name
           end
         end
 
         def lastpos(node)
           case node
           when Nodes::Star
-            firstpos(node.left)
+            lastpos(node.left)
           when Nodes::Or
-            node.children.flat_map { |c| lastpos(c) }.uniq
+            node.children.flat_map { |c| lastpos(c) }.tap(&:uniq!)
           when Nodes::Cat
             if nullable?(node.right)
               lastpos(node.left) | lastpos(node.right)
@@ -117,44 +122,26 @@ module ActionDispatch
           when Nodes::Unary
             lastpos(node.left)
           else
-            raise ArgumentError, 'unknown lastpos: %s' % node.class.name
+            raise ArgumentError, "unknown lastpos: %s" % node.class.name
           end
         end
 
-        def followpos(node)
-          followpos_table[node]
-        end
-
         private
-
-          def followpos_table
-            @followpos ||= build_followpos
-          end
-
           def build_followpos
-            table = Hash.new { |h, k| h[k] = [] }
+            table = Hash.new { |h, k| h[k] = [] }.compare_by_identity
             @ast.each do |n|
               case n
               when Nodes::Cat
                 lastpos(n.left).each do |i|
                   table[i] += firstpos(n.right)
                 end
-              when Nodes::Star
-                lastpos(n).each do |i|
-                  table[i] += firstpos(n)
-                end
               end
             end
             table
           end
 
           def symbol(edge)
-            case edge
-            when Journey::Nodes::Symbol
-              edge.regexp
-            else
-              edge.left
-            end
+            edge.symbol? ? edge.regexp : edge.left
           end
       end
     end

data/lib/action_dispatch/journey/gtg/simulator.rb

@@ -1,4 +1,8 @@
-require 'strscan'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "strscan"
 
 module ActionDispatch
   module Journey # :nodoc:
@@ -12,34 +16,33 @@ module ActionDispatch
       end
 
       class Simulator # :nodoc:
+        INITIAL_STATE = [ [0, nil] ].freeze
+
         attr_reader :tt
 
         def initialize(transition_table)
           @tt = transition_table
         end
 
-        def simulate(string)
-          ms = memos(string) { return }
-          MatchData.new(ms)
-        end
-
-        alias :=~    :simulate
-        alias :match :simulate
-
         def memos(string)
           input = StringScanner.new(string)
-          state = [0]
+          state = INITIAL_STATE
+          start_index = 0
+
           while sym = input.scan(%r([/.?]|[^/.?]+))
-            state = tt.move(state, sym)
-          end
+            end_index = start_index + sym.length
 
-          acceptance_states = state.find_all { |s|
-            tt.accepting? s
-          }
+            state = tt.move(state, string, start_index, end_index)
 
-          return yield if acceptance_states.empty?
+            start_index = end_index
+          end
+
+          acceptance_states = state.each_with_object([]) do |s_d, memos|
+            s, idx = s_d
+            memos.concat(tt.memo(s)) if idx.nil? && tt.accepting?(s)
+          end
 
-          acceptance_states.flat_map { |x| tt.memo(x) }.compact
+          acceptance_states.empty? ? yield : acceptance_states
         end
       end
     end