actionpack 6.0.3 → 6.1.0.rc1

data/lib/action_dispatch/journey.rb

@@ -3,5 +3,3 @@
 require "action_dispatch/journey/router"
 require "action_dispatch/journey/gtg/builder"
 require "action_dispatch/journey/gtg/simulator"
-require "action_dispatch/journey/nfa/builder"
-require "action_dispatch/journey/nfa/simulator"

data/lib/action_dispatch/journey/formatter.rb

@@ -15,12 +15,53 @@ 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)
         constraints = path_parameters.merge(options)
         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
@@ -44,17 +85,13 @@ module ActionDispatch
             parameterized_parts.delete(key)
           end
 
-          return [route.format(parameterized_parts), params]
+          return RouteWithParams.new(route, parameterized_parts, params)
         end
 
         unmatched_keys = (missing_keys || []) & constraints.keys
         missing_keys = (missing_keys || []) - unmatched_keys
 
-        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?
-
-        raise ActionController::UrlGenerationError, message
+        MissingRoute.new(constraints, missing_keys, unmatched_keys, routes, name)
       end
 
       def clear
@@ -62,7 +99,7 @@ module ActionDispatch
       end
 
       private
-        def extract_parameterized_parts(route, options, recall, parameterize = nil)
+        def extract_parameterized_parts(route, options, recall)
           parameterized_parts = recall.merge(options)
 
           keys_to_keep = route.parts.reverse_each.drop_while { |part|
@@ -73,9 +110,11 @@ module ActionDispatch
             !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
 
@@ -125,19 +164,10 @@ module ActionDispatch
           routes
         end
 
-        module RegexCaseComparator
-          DEFAULT_INPUT = /[-_.a-zA-Z0-9]+\/[-_.a-zA-Z0-9]+/
-          DEFAULT_REGEX = /\A#{DEFAULT_INPUT}\Z/
-
-          def self.===(regex)
-            DEFAULT_INPUT == regex
-          end
-        end
-
         # Returns an array populated with missing keys if any are present.
         def missing_keys(route, parts)
           missing_keys = nil
-          tests = route.path.requirements
+          tests = route.path.requirements_for_missing_keys_check
           route.required_parts.each { |key|
             case tests[key]
             when nil
@@ -145,13 +175,8 @@ module ActionDispatch
                 missing_keys ||= []
                 missing_keys << key
               end
-            when RegexCaseComparator
-              unless RegexCaseComparator::DEFAULT_REGEX === parts[key]
-                missing_keys ||= []
-                missing_keys << key
-              end
             else
-              unless /\A#{tests[key]}\Z/ === parts[key]
+              unless tests[key].match?(parts[key])
                 missing_keys ||= []
                 missing_keys << key
               end

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

@@ -13,45 +13,44 @@ module ActionDispatch
         def initialize(root)
           @root      = root
           @ast       = Nodes::Cat.new root, DUMMY
-          @followpos = nil
+          @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] }
               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 }
+                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
+                to = state_id[u]
+                dtrans[from, to] = sym
 
                 if u.include?(DUMMY)
-                  to = state_id[u]
-
-                  accepting = ps.find_all { |l| followpos(l).include?(DUMMY) }
-
-                  accepting.each { |accepting_state|
-                    dtrans.add_memo(to, accepting_state.memo)
-                  }
+                  ps.each do |state|
+                    if @followpos[state].include?(DUMMY)
+                      dtrans.add_memo(to, state.memo)
+                    end
+                  end
 
-                  dtrans.add_accepting(state_id[u])
+                  dtrans.add_accepting(to)
                 end
               end
 
@@ -92,7 +91,7 @@ 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
@@ -107,7 +106,7 @@ module ActionDispatch
           when Nodes::Star
             firstpos(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)
@@ -123,17 +122,9 @@ module ActionDispatch
           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
@@ -150,12 +141,7 @@ module ActionDispatch
           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

@@ -14,6 +14,8 @@ module ActionDispatch
       end
 
       class Simulator # :nodoc:
+        INITIAL_STATE = [0].freeze
+
         attr_reader :tt
 
         def initialize(transition_table)
@@ -22,18 +24,17 @@ module ActionDispatch
 
         def memos(string)
           input = StringScanner.new(string)
-          state = [0]
+          state = INITIAL_STATE
+
           while sym = input.scan(%r([/.?]|[^/.?]+))
             state = tt.move(state, sym)
           end
 
-          acceptance_states = state.find_all { |s|
-            tt.accepting? s
-          }
-
-          return yield if acceptance_states.empty?
+          acceptance_states = state.each_with_object([]) do |s, memos|
+            memos.concat(tt.memo(s)) if tt.accepting?(s)
+          end
 
-          acceptance_states.flat_map { |x| tt.memo(x) }.compact
+          acceptance_states.empty? ? yield : acceptance_states
         end
       end
     end

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

@@ -45,16 +45,18 @@ module ActionDispatch
           return [] if t.empty?
 
           regexps = []
+          strings = []
 
-          t.map { |s|
+          t.each { |s|
             if states = @regexp_states[s]
-              regexps.concat states.map { |re, v| re === a ? v : nil }
+              states.each { |re, v| regexps << v if re.match?(a) && !v.nil? }
             end
 
             if states = @string_states[s]
-              states[a]
+              strings << states[a] unless states[a].nil?
             end
-          }.compact.concat regexps
+          }
+          strings.concat regexps
         end
 
         def as_json(options = nil)

data/lib/action_dispatch/journey/nfa/dot.rb

@@ -9,17 +9,6 @@ module ActionDispatch
             "  #{from} -> #{to} [label=\"#{sym || 'ε'}\"];"
           }
 
