actionpack 3.2.22.5 → 5.2.4

data/lib/action_dispatch/journey/route.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  # :stopdoc:
+  module Journey
+    class Route
+      attr_reader :app, :path, :defaults, :name, :precedence
+
+      attr_reader :constraints, :internal
+      alias :conditions :constraints
+
+      module VerbMatchers
+        VERBS = %w{ DELETE GET HEAD OPTIONS LINK PATCH POST PUT TRACE UNLINK }
+        VERBS.each do |v|
+          class_eval <<-eoc, __FILE__, __LINE__ + 1
+            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, 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        = precedence
+        @path_formatter    = @path.build_formatter
+        @internal          = internal
+      end
+
+      def eager_load!
+        path.eager_load!
+        ast
+        parts
+        required_defaults
+        nil
+      end
+
+      def ast
+        @decorated_ast ||= begin
+          decorated_ast = path.ast
+          decorated_ast.find_all(&:terminal?).each { |n| n.memo = self }
+          decorated_ast
+        end
+      end
+
+      # Needed for `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]\d{5}/}
+      # as requirements.
+      def requirements
+        @defaults.merge(path.requirements).delete_if { |_, v|
+          /.+?/ == v
+        }
+      end
+
+      def segments
+        path.names
+      end
+
+      def required_keys
+        required_parts + required_defaults.keys
+      end
+
+      def score(supplied_keys)
+        required_keys = path.required_names
+
+        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 + (required_defaults.length * 2)
+      end
+
+      def parts
+        @parts ||= segments.map(&:to_sym)
+      end
+      alias :segment_keys :parts
+
+      def format(path_options)
+        @path_formatter.evaluate path_options
+      end
+
+      def required_parts
+        @required_parts ||= path.required_names.map(&:to_sym)
+      end
+
+      def required_default?(key)
+        @_required_defaults.include?(key)
+      end
+
+      def required_defaults
+        @required_defaults ||= @defaults.dup.delete_if do |k, _|
+          parts.include?(k) || !required_default?(k)
+        end
+      end
+
+      def glob?
+        !path.spec.grep(Nodes::Star).empty?
+      end
+
+      def dispatcher?
+        @app.dispatcher?
+      end
+
+      def matches?(request)
+        match_verb(request) &&
+        constraints.all? { |method, value|
+          case value
+          when Regexp, String
+            value === request.send(method).to_s
+          when Array
+            value.include?(request.send(method))
+          when TrueClass
+            request.send(method).present?
+          when FalseClass
+            request.send(method).blank?
+          else
+            value === request.send(method)
+          end
+        }
+      end
+
+      def ip
+        constraints[:ip] || //
+      end
+
+      def requires_matching_verb?
+        !@request_method_match.all? { |x| x == VerbMatchers::All }
+      end
+
+      def verb
+        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

@@ -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}".dup
+          path.squeeze!("/".freeze)
+          path.sub!(%r{/+\Z}, "".freeze)
+          path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
+          path = "/".dup if path == "".freeze
+          path.force_encoding(encoding)
+          path
+        end
+
+        # URI path and fragment escaping
+        # https://tools.ietf.org/html/rfc3986
+        class UriEncoder # :nodoc:
+          ENCODE   = "%%%02X".freeze
+          US_ASCII = Encoding::US_ASCII
+          UTF_8    = Encoding::UTF_8
+          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
+          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~".freeze
+          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;=".freeze
+
+          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/router.rb

@@ -0,0 +1,156 @@
+# 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:
+      class RoutingError < ::StandardError # :nodoc:
+      end
+
+      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/routes.rb

@@ -0,0 +1,82 @@
+# 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
+        return if ast.nil?
+        @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,64 @@
+# 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
+
+        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 = @ss.scan(/:\w+/)
+            [:SYMBOL, text]
+          when text = @ss.scan(/\*\w+/)
+            [:STAR, text]
+          when text = @ss.scan(/(?:[\w%\-~!$&'*+,;=@]|\\[:()])+/)
+            text.tr! "\\", ""
+            [:LITERAL, text]
+            # any char
+          when text = @ss.scan(/./)
+            [:LITERAL, text]
+          end
+        end
+    end
+  end
+end