actionpack 4.2.11.3 → 5.0.7.2

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

@@ -1,5 +1,3 @@
-require 'action_dispatch/journey/router/strexp'
-
 module ActionDispatch
   module Journey # :nodoc:
     module Path # :nodoc:
@@ -7,14 +5,20 @@ module ActionDispatch
         attr_reader :spec, :requirements, :anchored
 
         def self.from_string string
-          new Journey::Router::Strexp.build(string, {}, ["/.?"], true)
+          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(strexp)
-          @spec         = strexp.ast
-          @requirements = strexp.requirements
-          @separators   = strexp.separators.join
-          @anchored     = strexp.anchor
+        def initialize(ast, requirements, separators, anchored)
+          @spec         = ast
+          @requirements = requirements
+          @separators   = separators
+          @anchored     = anchored
 
           @names          = nil
           @optional_names = nil
@@ -28,12 +32,12 @@ module ActionDispatch
         end
 
         def ast
-          @spec.grep(Nodes::Symbol).each do |node|
+          @spec.find_all(&:symbol?).each do |node|
             re = @requirements[node.to_sym]
             node.regexp = re if re
           end
 
-          @spec.grep(Nodes::Star).each do |node|
+          @spec.find_all(&:star?).each do |node|
             node = node.left
             node.regexp = @requirements[node.to_sym] || /(.+)/
           end
@@ -42,7 +46,7 @@ module ActionDispatch
         end
 
         def names
-          @names ||= spec.grep(Nodes::Symbol).map { |n| n.name }
+          @names ||= spec.find_all(&:symbol?).map(&:name)
         end
 
         def required_names
@@ -50,34 +54,9 @@ module ActionDispatch
         end
 
         def optional_names
-          @optional_names ||= spec.grep(Nodes::Group).flat_map { |group|
-            group.grep(Nodes::Symbol)
-          }.map { |n| n.name }.uniq
-        end
-
-        class RegexpOffsets < Journey::Visitors::Visitor # :nodoc:
-          attr_reader :offsets
-
-          def initialize(matchers)
-            @matchers      = matchers
-            @capture_count = [0]
-          end
-
-          def visit(node)
-            super
-            @capture_count
-          end
-
-          def visit_SYMBOL(node)
-            node = node.to_sym
-
-            if @matchers.key?(node)
-              re = /#{@matchers[node]}|/
-              @capture_count.push((re.match('').length - 1) + (@capture_count.last || 0))
-            else
-              @capture_count << (@capture_count.last || 0)
-            end
-          end
+          @optional_names ||= spec.find_all(&:group?).flat_map { |group|
+            group.find_all(&:symbol?)
+          }.map(&:name).uniq
         end
 
         class AnchoredRegexp < Journey::Visitors::Visitor # :nodoc:
@@ -122,6 +101,11 @@ module ActionDispatch
             re = @matchers[node.left.to_sym] || '.+'
             "(#{re})"
           end
+
+          def visit_OR(node)
+            children = node.children.map { |n| visit n }
+            "(?:#{children.join(?|)})"
+          end
         end
 
         class UnanchoredRegexp < AnchoredRegexp # :nodoc:
@@ -140,7 +124,7 @@ module ActionDispatch
           end
 
           def captures
-            (length - 1).times.map { |i| self[i + 1] }
+            Array.new(length - 1) { |i| self[i + 1] }
           end
 
           def [](x)
@@ -184,8 +168,20 @@ module ActionDispatch
           def offsets
             return @offsets if @offsets
 
-            viz = RegexpOffsets.new(@requirements)
-            @offsets = viz.accept(spec)
+            @offsets = [0]
+
+            spec.find_all(&:symbol?).each do |node|
+              node = node.to_sym
+
+              if @requirements.key?(node)
+                re = /#{@requirements[node]}|/
+                @offsets.push((re.match('').length - 1) + @offsets.last)
+              else
+                @offsets << @offsets.last
+              end
+            end
+
+            @offsets
           end
       end
     end

data/lib/action_dispatch/journey/route.rb

@@ -1,41 +1,89 @@
 module ActionDispatch