-          # memo_nodes = memos.values.flatten.map { |n|
-          #   label = n
-          #   if Journey::Route === n
-          #     label = "#{n.verb.source} #{n.path.spec}"
-          #   end
-          #   "  #{n.object_id} [label=\"#{label}\", shape=box];"
-          # }
-          # memo_edges = memos.flat_map { |k, memos|
-          #   (memos || []).map { |v| "  #{k} -> #{v.object_id};" }
-          # }.uniq
-
           <<-eodot
 digraph nfa {
   rankdir=LR;

data/lib/action_dispatch/journey/nodes/node.rb

@@ -79,9 +79,10 @@ module ActionDispatch
         attr_reader :name
 
         DEFAULT_EXP = /[^\.\/\?]+/
-        def initialize(left)
-          super
-          @regexp = DEFAULT_EXP
+        GREEDY_EXP = /(.+)/
+        def initialize(left, regexp = DEFAULT_EXP)
+          super(left)
+          @regexp = regexp
           @name = -left.tr("*:", "")
         end
 

data/lib/action_dispatch/journey/parser.rb

@@ -1,6 +1,6 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.14
+# This file is automatically generated by Racc 1.4.16
 # from Racc grammar file "".
 #
 
@@ -135,11 +135,11 @@ Racc_debug_parser = false
 # reduce 0 omitted
 
 def _reduce_1(val, _values)
- Cat.new(val.first, val.last) 
+ Cat.new(val.first, val.last)
 end
 
 def _reduce_2(val, _values)
- val.first 
+ val.first
 end
 
 # reduce 3 omitted
@@ -151,19 +151,19 @@ end
 # reduce 6 omitted
 
 def _reduce_7(val, _values)
- Group.new(val[1]) 
+ Group.new(val[1])
 end
 
 def _reduce_8(val, _values)
- Or.new([val.first, val.last]) 
+ Or.new([val.first, val.last])
 end
 
 def _reduce_9(val, _values)
- Or.new([val.first, val.last]) 
+ Or.new([val.first, val.last])
 end
 
 def _reduce_10(val, _values)
- Star.new(Symbol.new(val.last)) 
+ Star.new(Symbol.new(val.last, Symbol::GREEDY_EXP))
 end
 
 # reduce 11 omitted
@@ -175,19 +175,19 @@ end
 # reduce 14 omitted
 
 def _reduce_15(val, _values)
- Slash.new(val.first) 
+ Slash.new(val.first)
 end
 
 def _reduce_16(val, _values)
- Symbol.new(val.first) 
+ Symbol.new(val.first)
 end
 
 def _reduce_17(val, _values)
- Literal.new(val.first) 
+ Literal.new(val.first)
 end
 
 def _reduce_18(val, _values)
- Dot.new(val.first) 
+ Dot.new(val.first)
 end
 
 def _reduce_none(val, _values)
@@ -195,5 +195,5 @@ def _reduce_none(val, _values)
 end
 
     end   # class Parser
-    end   # module Journey
-  end   # module ActionDispatch
+  end   # module Journey
+end   # module ActionDispatch

data/lib/action_dispatch/journey/parser.y

@@ -21,7 +21,7 @@ rule
     | expression OR or { Or.new([val.first, val.last]) }
     ;
   star
-    : STAR       { Star.new(Symbol.new(val.last)) }
+    : STAR       { Star.new(Symbol.new(val.last, Symbol::GREEDY_EXP)) }
     ;
   terminal
     : symbol

data/lib/action_dispatch/journey/path/pattern.rb

@@ -6,16 +6,6 @@ module ActionDispatch
       class Pattern # :nodoc:
         attr_reader :spec, :requirements, :anchored
 
-        def self.from_string(string)
-          build(string, {}, "/.?", true)
-        end
-
-        def self.build(path, requirements, separators, anchored)
-          parser = Journey::Parser.new
-          ast = parser.parse path
-          new ast, requirements, separators, anchored
-        end
-
         def initialize(ast, requirements, separators, anchored)
           @spec         = ast
           @requirements = requirements
@@ -46,11 +36,6 @@ module ActionDispatch
             node.regexp = re if re
           end
 
-          @spec.find_all(&:star?).each do |node|
-            node = node.left
-            node.regexp = @requirements[node.to_sym] || /(.+)/
-          end
-
           @spec
         end
 
@@ -81,7 +66,7 @@ module ActionDispatch
           end
 
           def visit_CAT(node)
-            [visit(node.left), visit(node.right)].join
+            "#{visit(node.left)}#{visit(node.right)}"
           end
 
           def visit_SYMBOL(node)
@@ -107,8 +92,8 @@ module ActionDispatch
           end
 
           def visit_STAR(node)
-            re = @matchers[node.left.to_sym] || ".+"
-            "(#{re})"
+            re = @matchers[node.left.to_sym]
+            re ? "(#{re})" : "(.+)"
           end
 
           def visit_OR(node)
@@ -165,6 +150,10 @@ module ActionDispatch
         end
         alias :=~ :match
 
+        def match?(other)
+          to_regexp.match?(other)
+        end
+
         def source
           to_regexp.source
         end
@@ -173,6 +162,12 @@ module ActionDispatch
           @re ||= regexp_visitor.new(@separators, @requirements).accept spec
         end
 
+        def requirements_for_missing_keys_check
+          @requirements_for_missing_keys_check ||= requirements.transform_values do |regex|
+            /\A#{regex}\Z/
+          end
+        end
+
         private
           def regexp_visitor
             @anchored ? AnchoredRegexp : UnanchoredRegexp