actionpack 4.2.10 → 7.2.0.rc1

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

@@ -1,22 +1,21 @@
-require 'action_dispatch/journey/router/strexp'
+# frozen_string_literal: true
+
+# :markup: markdown
 
 module ActionDispatch
   module Journey # :nodoc:
     module Path # :nodoc:
       class Pattern # :nodoc:
-        attr_reader :spec, :requirements, :anchored
-
-        def self.from_string string
-          new Journey::Router::Strexp.build(string, {}, ["/.?"], true)
-        end
+        attr_reader :ast, :names, :requirements, :anchored, :spec
 
-        def initialize(strexp)
-          @spec         = strexp.ast
-          @requirements = strexp.requirements
-          @separators   = strexp.separators.join
-          @anchored     = strexp.anchor
+        def initialize(ast, requirements, separators, anchored)
+          @ast          = ast
+          @spec         = ast.root
+          @requirements = requirements
+          @separators   = separators
+          @anchored     = anchored
 
-          @names          = nil
+          @names          = ast.names
           @optional_names = nil
           @required_names = nil
           @re             = nil
@@ -27,22 +26,33 @@ module ActionDispatch
           Visitors::FormatBuilder.new.accept(spec)
         end
 
-        def ast
-          @spec.grep(Nodes::Symbol).each do |node|
-            re = @requirements[node.to_sym]
-            node.regexp = re if re
-          end
+        def eager_load!
+          required_names
+          offsets
+          to_regexp
+          @ast = nil
+        end
 
-          @spec.grep(Nodes::Star).each do |node|
-            node = node.left
-            node.regexp = @requirements[node.to_sym] || /(.+)/
-          end
+        def requirements_anchored?
+          # each required param must not be surrounded by a literal, otherwise it isn't
+          # simple to chunk-match the url piecemeal
+          terminals = ast.terminals
 
-          @spec
-        end
+          terminals.each_with_index { |s, index|
+            next if index < 1
+            next if s.type == :DOT || s.type == :SLASH
+
+            back = terminals[index - 1]
+            fwd = terminals[index + 1]
+
+            # we also don't support this yet, constraints must be regexps
+            return false if s.symbol? && s.regexp.is_a?(Array)
 
-        def names
-          @names ||= spec.grep(Nodes::Symbol).map { |n| n.name }
+            return false if back.literal?
+            return false if !fwd.nil? && fwd.literal?
+          }
+
+          true
         end
 
         def required_names
@@ -50,34 +60,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:
@@ -93,7 +78,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)
@@ -102,7 +87,7 @@ module ActionDispatch
             return @separator_re unless @matchers.key?(node)
 
             re = @matchers[node]
-            "(#{re})"
+            "(#{Regexp.union(re)})"
           end
 
           def visit_GROUP(node)
@@ -119,14 +104,20 @@ 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)
+            children = node.children.map { |n| visit n }
+            "(?:#{children.join(?|)})"
           end
         end
 
         class UnanchoredRegexp < AnchoredRegexp # :nodoc:
           def accept(node)