-  module Journey # :nodoc:
-    class Route # :nodoc:
-      attr_reader :app, :path, :defaults, :name
+  # :stopdoc:
+  module Journey
+    class Route
+      attr_reader :app, :path, :defaults, :name, :precedence
 
-      attr_reader :constraints
+      attr_reader :constraints, :internal
       alias :conditions :constraints
 
-      attr_accessor :precedence
+      module VerbMatchers
+        VERBS = %w{ DELETE GET HEAD OPTIONS LINK PATCH POST PUT TRACE UNLINK }
+        VERBS.each do |v|
+          class_eval <<-eoc
+          class #{v}
+            def self.verb; name.split("::").last; end
+            def self.call(req); req.#{v.downcase}?; end
+          end
+          eoc
+        end
+
+        class Unknown
+          attr_reader :verb
+
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def call(request); @verb === request.request_method; end
+        end
+
+        class All
+          def self.call(_); true; end
+          def self.verb; ''; end
+        end
+
+        VERB_TO_CLASS = VERBS.each_with_object({ :all => All }) do |verb, hash|
+          klass = const_get verb
+          hash[verb]                 = klass
+          hash[verb.downcase]        = klass
+          hash[verb.downcase.to_sym] = klass
+        end
+
+      end
+
+      def self.verb_matcher(verb)
+        VerbMatchers::VERB_TO_CLASS.fetch(verb) do
+          VerbMatchers::Unknown.new verb.to_s.dasherize.upcase
+        end
+      end
+
+      def self.build(name, app, path, constraints, required_defaults, defaults)
+        request_method_match = verb_matcher(constraints.delete(:request_method))
+        new name, app, path, constraints, required_defaults, defaults, request_method_match, 0
+      end
 
       ##
       # +path+ is a path constraint.
       # +constraints+ is a hash of constraints to be applied to this route.
-      def initialize(name, app, path, constraints, defaults = {})
+      def initialize(name, app, path, constraints, required_defaults, defaults, request_method_match, precedence, internal = false)
         @name        = name
         @app         = app
         @path        = path
 
+        @request_method_match = request_method_match
         @constraints = constraints
         @defaults    = defaults
         @required_defaults = nil
+        @_required_defaults = required_defaults
         @required_parts    = nil
         @parts             = nil
         @decorated_ast     = nil
-        @precedence        = 0
+        @precedence        = precedence
         @path_formatter    = @path.build_formatter
+        @internal          = internal
       end
 
       def ast
         @decorated_ast ||= begin
           decorated_ast = path.ast
-          decorated_ast.grep(Nodes::Terminal).each { |n| n.memo = self }
+          decorated_ast.find_all(&:terminal?).each { |n| n.memo = self }
           decorated_ast
         end
       end
 
-      def requirements # :nodoc:
-        # needed for rails `rake routes`
+      def requirements
+        # needed for rails `rails routes`
         @defaults.merge(path.requirements).delete_if { |_,v|
           /.+?/ == v
         }
@@ -49,18 +97,23 @@ module ActionDispatch
         required_parts + required_defaults.keys
       end
 
-      def score(constraints)
+      def score(supplied_keys)
         required_keys = path.required_names
-        supplied_keys = constraints.map { |k,v| v && k.to_s }.compact
 
-        return -1 unless (required_keys - supplied_keys).empty?
+        required_keys.each do |k|
+          return -1 unless supplied_keys.include?(k)
+        end
+
+        score = 0
+        path.names.each do |k|
+          score += 1 if supplied_keys.include?(k)
+        end
 
-        score = (supplied_keys & path.names).length
         score + (required_defaults.length * 2)
       end
 
       def parts
-        @parts ||= segments.map { |n| n.to_sym }
+        @parts ||= segments.map(&:to_sym)
       end
       alias :segment_keys :parts
 
@@ -68,16 +121,12 @@ module ActionDispatch
         @path_formatter.evaluate path_options
       end
 
-      def optional_parts
-        path.optional_names.map { |n| n.to_sym }
-      end
-
       def required_parts
