actionpack 6.0.0

data/lib/action_dispatch/journey/router.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "action_dispatch/journey/router/utils"
+require "action_dispatch/journey/routes"
+require "action_dispatch/journey/formatter"
+
+before = $-w
+$-w = false
+require "action_dispatch/journey/parser"
+$-w = before
+
+require "action_dispatch/journey/route"
+require "action_dispatch/journey/path/pattern"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Router # :nodoc:
+      attr_accessor :routes
+
+      def initialize(routes)
+        @routes = routes
+      end
+
+      def eager_load!
+        # Eagerly trigger the simulator's initialization so
+        # it doesn't happen during a request cycle.
+        simulator
+        nil
+      end
+
+      def serve(req)
+        find_routes(req).each do |match, parameters, route|
+          set_params  = req.path_parameters
+          path_info   = req.path_info
+          script_name = req.script_name
+
+          unless route.path.anchored
+            req.script_name = (script_name.to_s + match.to_s).chomp("/")
+            req.path_info = match.post_match
+            req.path_info = "/" + req.path_info unless req.path_info.start_with? "/"
+          end
+
+          parameters = route.defaults.merge parameters.transform_values { |val|
+            val.dup.force_encoding(::Encoding::UTF_8)
+          }
+
+          req.path_parameters = set_params.merge parameters
+
+          status, headers, body = route.app.serve(req)
+
+          if "pass" == headers["X-Cascade"]
+            req.script_name     = script_name
+            req.path_info       = path_info
+            req.path_parameters = set_params
+            next
+          end
+
+          return [status, headers, body]
+        end
+
+        [404, { "X-Cascade" => "pass" }, ["Not Found"]]
+      end
+
+      def recognize(rails_req)
+        find_routes(rails_req).each do |match, parameters, route|
+          unless route.path.anchored
+            rails_req.script_name = match.to_s
+            rails_req.path_info   = match.post_match.sub(/^([^\/])/, '/\1')
+          end
+
+          parameters = route.defaults.merge parameters
+          yield(route, parameters)
+        end
+      end
+
+      def visualizer
+        tt     = GTG::Builder.new(ast).transition_table
+        groups = partitioned_routes.first.map(&:ast).group_by(&:to_s)
+        asts   = groups.values.map(&:first)
+        tt.visualizer(asts)
+      end
+
+      private
+
+        def partitioned_routes
+          routes.partition { |r|
+            r.path.anchored && r.ast.grep(Nodes::Symbol).all? { |n| n.default_regexp?  }
+          }
+        end
+
+        def ast
+          routes.ast
+        end
+
+        def simulator
+          routes.simulator
+        end
+
+        def custom_routes
+          routes.custom_routes
+        end
+
+        def filter_routes(path)
+          return [] unless ast
+          simulator.memos(path) { [] }
+        end
+
+        def find_routes(req)
+          routes = filter_routes(req.path_info).concat custom_routes.find_all { |r|
+            r.path.match(req.path_info)
+          }
+
+          routes =
+            if req.head?
+              match_head_routes(routes, req)
+            else
+              match_routes(routes, req)
+            end
+
+          routes.sort_by!(&:precedence)
+
+          routes.map! { |r|
+            match_data = r.path.match(req.path_info)
+            path_parameters = {}
+            match_data.names.zip(match_data.captures) { |name, val|
+              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
+            }
+            [match_data, path_parameters, r]
+          }
+        end
+
+        def match_head_routes(routes, req)
+          verb_specific_routes = routes.select(&:requires_matching_verb?)
+          head_routes = match_routes(verb_specific_routes, req)
+
+          if head_routes.empty?
+            begin
+              req.request_method = "GET"
+              match_routes(routes, req)
+            ensure
+              req.request_method = "HEAD"
+            end
+          else
+            head_routes
+          end
+        end
+
+        def match_routes(routes, req)
+          routes.select { |r| r.matches?(req) }
+        end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+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.
+        #
+        #   normalize_path("/foo")  # => "/foo"
+        #   normalize_path("/foo/") # => "/foo"
+        #   normalize_path("foo")   # => "/foo"
+        #   normalize_path("")      # => "/"
+        #   normalize_path("/%ab")  # => "/%AB"
+        def self.normalize_path(path)
+          path ||= ""
+          encoding = path.encoding
+          path = +"/#{path}"
+          path.squeeze!("/")
+          path.sub!(%r{/+\Z}, "")
+          path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
+          path = +"/" if path == ""
+          path.force_encoding(encoding)
+          path
+        end
+
+        # URI path and fragment escaping
+        # https://tools.ietf.org/html/rfc3986
+        class UriEncoder # :nodoc:
+          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) }
+
+          ALPHA = "a-zA-Z"
+          DIGIT = "0-9"
+          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~"
+          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;="
+
+          ESCAPED  = /%[a-zA-Z0-9]{2}/.freeze
+
+          FRAGMENT = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/\?]/.freeze
+          SEGMENT  = /[^#{UNRESERVED}#{SUB_DELIMS}:@]/.freeze
+          PATH     = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/]/.freeze
+
+          def escape_fragment(fragment)
+            escape(fragment, FRAGMENT)
+          end
+
+          def escape_path(path)
+            escape(path, PATH)
+          end
+
+          def escape_segment(segment)
+            escape(segment, SEGMENT)
+          end
+
+          def unescape_uri(uri)
+            encoding = uri.encoding == US_ASCII ? UTF_8 : uri.encoding
+            uri.gsub(ESCAPED) { |match| [match[1, 2].hex].pack("C") }.force_encoding(encoding)
+          end
+
+          private
+            def escape(component, pattern)
+              component.gsub(pattern) { |unsafe| percent_encode(unsafe) }.force_encoding(US_ASCII)
+            end
+
+            def percent_encode(unsafe)
+              safe = EMPTY.dup
+              unsafe.each_byte { |b| safe << DEC2HEX[b] }
+              safe
+            end
+        end
+
+        ENCODER = UriEncoder.new
+
+        def self.escape_path(path)
+          ENCODER.escape_path(path.to_s)
+        end
+
+        def self.escape_segment(segment)
+          ENCODER.escape_segment(segment.to_s)
+        end
+
+        def self.escape_fragment(fragment)
+          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
+      end
+    end
+  end
+end