-            %r{\A#{visit node}}
+            path = visit node
+            path == "/" ? %r{\A/} : %r{\A#{path}(?:\b|\Z|/)}
           end
         end
 
@@ -140,7 +131,11 @@ module ActionDispatch
           end
 
           def captures
-            (length - 1).times.map { |i| self[i + 1] }
+            Array.new(length - 1) { |i| self[i + 1] }
+          end
+
+          def named_captures
+            @names.zip(captures).to_h
           end
 
           def [](x)
@@ -167,6 +162,10 @@ module ActionDispatch
         end
         alias :=~ :match
 
+        def match?(other)
+          to_regexp.match?(other)
+        end
+
         def source
           to_regexp.source
         end
@@ -175,17 +174,34 @@ module ActionDispatch
           @re ||= regexp_visitor.new(@separators, @requirements).accept spec
         end
 
-        private
+        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
           end
 
           def offsets
-            return @offsets if @offsets
+            @offsets ||= begin
+              offsets = [0]
+
+              spec.find_all(&:symbol?).each do |node|
+                node = node.to_sym
 
-            viz = RegexpOffsets.new(@requirements)
-            @offsets = viz.accept(spec)
+                if @requirements.key?(node)
+                  re = /#{Regexp.union(@requirements[node])}|/
+                  offsets.push((re.match("").length - 1) + offsets.last)
+                else
+                  offsets << offsets.last
+                end
+              end
+
+              offsets
+            end
           end
       end
     end

data/lib/action_dispatch/journey/route.rb

@@ -1,43 +1,100 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 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, :constraints,
+                  :internal, :scope_options, :ast, :source_location
 
-      attr_reader :constraints
       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, __FILE__, __LINE__ + 1
+            # frozen_string_literal: true
+            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
 
       ##
       # +path+ is a path constraint.
-      # +constraints+ is a hash of constraints to be applied to this route.
-      def initialize(name, app, path, constraints, defaults = {})
+      # `constraints` is a hash of constraints to be applied to this route.
+      def initialize(name:, app: nil, path:, constraints: {}, required_defaults: [], defaults: {}, request_method_match: nil, precedence: 0, scope_options: {}, internal: false, source_location: nil)
         @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
-      end
-
-      def ast
-        @decorated_ast ||= begin
-          decorated_ast = path.ast
-          decorated_ast.grep(Nodes::Terminal).each { |n| n.memo = self }
-          decorated_ast
-        end
-      end
-
-      def requirements # :nodoc:
-        # needed for rails `rake routes`
-        @defaults.merge(path.requirements).delete_if { |_,v|
-          /.+?/ == v
+        @scope_options     = scope_options
+        @internal          = internal
+        @source_location   = source_location
+
+        @ast = @path.ast.root
+        @path.ast.route = self
+      end
+
+      def eager_load!
+        path.eager_load!
+        parts
+        required_defaults
+        nil
+      end
+
+      # Needed for `bin/rails routes`. Picks up succinctly defined requirements for a
+      # route, for example route
+      #
+      #     get 'photo/:id', :controller => 'photos', :action => 'show',
+      #       :id => /[A-Z]\d{5}/
+      #
+      # will have {:controller=>"photos", :action=>"show", :[id=>/](A-Z){5}/} as
+      # requirements.
+      def requirements
+        @defaults.merge(path.requirements).delete_if { |_, v|
+          /.+?/m == v
         }
       end
 
@@ -49,18 +106,16 @@ module ActionDispatch
         required_parts + required_defaults.keys
       end
 
-      def score(constraints)
-        required_keys = path.required_names
-        supplied_keys = constraints.map { |k,v| v && k.to_s }.compact
-
-        return -1 unless (required_keys - supplied_keys).empty?
+      def score(supplied_keys)
+        path.required_names.each do |k|
+          return -1 unless supplied_keys.include?(k)
+        end
 
-        score = (supplied_keys & path.names).length
-        score + (required_defaults.length * 2)
+        (required_defaults.length * 2) + path.names.count { |k| supplied_keys.include?(k) }
       end
 
       def parts
-        @parts ||= segments.map { |n| n.to_sym }
+        @parts ||= segments.map(&:to_sym)
       end
       alias :segment_keys :parts
 
@@ -68,26 +123,22 @@ 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
-        @required_defaults ||= @defaults.dup.delete_if do |k,_|
+        @required_defaults ||= @defaults.dup.delete_if do |k, _|
           parts.include?(k) || !required_default?(k)
         end
       end
 
       def glob?
-        !path.spec.grep(Nodes::Star).empty?
+        path.ast.glob?
       end
 
       def dispatcher?
@@ -95,9 +146,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 +160,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

@@ -1,45 +1,53 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
   module Journey # :nodoc:
     class Router # :nodoc:
       class Utils # :nodoc:
         # Normalizes URI path.
         #
-        # Strips off trailing slash and ensures there is a leading slash.
-        # Also converts downcase url encoded string to uppercase.
+        # Strips off trailing slash and ensures there is a leading slash. Also converts
+        # downcase URL encoded string to uppercase.
         #
-        #   normalize_path("/foo")  # => "/foo"
-        #   normalize_path("/foo/") # => "/foo"
-        #   normalize_path("foo")   # => "/foo"
-        #   normalize_path("")      # => "/"
-        #   normalize_path("/%ab")  # => "/%AB"
+        #     normalize_path("/foo")  # => "/foo"
+        #     normalize_path("/foo/") # => "/foo"
+        #     normalize_path("foo")   # => "/foo"
+        #     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.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
-          path = '/' if path == ''
-          path
+          path ||= ""
+          encoding = path.encoding
+          path = +"/#{path}"
+          path.squeeze!("/")
+
+          unless path == "/"
+            path.delete_suffix!("/")
+            path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
+          end
+
+          path.force_encoding(encoding)
         end
 
-        # URI path and fragment escaping
-        # http://tools.ietf.org/html/rfc3986
+        # URI path and fragment escaping https://tools.ietf.org/html/rfc3986
         class UriEncoder # :nodoc:
-          ENCODE   = "%%%02X".freeze
+          ENCODE   = "%%%02X"
           US_ASCII = Encoding::US_ASCII
           UTF_8    = Encoding::UTF_8
-          EMPTY    = "".force_encoding(US_ASCII).freeze
-          DEC2HEX  = (0..255).to_a.map{ |i| ENCODE % i }.map{ |s| s.force_encoding(US_ASCII) }
+          EMPTY    = (+"").force_encoding(US_ASCII).freeze
+          DEC2HEX  = (0..255).map { |i| (ENCODE % i).force_encoding(US_ASCII) }
 
-          ALPHA = "a-zA-Z".freeze
-          DIGIT = "0-9".freeze
-          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~".freeze
-          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;=".freeze
+          ALPHA = "a-zA-Z"
+          DIGIT = "0-9"
+          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~"
+          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;="
 
-          ESCAPED  = /%[a-zA-Z0-9]{2}/.freeze
+          ESCAPED  = /%[a-zA-Z0-9]{2}/
 
-          FRAGMENT = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/\?]/.freeze
-          SEGMENT  = /[^#{UNRESERVED}#{SUB_DELIMS}:@]/.freeze
-          PATH     = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/]/.freeze
+          FRAGMENT = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/?]/
+          SEGMENT  = /[^#{UNRESERVED}#{SUB_DELIMS}:@]/
+          PATH     = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/]/
 
           def escape_fragment(fragment)
             escape(fragment, FRAGMENT)
@@ -55,12 +63,12 @@ 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
+          private
             def escape(component, pattern)
-              component.gsub(pattern){ |unsafe| percent_encode(unsafe) }.force_encoding(US_ASCII)
+              component.gsub(pattern) { |unsafe| percent_encode(unsafe) }.force_encoding(US_ASCII)
             end
 
             def percent_encode(unsafe)
@@ -84,6 +92,10 @@ module ActionDispatch
           ENCODER.escape_fragment(fragment.to_s)
         end
 
+        # Replaces any escaped sequences with their unescaped representations.
+        #
+        #     uri = "/topics?title=Ruby%20on%20Rails"
+        #     unescape_uri(uri)  #=> "/topics?title=Ruby on Rails"
         def self.unescape_uri(uri)
           ENCODER.unescape_uri(uri)
         end