omg-actionpack 8.0.0.alpha1

data/lib/action_dispatch/journey/parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "action_dispatch/journey/scanner"
+require "action_dispatch/journey/nodes/node"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Parser # :nodoc:
+      include Journey::Nodes
+
+      def self.parse(string)
+        new.parse string
+      end
+
+      def initialize
+        @scanner = Scanner.new
+        @next_token = nil
+      end
+
+      def parse(string)
+        @scanner.scan_setup(string)
+        advance_token
+        do_parse
+      end
+
+      private
+        def advance_token
+          @next_token = @scanner.next_token
+        end
+
+        def do_parse
+          parse_expressions
+        end
+
+        def parse_expressions
+          node = parse_expression
+
+          while @next_token
+            case @next_token
+            when :RPAREN
+              break
+            when :OR
+              node = parse_or(node)
+            else
+              node = Cat.new(node, parse_expressions)
+            end
+          end
+
+          node
+        end
+
+        def parse_or(lhs)
+          advance_token
+          node = parse_expression
+          Or.new([lhs, node])
+        end
+
+        def parse_expression
+          if @next_token == :STAR
+            parse_star
+          elsif @next_token == :LPAREN
+            parse_group
+          else
+            parse_terminal
+          end
+        end
+
+        def parse_star
+          node = Star.new(Symbol.new(@scanner.last_string, Symbol::GREEDY_EXP))
+          advance_token
+          node
+        end
+
+        def parse_group
+          advance_token
+          node = parse_expressions
+          if @next_token == :RPAREN
+            node = Group.new(node)
+            advance_token
+            node
+          else
+            raise ArgumentError, "missing right parenthesis."
+          end
+        end
+
+        def parse_terminal
+          node = case @next_token
+          when :SYMBOL
+            Symbol.new(@scanner.last_string)
+          when :LITERAL
+            Literal.new(@scanner.last_literal)
+          when :SLASH
+            Slash.new("/")
+          when :DOT
+            Dot.new(".")
+          end
+
+          advance_token
+          node
+        end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module Path # :nodoc:
+      class Pattern # :nodoc:
+        attr_reader :ast, :names, :requirements, :anchored, :spec
+
+        def initialize(ast, requirements, separators, anchored)
+          @ast          = ast
+          @spec         = ast.root
+          @requirements = requirements
+          @separators   = separators
+          @anchored     = anchored
+
+          @names          = ast.names
+          @optional_names = nil
+          @required_names = nil
+          @re             = nil
+          @offsets        = nil
+        end
+
+        def build_formatter
+          Visitors::FormatBuilder.new.accept(spec)
+        end
+
+        def eager_load!
+          required_names
+          offsets
+          to_regexp
+          @ast = nil
+        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
+
+          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)
+
+            return false if back.literal?
+            return false if !fwd.nil? && fwd.literal?
+          }
+
+          true
+        end
+
+        def required_names
+          @required_names ||= names - optional_names
+        end
+
+        def optional_names
+          @optional_names ||= spec.find_all(&:group?).flat_map { |group|
+            group.find_all(&:symbol?)
+          }.map(&:name).uniq
+        end
+
+        class AnchoredRegexp < Journey::Visitors::Visitor # :nodoc:
+          def initialize(separator, matchers)
+            @separator = separator
+            @matchers  = matchers
+            @separator_re = "([^#{separator}]+)"
+            super()
+          end
+
+          def accept(node)
+            %r{\A#{visit node}\Z}
+          end
+
+          def visit_CAT(node)
+            "#{visit(node.left)}#{visit(node.right)}"
+          end
+
+          def visit_SYMBOL(node)
+            node = node.to_sym
+
+            return @separator_re unless @matchers.key?(node)
+
+            re = @matchers[node]
+            "(#{Regexp.union(re)})"
+          end
+
+          def visit_GROUP(node)
+            "(?:#{visit node.left})?"
+          end
+
+          def visit_LITERAL(node)
+            Regexp.escape(node.left)
+          end
+          alias :visit_DOT :visit_LITERAL
+
+          def visit_SLASH(node)
+            node.left
+          end
+
+          def visit_STAR(node)
+            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)
+            path = visit node
+            path == "/" ? %r{\A/} : %r{\A#{path}(?:\b|\Z|/)}
+          end
+        end
+
+        class MatchData # :nodoc:
+          attr_reader :names
+
+          def initialize(names, offsets, match)
+            @names   = names
+            @offsets = offsets
+            @match   = match
+          end
+
+          def captures
+            Array.new(length - 1) { |i| self[i + 1] }
+          end
+
+          def named_captures
+            @names.zip(captures).to_h
+          end
+
+          def [](x)
+            idx = @offsets[x - 1] + x
+            @match[idx]
+          end
+
+          def length
+            @offsets.length
+          end
+
+          def post_match
+            @match.post_match
+          end
+
+          def to_s
+            @match.to_s
+          end
+        end
+
+        def match(other)
+          return unless match = to_regexp.match(other)
+          MatchData.new(names, offsets, match)
+        end
+        alias :=~ :match
+
+        def match?(other)
+          to_regexp.match?(other)
+        end
+
+        def source
+          to_regexp.source
+        end
+
+        def to_regexp
+          @re ||= regexp_visitor.new(@separators, @requirements).accept spec
+        end
+
+        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
+            @offsets ||= begin
+              offsets = [0]
+
+              spec.find_all(&:symbol?).each do |node|
+                node = node.to_sym
+
+                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
+  end
+end

data/lib/action_dispatch/journey/route.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  # :stopdoc:
+  module Journey
+    class Route
+      attr_reader :app, :path, :defaults, :name, :precedence, :constraints,
+                  :internal, :scope_options, :ast, :source_location
+
+      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
+            # 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: 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
+        @precedence        = precedence
+        @path_formatter    = @path.build_formatter
+        @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
+
+      def segments
+        path.names
+      end
+
+      def required_keys
+        required_parts + required_defaults.keys
+      end
+
+      def score(supplied_keys)
+        path.required_names.each do |k|
+          return -1 unless supplied_keys.include?(k)
+        end
+
+        (required_defaults.length * 2) + path.names.count { |k| supplied_keys.include?(k) }
+      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.ast.glob?
+      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,105 @@
+# 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.
+        #
+        #     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!("/")
+
+          unless path == "/"
+            path.delete_suffix!("/")
+            path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
+          end
+
+          path.force_encoding(encoding)
+        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).map { |i| (ENCODE % i).force_encoding(US_ASCII) }
+
+          ALPHA = "a-zA-Z"
+          DIGIT = "0-9"
+          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~"
+          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;="
+
+          ESCAPED  = /%[a-zA-Z0-9]{2}/
+
+          FRAGMENT = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/?]/
+          SEGMENT  = /[^#{UNRESERVED}#{SUB_DELIMS}:@]/
+          PATH     = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/]/
+
+          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