data/lib/action_dispatch/journey/routes.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Journey # :nodoc:
+    # The Routing table. Contains all routes for a system. Routes can be
+    # added to the table by calling Routes#add_route.
+    class Routes # :nodoc:
+      include Enumerable
+
+      attr_reader :routes, :custom_routes, :anchored_routes
+
+      def initialize
+        @routes             = []
+        @ast                = nil
+        @anchored_routes    = []
+        @custom_routes      = []
+        @simulator          = nil
+      end
+
+      def empty?
+        routes.empty?
+      end
+
+      def length
+        routes.length
+      end
+      alias :size :length
+
+      def last
+        routes.last
+      end
+
+      def each(&block)
+        routes.each(&block)
+      end
+
+      def clear
+        routes.clear
+        anchored_routes.clear
+        custom_routes.clear
+      end
+
+      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 = anchored_routes.map(&:ast)
+          Nodes::Or.new(asts)
+        end
+      end
+
+      def simulator
+        @simulator ||= begin
+          gtg = GTG::Builder.new(ast).transition_table
+          GTG::Simulator.new(gtg)
+        end
+      end
+
+      def add_route(name, mapping)
+        route = mapping.make_route name, routes.length
+        routes << route
+        partition_route(route)
+        clear_cache!
+        route
+      end
+
+      private
+
+        def clear_cache!
+          @ast                = nil
+          @simulator          = nil
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/scanner.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Scanner # :nodoc:
+      def initialize
+        @ss = nil
+      end
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+      end
+
+      def eos?
+        @ss.eos?
+      end
+
+      def pos
+        @ss.pos
+      end
+
+      def pre_match
+        @ss.pre_match
+      end
+
+      def next_token
+        return if @ss.eos?
+
+        until token = scan || @ss.eos?; end
+        token
+      end
+
+      private
+
+        # takes advantage of String @- deduping capabilities in Ruby 2.5 upwards
+        # see: https://bugs.ruby-lang.org/issues/13077
+        def dedup_scan(regex)
+          r = @ss.scan(regex)
+          r ? -r : nil
+        end
+
+        def scan
+          case
+            # /
+          when @ss.skip(/\//)
+            [:SLASH, "/"]
+          when @ss.skip(/\(/)
+            [:LPAREN, "("]
+          when @ss.skip(/\)/)
+            [:RPAREN, ")"]
+          when @ss.skip(/\|/)
+            [:OR, "|"]
+          when @ss.skip(/\./)
+            [:DOT, "."]
+          when text = dedup_scan(/:\w+/)
+            [:SYMBOL, text]
+          when text = dedup_scan(/\*\w+/)
+            [:STAR, text]
+          when text = @ss.scan(/(?:[\w%\-~!$&'*+,;=@]|\\[:()])+/)
+            text.tr! "\\", ""
+            [:LITERAL, -text]
+            # any char
+          when text = dedup_scan(/./)
+            [:LITERAL, text]
+          end
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/visitors.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  # :stopdoc:
+  module Journey
+    class Format
+      ESCAPE_PATH    = ->(value) { Router::Utils.escape_path(value) }
+      ESCAPE_SEGMENT = ->(value) { Router::Utils.escape_segment(value) }
+
+      Parameter = Struct.new(:name, :escaper) do
+        def escape(value); escaper.call value; end
+      end
+
+      def self.required_path(symbol)
+        Parameter.new symbol, ESCAPE_PATH
+      end
+
+      def self.required_segment(symbol)
+        Parameter.new symbol, ESCAPE_SEGMENT
+      end
+
+      def initialize(parts)
+        @parts      = parts
+        @children   = []
+        @parameters = []
+
+        parts.each_with_index do |object, i|
+          case object
+          when Journey::Format
+            @children << i
+          when Parameter
+            @parameters << i
+          end
+        end
+      end
+
+      def evaluate(hash)
+        parts = @parts.dup
+
+        @parameters.each do |index|
+          param = parts[index]
+          value = hash[param.name]
+          return "" unless value
+          parts[index] = param.escape value
+        end
+
+        @children.each { |index| parts[index] = parts[index].evaluate(hash) }
+
+        parts.join
+      end
+    end
+
+    module Visitors # :nodoc:
+      class Visitor # :nodoc:
+        DISPATCH_CACHE = {}
+
+        def accept(node)
+          visit(node)
+        end
+
+        private
+
+          def visit(node)
+            send(DISPATCH_CACHE[node.type], node)
+          end
+
+          def binary(node)
+            visit(node.left)
+            visit(node.right)
+          end
+          def visit_CAT(n); binary(n); end
+
+          def nary(node)
+            node.children.each { |c| visit(c) }
+          end
+          def visit_OR(n); nary(n); end
+
+          def unary(node)
+            visit(node.left)
+          end
+          def visit_GROUP(n); unary(n); end
+          def visit_STAR(n); unary(n); end
+
+          def terminal(node); end
+          def visit_LITERAL(n); terminal(n); end
+          def visit_SYMBOL(n);  terminal(n); end
+          def visit_SLASH(n);   terminal(n); end
+          def visit_DOT(n);     terminal(n); end
+
+          private_instance_methods(false).each do |pim|
+            next unless pim =~ /^visit_(.*)$/
+            DISPATCH_CACHE[$1.to_sym] = pim
+          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
+
+        def binary(node)
+          visit(node.left) + visit(node.right)
+        end
+
+        def visit_GROUP(n); [Journey::Format.new(unary(n))]; end
+
+        def visit_STAR(n)
+          [Journey::Format.required_path(n.left.to_sym)]
+        end
+
+        def visit_SYMBOL(n)
+          symbol = n.to_sym
+          if symbol == :controller
+            [Journey::Format.required_path(symbol)]
+          else
+            [Journey::Format.required_segment(symbol)]
+          end
+        end
+      end
+
+      # Loop through the requirements AST.
+      class Each < FunctionalVisitor # :nodoc:
+        def visit(node, block)
+          block.call(node)
+          super
+        end
+
+        INSTANCE = new
+      end
+
+      class String < FunctionalVisitor # :nodoc:
+        private
+
+          def binary(node, seed)
+            visit(node.right, visit(node.left, seed))
+          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, seed)
+            seed + node.left
+          end
+
+          def visit_GROUP(node, seed)
+            visit(node.left, seed.dup << "(") << ")"
+          end
+
+          INSTANCE = new
+      end
+
+      class Dot < FunctionalVisitor # :nodoc:
+        def initialize
+          @nodes = []
+          @edges = []
+        end
+
+        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")}
+  }
+          eodot
+        end
+
+        private
+
+          def binary(node, seed)
+            seed.last.concat node.children.map { |c|
+              "#{node.object_id} -> #{c.object_id};"
+            }
+            super
+          end
+
+          def nary(node, seed)
+            seed.last.concat node.children.map { |c|
+              "#{node.object_id} -> #{c.object_id};"
+            }
+            super
+          end
+
+          def unary(node, seed)
+            seed.last << "#{node.object_id} -> #{node.left.object_id};"
+            super
+          end
+
+          def visit_GROUP(node, seed)
+            seed.first << "#{node.object_id} [label=\"()\"];"
+            super
+          end
+
+          def visit_CAT(node, seed)
+            seed.first << "#{node.object_id} [label=\"○\"];"
+            super
+          end
+
+          def visit_STAR(node, seed)
+            seed.first << "#{node.object_id} [label=\"*\"];"
+            super
+          end
+
+          def visit_OR(node, seed)
+            seed.first << "#{node.object_id} [label=\"|\"];"
+            super
+          end
+
+          def terminal(node, seed)
+            value = node.left
+
+            seed.first << "#{node.object_id} [label=\"#{value}\"];"
+            seed
+          end
+          INSTANCE = new
+      end
+    end
+  end
+  # :startdoc:
+end