-        @required_parts ||= path.required_names.map { |n| n.to_sym }
+        @required_parts ||= path.required_names.map(&:to_sym)
       end
 
       def required_default?(key)
-        (constraints[:required_defaults] || []).include?(key)
+        @_required_defaults.include?(key)
       end
 
       def required_defaults
@@ -95,9 +144,8 @@ module ActionDispatch
       end
 
       def matches?(request)
-        constraints.all? do |method, value|
-          next true unless request.respond_to?(method)
-
+        match_verb(request) &&
+        constraints.all? { |method, value|
           case value
           when Regexp, String
             value === request.send(method).to_s
@@ -110,16 +158,30 @@ module ActionDispatch
           else
             value === request.send(method)
           end
-        end
+        }
       end
 
       def ip
         constraints[:ip] || //
       end
 
+      def requires_matching_verb?
+        !@request_method_match.all? { |x| x == VerbMatchers::All }
+      end
+
       def verb
-        constraints[:request_method] || //
+        verbs.join('|')
+      end
+
+      private
+      def verbs
+        @request_method_match.map(&:verb)
+      end
+
+      def match_verb(request)
+        @request_method_match.any? { |m| m.call request }
       end
     end
   end
+  # :startdoc:
 end

data/lib/action_dispatch/journey/router/utils.rb

@@ -13,11 +13,11 @@ module ActionDispatch
         #   normalize_path("")      # => "/"
         #   normalize_path("/%ab")  # => "/%AB"
         def self.normalize_path(path)
-          path = "/#{path}".force_encoding(Encoding::UTF_8)
-          path.squeeze!('/')
-          path.sub!(%r{/+\Z}, '')
+          path = "/#{path}"
+          path.squeeze!('/'.freeze)
+          path.sub!(%r{/+\Z}, ''.freeze)
           path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
-          path = '/' if path == ''
+          path = '/' if path == ''.freeze
           path
         end
 
@@ -55,7 +55,7 @@ module ActionDispatch
 
           def unescape_uri(uri)
             encoding = uri.encoding == US_ASCII ? UTF_8 : uri.encoding
-            uri.gsub(ESCAPED) { [$&[1, 2].hex].pack('C') }.force_encoding(encoding)
+            uri.gsub(ESCAPED) { |match| [match[1, 2].hex].pack('C') }.force_encoding(encoding)
           end
 
           protected

data/lib/action_dispatch/journey/router.rb

@@ -1,5 +1,4 @@
 require 'action_dispatch/journey/router/utils'
-require 'action_dispatch/journey/router/strexp'
 require 'action_dispatch/journey/routes'
 require 'action_dispatch/journey/formatter'
 
@@ -17,9 +16,6 @@ module ActionDispatch
       class RoutingError < ::StandardError # :nodoc:
       end
 
-      # :nodoc:
-      VERSION = '2.0.0'
-
       attr_accessor :routes
 
       def initialize(routes)
@@ -68,15 +64,17 @@ module ActionDispatch
 
       def visualizer
         tt     = GTG::Builder.new(ast).transition_table
-        groups = partitioned_routes.first.map(&:ast).group_by { |a| a.to_s }
-        asts   = groups.values.map { |v| v.first }
+        groups = partitioned_routes.first.map(&:ast).group_by(&:to_s)
+        asts   = groups.values.map(&:first)
         tt.visualizer(asts)
       end
 
       private
 
         def partitioned_routes
-          routes.partitioned_routes
+          routes.partition { |r|
+            r.path.anchored && r.ast.grep(Nodes::Symbol).all? { |n| n.default_regexp?  }
+          }
         end
 
         def ast
@@ -88,7 +86,7 @@ module ActionDispatch
         end
 
         def custom_routes
-          partitioned_routes.last
+          routes.custom_routes
         end
 
         def filter_routes(path)
@@ -102,7 +100,7 @@ module ActionDispatch
           }
 
           routes =
-            if req.request_method == "HEAD"
+            if req.head?
               match_head_routes(routes, req)
             else
               match_routes(routes, req)
@@ -121,7 +119,7 @@ module ActionDispatch
         end
 
         def match_head_routes(routes, req)
