actionpack 4.2.8 → 5.2.4.2

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionDispatch
   module Journey # :nodoc:
     class Router # :nodoc:
@@ -5,7 +7,7 @@ module ActionDispatch
         # Normalizes URI path.
         #
         # Strips off trailing slash and ensures there is a leading slash.
-        # Also converts downcase url encoded string to uppercase.
+        # Also converts downcase URL encoded string to uppercase.
         #
         #   normalize_path("/foo")  # => "/foo"
         #   normalize_path("/foo/") # => "/foo"
@@ -13,22 +15,25 @@ module ActionDispatch
         #   normalize_path("")      # => "/"
         #   normalize_path("/%ab")  # => "/%AB"
         def self.normalize_path(path)
-          path = "/#{path}"
-          path.squeeze!('/')
-          path.sub!(%r{/+\Z}, '')
+          path ||= ""
+          encoding = path.encoding
+          path = "/#{path}".dup
+          path.squeeze!("/".freeze)
+          path.sub!(%r{/+\Z}, "".freeze)
           path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
-          path = '/' if path == ''
+          path = "/".dup if path == "".freeze
+          path.force_encoding(encoding)
           path
         end
 
         # URI path and fragment escaping
-        # http://tools.ietf.org/html/rfc3986
+        # https://tools.ietf.org/html/rfc3986
         class UriEncoder # :nodoc:
           ENCODE   = "%%%02X".freeze
           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    = "".dup.force_encoding(US_ASCII).freeze
+          DEC2HEX  = (0..255).to_a.map { |i| ENCODE % i }.map { |s| s.force_encoding(US_ASCII) }
 
           ALPHA = "a-zA-Z".freeze
           DIGIT = "0-9".freeze
@@ -55,12 +60,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 +89,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

data/lib/action_dispatch/journey/routes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionDispatch
   module Journey # :nodoc:
     # The Routing table. Contains all routes for a system. Routes can be
@@ -5,13 +7,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,36 +36,37 @@ 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)
-          Nodes::Or.new(asts) unless asts.empty?
+          asts = anchored_routes.map(&:ast)
+          Nodes::Or.new(asts)
         end
       end
 
       def simulator
+        return if ast.nil?
         @simulator ||= begin
           gtg = GTG::Builder.new(ast).transition_table
           GTG::Simulator.new(gtg)
         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 +75,6 @@ module ActionDispatch
 
         def clear_cache!
           @ast                = nil
-          @partitioned_routes = nil
           @simulator          = nil
         end
     end

data/lib/action_dispatch/journey/scanner.rb

@@ -1,4 +1,6 @@
-require 'strscan'
+# frozen_string_literal: true
+
+require "strscan"
 
 module ActionDispatch
   module Journey # :nodoc:
@@ -35,22 +37,23 @@ module ActionDispatch
         def scan
           case
             # /
-          when text = @ss.scan(/\//)
-            [:SLASH, text]
+          when @ss.skip(/\//)
+            [:SLASH, "/"]
+          when @ss.skip(/\(/)
+            [:LPAREN, "("]
+          when @ss.skip(/\)/)
+            [:RPAREN, ")"]
+          when @ss.skip(/\|/)
+            [:OR, "|"]
+          when @ss.skip(/\./)
+            [:DOT, "."]
+          when text = @ss.scan(/:\w+/)
+            [:SYMBOL, text]
           when text = @ss.scan(/\*\w+/)
             [:STAR, text]
-          when text = @ss.scan(/(?<!\\)\(/)
-            [:LPAREN, text]
-          when text = @ss.scan(/(?<!\\)\)/)
-            [:RPAREN, text]
-          when text = @ss.scan(/\|/)
-            [:OR, text]
-          when text = @ss.scan(/\./)
-            [:DOT, text]
-          when text = @ss.scan(/(?<!\\):\w+/)
-            [:SYMBOL, text]
-          when text = @ss.scan(/(?:[\w%\-~!$&'*+,;=@]|\\:|\\\(|\\\))+/)
-            [:LITERAL, text.tr('\\', '')]
+          when text = @ss.scan(/(?:[\w%\-~!$&'*+,;=@]|\\[:()])+/)
+            text.tr! "\\", ""
+            [:LITERAL, text]
             # any char
           when text = @ss.scan(/./)
             [:LITERAL, text]

data/lib/action_dispatch/journey/visitors.rb

@@ -1,12 +1,13 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 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) }
 
-      class Parameter < Struct.new(:name, :escaper)
+      Parameter = Struct.new(:name, :escaper) do
         def escape(value); escaper.call value; end
       end
 
@@ -23,7 +24,7 @@ module ActionDispatch
         @children   = []
         @parameters = []
 
-        parts.each_with_index do |object,i|
+        parts.each_with_index do |object, i|
           case object
           when Journey::Format
             @children << i
@@ -39,7 +40,7 @@ module ActionDispatch
         @parameters.each do |index|
           param = parts[index]
           value = hash[param.name]
-          return ''.freeze unless value
+          return "".freeze unless value
           parts[index] = param.escape value
         end
 
@@ -59,7 +60,7 @@ module ActionDispatch
 
         private
 
-          def visit node
+          def visit(node)
             send(DISPATCH_CACHE[node.type], node)
           end
 
@@ -92,6 +93,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
@@ -116,106 +156,113 @@ module ActionDispatch
         end
       end
 
-      # Loop through the requirements AST
-      class Each < Visitor # :nodoc:
-        attr_reader :block
-
-        def initialize(block)
-          @block = block
-        end
-
-        def visit(node)
+      # Loop through the requirements AST.
+      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
-        end
+          def binary(node, seed)
+            visit(node.right, visit(node.left, seed))
+          end
 
-        def nary(node)
-          node.children.map { |c| visit(c) }.join '|'
-        end
+          def nary(node, seed)
+            last_child = node.children.last
+            node.children.inject(seed) { |s, c|
+              string = visit(c, s)
+              string << "|" unless last_child == c
+              string
+            }
+          end
 
-        def terminal(node)
-          node.left
-        end
+          def terminal(node, seed)
+            seed + node.left
+          end
 
-        def visit_GROUP(node)
-          "(#{visit(node.left)})"
-        end
+          def visit_GROUP(node, seed)
+            visit(node.left, seed.dup << "(") << ")"
+          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

data/lib/action_dispatch/middleware/callbacks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module ActionDispatch
   # Provides callbacks to be executed before and after dispatching the request.
@@ -7,8 +8,6 @@ module ActionDispatch
     define_callbacks :call
 
     class << self
-      delegate :to_prepare, :to_cleanup, :to => "ActionDispatch::Reloader"
-
       def before(*args, &block)
         set_callback(:call, :before, *args, &block)
       end