jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/lib/action_dispatch/journey/parser.y

@@ -1,50 +0,0 @@
-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/vendor/rails/actionpack/lib/action_dispatch/journey/parser_extras.rb

@@ -1,31 +0,0 @@
-# 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/vendor/rails/actionpack/lib/action_dispatch/journey/path/pattern.rb

@@ -1,198 +0,0 @@
-# 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]
-            "(#{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)
-            %r{\A#{visit node}}
-          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 [](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 = /#{@requirements[node]}|/
-                @offsets.push((re.match("").length - 1) + @offsets.last)
-              else
-                @offsets << @offsets.last
-              end
-            end
-
-            @offsets
-          end
-      end
-    end
-  end
-end

data/vendor/rails/actionpack/lib/action_dispatch/journey/route.rb

@@ -1,203 +0,0 @@
-# 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