actionpack 6.0.0

data/lib/action_dispatch/journey/parser.y

@@ -0,0 +1,50 @@
+class ActionDispatch::Journey::Parser
+  options no_result_var
+token SLASH LITERAL SYMBOL LPAREN RPAREN DOT STAR OR
+
+rule
+  expressions
+    : expression expressions  { Cat.new(val.first, val.last) }
+    | expression              { val.first }
+    | or
+    ;
+  expression
+    : terminal
+    | group
+    | star
+    ;
+  group
+    : LPAREN expressions RPAREN { Group.new(val[1]) }
+    ;
+  or
+    : expression OR expression { Or.new([val.first, val.last]) }
+    | expression OR or { Or.new([val.first, val.last]) }
+    ;
+  star
+    : STAR       { Star.new(Symbol.new(val.last)) }
+    ;
+  terminal
+    : symbol
+    | literal
+    | slash
+    | dot
+    ;
+  slash
+    : SLASH              { Slash.new(val.first) }
+    ;
+  symbol
+    : SYMBOL             { Symbol.new(val.first) }
+    ;
+  literal
+    : LITERAL            { Literal.new(val.first) }
+    ;
+  dot
+    : DOT                { Dot.new(val.first) }
+    ;
+
+end
+
+---- header
+# :stopdoc:
+
+require "action_dispatch/journey/parser_extras"

data/lib/action_dispatch/journey/parser_extras.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "action_dispatch/journey/scanner"
+require "action_dispatch/journey/nodes/node"
+
+module ActionDispatch
+  # :stopdoc:
+  module Journey
+    class Parser < Racc::Parser
+      include Journey::Nodes
+
+      def self.parse(string)
+        new.parse string
+      end
+
+      def initialize
+        @scanner = Scanner.new
+      end
+
+      def parse(string)
+        @scanner.scan_setup(string)
+        do_parse
+      end
+
+      def next_token
+        @scanner.next_token
+      end
+    end
+  end
+  # :startdoc:
+end

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module Path # :nodoc:
+      class Pattern # :nodoc:
+        attr_reader :spec, :requirements, :anchored
+
+        def self.from_string(string)
+          build(string, {}, "/.?", true)
+        end
+
+        def self.build(path, requirements, separators, anchored)
+          parser = Journey::Parser.new
+          ast = parser.parse path
+          new ast, requirements, separators, anchored
+        end
+
+        def initialize(ast, requirements, separators, anchored)
+          @spec         = ast
+          @requirements = requirements
+          @separators   = separators
+          @anchored     = anchored
+
+          @names          = nil
+          @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
+          nil
+        end
+
+        def ast
+          @spec.find_all(&:symbol?).each do |node|
+            re = @requirements[node.to_sym]
+            node.regexp = re if re
+          end
+
+          @spec.find_all(&:star?).each do |node|
+            node = node.left
+            node.regexp = @requirements[node.to_sym] || /(.+)/
+          end
+
+          @spec
+        end
+
+        def names
+          @names ||= spec.find_all(&:symbol?).map(&:name)
+        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)].join
+          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})"
+          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 source
+          to_regexp.source
+        end
+
+        def to_regexp
+          @re ||= regexp_visitor.new(@separators, @requirements).accept spec
+        end
+
+        private
+
+          def regexp_visitor
+            @anchored ? AnchoredRegexp : UnanchoredRegexp
+          end
+
+          def offsets
+            return @offsets if @offsets
+
+            @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

data/lib/action_dispatch/journey/route.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  # :stopdoc:
+  module Journey
+    class Route
+      attr_reader :app, :path, :defaults, :name, :precedence, :constraints,
+                  :internal, :scope_options
+
+      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, scope_options, 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
+        @scope_options     = scope_options
+        @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