tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/actionpack-8.0.4/lib/action_dispatch/journey/nodes/node.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-# :markup: markdown
-
-require "action_dispatch/journey/visitors"
-
-module ActionDispatch
-  module Journey # :nodoc:
-    class Ast # :nodoc:
-      attr_reader :names, :path_params, :tree, :wildcard_options, :terminals
-      alias :root :tree
-
-      def initialize(tree, formatted)
-        @tree = tree
-        @path_params = []
-        @names = []
-        @symbols = []
-        @stars = []
-        @terminals = []
-        @wildcard_options = {}
-
-        visit_tree(formatted)
-      end
-
-      def requirements=(requirements)
-        # inject any regexp requirements for `star` nodes so they can be determined
-        # nullable, which requires knowing if the regex accepts an empty string.
-        (symbols + stars).each do |node|
-          re = requirements[node.to_sym]
-          node.regexp = re if re
-        end
-      end
-
-      def route=(route)
-        terminals.each { |n| n.memo = route }
-      end
-
-      def glob?
-        stars.any?
-      end
-
-      private
-        attr_reader :symbols, :stars
-
-        def visit_tree(formatted)
-          tree.each do |node|
-            if node.symbol?
-              path_params << node.to_sym
-              names << node.name
-              symbols << node
-            elsif node.star?
-              stars << node
-
-              if formatted != false
-                # Add a constraint for wildcard route to make it non-greedy and match the
-                # optional format part of the route by default.
-                wildcard_options[node.name.to_sym] ||= /.+?/m
-              end
-            end
-
-            if node.terminal?
-              terminals << node
-            end
-          end
-        end
-    end
-
-    module Nodes # :nodoc:
-      class Node # :nodoc:
-        include Enumerable
-
-        attr_accessor :left, :memo
-
-        def initialize(left)
-          @left = left
-          @memo = nil
-        end
-
-        def each(&block)
-          Visitors::Each::INSTANCE.accept(self, block)
-        end
-
-        def to_s
-          Visitors::String::INSTANCE.accept(self, "")
-        end
-
-        def to_dot
-          Visitors::Dot::INSTANCE.accept(self)
-        end
-
-        def to_sym
-          name.to_sym
-        end
-
-        def name
-          -left.tr("*:", "")
-        end
-
-        def type
-          raise NotImplementedError
-        end
-
-        def symbol?; false; end
-        def literal?; false; end
-        def terminal?; false; end
-        def star?; false; end
-        def cat?; false; end
-        def group?; false; end
-      end
-
-      class Terminal < Node # :nodoc:
-        alias :symbol :left
-        def terminal?; true; end
-      end
-
-      class Literal < Terminal # :nodoc:
-        def literal?; true; end
-        def type; :LITERAL; end
-      end
-
-      class Dummy < Literal # :nodoc:
-        def initialize(x = Object.new)
-          super
-        end
-
-        def literal?; false; end
-      end
-
-      class Slash < Terminal # :nodoc:
-        def type; :SLASH; end
-      end
-
-      class Dot < Terminal # :nodoc:
-        def type; :DOT; end
-      end
-
-      class Symbol < Terminal # :nodoc:
-        attr_accessor :regexp
-        alias :symbol :regexp
-        attr_reader :name
-
-        DEFAULT_EXP = /[^.\/?]+/
-        GREEDY_EXP = /(.+)/
-        def initialize(left, regexp = DEFAULT_EXP)
-          super(left)
-          @regexp = regexp
-          @name = -left.tr("*:", "")
-        end
-
-        def type; :SYMBOL; end
-        def symbol?; true; end
-      end
-
-      class Unary < Node # :nodoc:
-        def children; [left] end
-      end
-
-      class Group < Unary # :nodoc:
-        def type; :GROUP; end
-        def group?; true; end
-      end
-
-      class Star < Unary # :nodoc:
-        attr_accessor :regexp
-
-        def initialize(left)
-          super(left)
-
-          # By default wildcard routes are non-greedy and must match something.
-          @regexp = /.+?/m
-        end
-
-        def star?; true; end
-        def type; :STAR; end
-
-        def name
-          left.name.tr "*:", ""
-        end
-      end
-
-      class Binary < Node # :nodoc:
-        attr_accessor :right
-
-        def initialize(left, right)
-          super(left)
-          @right = right
-        end
-
-        def children; [left, right] end
-      end
-
-      class Cat < Binary # :nodoc:
-        def cat?; true; end
-        def type; :CAT; end
-      end
-
-      class Or < Node # :nodoc:
-        attr_reader :children
-
-        def initialize(children)
-          @children = children
-        end
-
-        def type; :OR; end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/actionpack-8.0.4/lib/action_dispatch/journey/route.rb

@@ -1,189 +0,0 @@
-# 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/vendor/bundle/ruby/3.4.0/gems/actionpack-8.0.4/lib/action_dispatch/journey/router/utils.rb

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

data/vendor/bundle/ruby/3.4.0/gems/actionpack-8.0.4/lib/action_dispatch/journey/router.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-# :markup: markdown
-
-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) 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
-
-          tmp_params = set_params.merge route.defaults
-          parameters.each_pair { |key, val|
-            tmp_params[key] = val.force_encoding(::Encoding::UTF_8)
-          }
-
-          req.path_parameters = tmp_params
-          req.route_uri_pattern = route.path.spec.to_s
-
-          _, headers, _ = response = route.app.serve(req)
-
-          if "pass" == headers[Constants::X_CASCADE]
-            req.script_name     = script_name
-            req.path_info       = path_info
-            req.path_parameters = set_params
-            next
-          end
-
-          return response
-        end
-
-        [404, { Constants::X_CASCADE => "pass" }, ["Not Found"]]
-      end
-
-      def recognize(rails_req)
-        find_routes(rails_req) do |match, parameters, route|
-          unless route.path.anchored
-            rails_req.script_name = match.to_s
-            rails_req.path_info   = match.post_match
-            rails_req.path_info   = "/" + rails_req.path_info unless rails_req.path_info.start_with? "/"
-          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.path.requirements_anchored?
-          }
-        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)
-          path_info = req.path_info
-          routes = filter_routes(path_info).concat custom_routes.find_all { |r|
-            r.path.match?(path_info)
-          }
-
-          if req.head?
-            routes = match_head_routes(routes, req)
-          else
-            routes.select! { |r| r.matches?(req) }
-          end
-
-          routes.sort_by!(&:precedence)
-
-          routes.each { |r|
-            match_data = r.path.match(path_info)
-            path_parameters = {}
-            match_data.names.each_with_index { |name, i|
-              val = match_data[i + 1]
-              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
-            }
-            yield [match_data, path_parameters, r]
-          }
-        end
-
-        def match_head_routes(routes, req)
-          head_routes = routes.select { |r| r.requires_matching_verb? && r.matches?(req) }
-          return head_routes unless head_routes.empty?
-
-          begin
-            req.request_method = "GET"
-            routes.select! { |r| r.matches?(req) }
-            routes
-          ensure
-            req.request_method = "HEAD"
-          end
-        end
-    end
-  end
-end