-          verb_specific_routes = routes.reject { |route| route.verb == // }
+          verb_specific_routes = routes.select(&:requires_matching_verb?)
           head_routes = match_routes(verb_specific_routes, req)
 
           if head_routes.empty?

data/lib/action_dispatch/journey/routes.rb

@@ -5,13 +5,13 @@ module ActionDispatch
     class Routes # :nodoc:
       include Enumerable
 
-      attr_reader :routes, :named_routes
+      attr_reader :routes, :custom_routes, :anchored_routes
 
       def initialize
         @routes             = []
-        @named_routes       = {}
         @ast                = nil
-        @partitioned_routes = nil
+        @anchored_routes    = []
+        @custom_routes      = []
         @simulator          = nil
       end
 
@@ -34,18 +34,21 @@ module ActionDispatch
 
       def clear
         routes.clear
-        named_routes.clear
+        anchored_routes.clear
+        custom_routes.clear
       end
 
-      def partitioned_routes
-        @partitioned_routes ||= routes.partition do |r|
-          r.path.anchored && r.ast.grep(Nodes::Symbol).all?(&:default_regexp?)
+      def partition_route(route)
+        if route.path.anchored && route.ast.grep(Nodes::Symbol).all?(&:default_regexp?)
+          anchored_routes << route
+        else
+          custom_routes << route
         end
       end
 
       def ast
         @ast ||= begin
-          asts = partitioned_routes.first.map(&:ast)
+          asts = anchored_routes.map(&:ast)
           Nodes::Or.new(asts) unless asts.empty?
         end
       end
@@ -57,13 +60,10 @@ module ActionDispatch
         end
       end
 
-      # Add a route to the routing table.
-      def add_route(app, path, conditions, defaults, name = nil)
-        route = Route.new(name, app, path, conditions, defaults)
-
-        route.precedence = routes.length
+      def add_route(name, mapping)
+        route = mapping.make_route name, routes.length
         routes << route
-        named_routes[name] = route if name && !named_routes[name]
+        partition_route(route)
         clear_cache!
         route
       end
@@ -72,7 +72,6 @@ module ActionDispatch
 
         def clear_cache!
           @ast                = nil
-          @partitioned_routes = nil
           @simulator          = nil
         end
     end

data/lib/action_dispatch/journey/visitors.rb

@@ -1,7 +1,6 @@
-# encoding: utf-8
-
 module ActionDispatch
-  module Journey # :nodoc:
+  # :stopdoc:
+  module Journey
     class Format
       ESCAPE_PATH    = ->(value) { Router::Utils.escape_path(value) }
       ESCAPE_SEGMENT = ->(value) { Router::Utils.escape_segment(value) }
@@ -92,6 +91,45 @@ module ActionDispatch
           end
       end
 
+      class FunctionalVisitor # :nodoc:
+        DISPATCH_CACHE = {}
+
+        def accept(node, seed)
+          visit(node, seed)
+        end
+
+        def visit node, seed
+          send(DISPATCH_CACHE[node.type], node, seed)
+        end
+
+        def binary(node, seed)
+          visit(node.right, visit(node.left, seed))
+        end
+        def visit_CAT(n, seed); binary(n, seed); end
+
+        def nary(node, seed)
+          node.children.inject(seed) { |s, c| visit(c, s) }
+        end
+        def visit_OR(n, seed); nary(n, seed); end
+
+        def unary(node, seed)
+          visit(node.left, seed)
+        end
+        def visit_GROUP(n, seed); unary(n, seed); end
+        def visit_STAR(n, seed); unary(n, seed); end
+
+        def terminal(node, seed);   seed; end
+        def visit_LITERAL(n, seed); terminal(n, seed); end
+        def visit_SYMBOL(n, seed);  terminal(n, seed); end
+        def visit_SLASH(n, seed);   terminal(n, seed); end
+        def visit_DOT(n, seed);     terminal(n, seed); end
+
+        instance_methods(false).each do |pim|
+          next unless pim =~ /^visit_(.*)$/
+          DISPATCH_CACHE[$1.to_sym] = pim
+        end
+      end
+
       class FormatBuilder < Visitor # :nodoc:
         def accept(node); Journey::Format.new(super); end
         def terminal(node); [node.left]; end
@@ -117,105 +155,112 @@ module ActionDispatch
       end
 
       # Loop through the requirements AST
-      class Each < Visitor # :nodoc:
-        attr_reader :block
-
-        def initialize(block)
-          @block = block
-        end
-
-        def visit(node)
+      class Each < FunctionalVisitor # :nodoc:
+        def visit(node, block)
           block.call(node)
           super
         end
+
+        INSTANCE = new
       end
 
-      class String < Visitor # :nodoc:
+      class String < FunctionalVisitor # :nodoc:
         private
 
-        def binary(node)
-          [visit(node.left), visit(node.right)].join
+        def binary(node, seed)
+          visit(node.right, visit(node.left, seed))
         end
 
-        def nary(node)
-          node.children.map { |c| visit(c) }.join '|'
+        def nary(node, seed)
+          last_child = node.children.last
+          node.children.inject(seed) { |s, c|
+            string = visit(c, s)
+            string << "|".freeze unless last_child == c
+            string
+          }
         end
 
-        def terminal(node)
-          node.left
+        def terminal(node, seed)
+          seed + node.left
         end
 
-        def visit_GROUP(node)
-          "(#{visit(node.left)})"
+        def visit_GROUP(node, seed)
+          visit(node.left, seed << "(".freeze) << ")".freeze
         end
+
+        INSTANCE = new
       end
 
-      class Dot < Visitor # :nodoc:
+      class Dot < FunctionalVisitor # :nodoc:
         def initialize
           @nodes = []
           @edges = []
         end
 
-        def accept(node)
+        def accept(node, seed = [[], []])
           super
+          nodes, edges = seed
           <<-eodot
   digraph parse_tree {
     size="8,5"
     node [shape = none];
     edge [dir = none];
-    #{@nodes.join "\n"}
-    #{@edges.join("\n")}
+    #{nodes.join "\n"}
+    #{edges.join("\n")}
   }
           eodot
         end
 
         private
 
-          def binary(node)
-            node.children.each do |c|
-              @edges << "#{node.object_id} -> #{c.object_id};"
-            end
+          def binary(node, seed)
+            seed.last.concat node.children.map { |c|
+              "#{node.object_id} -> #{c.object_id};"
+            }
             super
           end
 
-          def nary(node)
-            node.children.each do |c|
-              @edges << "#{node.object_id} -> #{c.object_id};"
-            end
+          def nary(node, seed)
+            seed.last.concat node.children.map { |c|
+              "#{node.object_id} -> #{c.object_id};"
+            }
             super
           end
 
-          def unary(node)
-            @edges << "#{node.object_id} -> #{node.left.object_id};"
+          def unary(node, seed)
+            seed.last << "#{node.object_id} -> #{node.left.object_id};"
             super
           end
 
-          def visit_GROUP(node)
-            @nodes << "#{node.object_id} [label=\"()\"];"
+          def visit_GROUP(node, seed)
+            seed.first << "#{node.object_id} [label=\"()\"];"
             super
           end
 
-          def visit_CAT(node)
-            @nodes << "#{node.object_id} [label=\"○\"];"
+          def visit_CAT(node, seed)
+            seed.first << "#{node.object_id} [label=\"○\"];"
             super
           end
 
-          def visit_STAR(node)
-            @nodes << "#{node.object_id} [label=\"*\"];"
+          def visit_STAR(node, seed)
+            seed.first << "#{node.object_id} [label=\"*\"];"
             super
           end
 
-          def visit_OR(node)
-            @nodes << "#{node.object_id} [label=\"|\"];"
+          def visit_OR(node, seed)
+            seed.first << "#{node.object_id} [label=\"|\"];"
             super
           end
 
-          def terminal(node)
+          def terminal(node, seed)
             value = node.left
 
-            @nodes << "#{node.object_id} [label=\"#{value}\"];"
+            seed.first << "#{node.object_id} [label=\"#{value}\"];"
+            seed
           end
+          INSTANCE = new
       end
     end
   end
+  # :startdoc:
 end