byp4a55 professor6T9

Linux premium22.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
LiteSpeed
68.65.122.106

File Name : query_parser.rb

# frozen_string_literal: true

require 'uri'

module Rack
  class QueryParser
    DEFAULT_SEP = /[&] */n
    COMMON_SEP = { ";" => /[;] */n, ";," => /[;,] */n, "&" => /[&] */n }

# ParameterTypeError is the error that is raised when incoming structural
    # parameters (parsed by parse_nested_query) contain conflicting types.
    class ParameterTypeError < TypeError; end

# InvalidParameterError is the error that is raised when incoming structural
    # parameters (parsed by parse_nested_query) contain invalid format or byte
    # sequence.
    class InvalidParameterError < ArgumentError; end

# ParamsTooDeepError is the error that is raised when params are recursively
    # nested over the specified limit.
    class ParamsTooDeepError < RangeError; end

def self.make_default(_key_space_limit=(not_deprecated = true; nil), param_depth_limit)
      unless not_deprecated
        warn("`first argument `key_space limit` is deprecated and no longer has an effect. Please call with only one argument, which will be required in a future version of Rack", uplevel: 1)
      end

new Params, param_depth_limit
    end

attr_reader :param_depth_limit

def initialize(params_class, _key_space_limit=(not_deprecated = true; nil), param_depth_limit)
      unless not_deprecated
        warn("`second argument `key_space limit` is deprecated and no longer has an effect. Please call with only two arguments, which will be required in a future version of Rack", uplevel: 1)
      end

@params_class = params_class
      @param_depth_limit = param_depth_limit
    end

# Stolen from Mongrel, with some small modifications:
    # Parses a query string by breaking it up at the '&'.  You can also use this
    # to parse cookies by changing the characters used in the second parameter
    # (which defaults to '&').
    def parse_query(qs, separator = nil, &unescaper)
      unescaper ||= method(:unescape)

params = make_params

(qs || '').split(separator ? (COMMON_SEP[separator] || /[#{separator}] */n) : DEFAULT_SEP).each do |p|
        next if p.empty?
        k, v = p.split('=', 2).map!(&unescaper)

if cur = params[k]
          if cur.class == Array
            params[k] << v
          else
            params[k] = [cur, v]
          end
        else
          params[k] = v
        end
      end

return params.to_h
    end

# parse_nested_query expands a query string into structural types. Supported
    # types are Arrays, Hashes and basic value types. It is possible to supply
    # query strings with parameters of conflicting types, in this case a
    # ParameterTypeError is raised. Users are encouraged to return a 400 in this
    # case.
    def parse_nested_query(qs, separator = nil)
      params = make_params

unless qs.nil? || qs.empty?
        (qs || '').split(separator ? (COMMON_SEP[separator] || /[#{separator}] */n) : DEFAULT_SEP).each do |p|
          k, v = p.split('=', 2).map! { |s| unescape(s) }

_normalize_params(params, k, v, 0)
        end
      end

return params.to_h
    rescue ArgumentError => e
      raise InvalidParameterError, e.message, e.backtrace
    end

# normalize_params recursively expands parameters into structural types. If
    # the structural types represented by two different parameter names are in
    # conflict, a ParameterTypeError is raised.  The depth argument is deprecated
    # and should no longer be used, it is kept for backwards compatibility with
    # earlier versions of rack.
    def normalize_params(params, name, v, _depth=nil)
      _normalize_params(params, name, v, 0)
    end

private def _normalize_params(params, name, v, depth)
      raise ParamsTooDeepError if depth >= param_depth_limit

if !name
        # nil name, treat same as empty string (required by tests)
        k = after = ''
      elsif depth == 0
        # Start of parsing, don't treat [] or [ at start of string specially
        if start = name.index('[', 1)
          # Start of parameter nesting, use part before brackets as key
          k = name[0, start]
          after = name[start, name.length]
        else
          # Plain parameter with no nesting
          k = name
          after = ''
        end
      elsif name.start_with?('[]')
        # Array nesting
        k = '[]'
        after = name[2, name.length]
      elsif name.start_with?('[') && (start = name.index(']', 1))
        # Hash nesting, use the part inside brackets as the key
        k = name[1, start-1]
        after = name[start+1, name.length]
      else
        # Probably malformed input, nested but not starting with [
        # treat full name as key for backwards compatibility.
        k = name
        after = ''
      end

return if k.empty?

if after == ''
        if k == '[]' && depth != 0
          return [v]
        else
          params[k] = v
        end
      elsif after == "["
        params[name] = v
      elsif after == "[]"
        params[k] ||= []
        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
        params[k] << v
      elsif after.start_with?('[]')
        # Recognize x[][y] (hash inside array) parameters
        unless after[2] == '[' && after.end_with?(']') && (child_key = after[3, after.length-4]) && !child_key.empty? && !child_key.index('[') && !child_key.index(']')
          # Handle other nested array parameters
          child_key = after[2, after.length]
        end
        params[k] ||= []
        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
        if params_hash_type?(params[k].last) && !params_hash_has_key?(params[k].last, child_key)
          _normalize_params(params[k].last, child_key, v, depth + 1)
        else
          params[k] << _normalize_params(make_params, child_key, v, depth + 1)
        end
      else
        params[k] ||= make_params
        raise ParameterTypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params_hash_type?(params[k])
        params[k] = _normalize_params(params[k], after, v, depth + 1)
      end

params
    end

def make_params
      @params_class.new
    end

def new_depth_limit(param_depth_limit)
      self.class.new @params_class, param_depth_limit
    end

private

def params_hash_type?(obj)
      obj.kind_of?(@params_class)
    end

def params_hash_has_key?(hash, key)
      return false if /\[\]/.match?(key)

key.split(/[\[\]]+/).inject(hash) do |h, part|
        next h if part == ''
        return false unless params_hash_type?(h) && h.key?(part)
        h[part]
      end

true
    end

def unescape(string, encoding = Encoding::UTF_8)
      URI.decode_www_form_component(string, encoding)
    end

class Params
      def initialize
        @size   = 0
        @params = {}
      end

def [](key)
        @params[key]
      end

def []=(key, value)
        @params[key] = value
      end

def key?(key)
        @params.key?(key)
      end

# Recursively unwraps nested `Params` objects and constructs an object
      # of the same shape, but using the objects' internal representations
      # (Ruby hashes) in place of the objects. The result is a hash consisting
      # purely of Ruby primitives.
      #
      #   Mutation warning!
      #
      #   1. This method mutates the internal representation of the `Params`
      #      objects in order to save object allocations.
      #
      #   2. The value you get back is a reference to the internal hash
      #      representation, not a copy.
      #
      #   3. Because the `Params` object's internal representation is mutable
      #      through the `#[]=` method, it is not thread safe. The result of
      #      getting the hash representation while another thread is adding a
      #      key to it is non-deterministic.
      #
      def to_h
        @params.each do |key, value|
          case value
          when self
            # Handle circular references gracefully.
            @params[key] = @params
          when Params
            @params[key] = value.to_h
          when Array
            value.map! { |v| v.kind_of?(Params) ? v.to_h : v }
          else
            # Ignore anything that is not a `Params` object or
            # a collection that can contain one.
          end
        end
        @params
      end
      alias_method :to_params_hash, :to_h
    end
  end
end

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2024-03-06 04:26:14
..	dir	-	root/root	0755	2024-03-06 04:26:14
auth	dir	-	root/root	0755	2024-03-06 04:26:14
multipart	dir	-	root/root	0755	2024-03-06 04:26:14
body_proxy.rb	text/x-ruby	1.3 KB	root/root	0644	2024-02-12 09:07:14
builder.rb	text/x-ruby	8.56 KB	root/root	0644	2024-02-12 09:07:14
cascade.rb	text/x-ruby	2.25 KB	root/root	0644	2024-02-12 09:07:14
chunked.rb	text/x-ruby	3.3 KB	root/root	0644	2024-02-12 09:07:14
common_logger.rb	text/x-ruby	3.12 KB	root/root	0644	2024-02-12 09:07:14
conditional_get.rb	text/x-ruby	2.99 KB	root/root	0644	2024-02-12 09:07:14
config.rb	text/x-ruby	410 B	root/root	0644	2024-02-12 09:07:14
constants.rb	text/x-ruby	2.47 KB	root/root	0644	2024-02-12 09:07:14
content_length.rb	text/x-ruby	806 B	root/root	0644	2024-02-12 09:07:14
content_type.rb	text/x-ruby	695 B	root/root	0644	2024-02-12 09:07:14
deflater.rb	text/x-ruby	5.51 KB	root/root	0644	2024-02-12 09:07:14
directory.rb	text/x-ruby	6.02 KB	root/root	0644	2024-02-12 09:07:14
etag.rb	text/x-ruby	1.87 KB	root/root	0644	2024-02-12 09:07:14
events.rb	text/x-ruby	4.8 KB	root/root	0644	2024-02-12 09:07:14
file.rb	text/x-ruby	167 B	root/root	0644	2024-02-12 09:07:14
files.rb	text/x-ruby	5.66 KB	root/root	0644	2024-02-12 09:07:14
head.rb	text/x-ruby	524 B	root/root	0644	2024-02-12 09:07:14
headers.rb	text/x-ruby	2.96 KB	root/root	0644	2024-02-12 09:07:14
lint.rb	text/x-ruby	36.09 KB	root/root	0755	2024-02-12 09:07:14
lock.rb	text/x-ruby	573 B	root/root	0644	2024-02-12 09:07:14
logger.rb	text/x-ruby	414 B	root/root	0644	2024-02-12 09:07:14
media_type.rb	text/x-ruby	1.4 KB	root/root	0644	2024-02-12 09:07:14
method_override.rb	text/x-ruby	1.45 KB	root/root	0644	2024-02-12 09:07:14
mime.rb	text/x-ruby	32.69 KB	root/root	0644	2024-02-12 09:07:14
mock.rb	text/plain	63 B	root/root	0644	2024-02-12 09:07:14
mock_request.rb	text/x-ruby	5.37 KB	root/root	0644	2024-02-12 09:07:14
mock_response.rb	text/x-ruby	3.28 KB	root/root	0644	2024-02-12 09:07:14
multipart.rb	text/x-ruby	1.17 KB	root/root	0644	2024-02-12 09:07:14
null_logger.rb	text/x-ruby	1.18 KB	root/root	0644	2024-02-12 09:07:14
query_parser.rb	text/x-ruby	8.37 KB	root/root	0644	2024-02-12 09:07:14
recursive.rb	text/x-ruby	1.78 KB	root/root	0644	2024-02-12 09:07:14
reloader.rb	text/x-ruby	3.02 KB	root/root	0644	2024-02-12 09:07:14
request.rb	text/x-ruby	24.57 KB	root/root	0644	2024-02-12 09:07:14
response.rb	text/x-ruby	10.72 KB	root/root	0644	2024-02-12 09:07:14
rewindable_input.rb	text/x-ruby	3.12 KB	root/root	0644	2024-02-12 09:07:14
runtime.rb	text/x-ruby	870 B	root/root	0644	2024-02-12 09:07:14
sendfile.rb	text/x-ruby	5.55 KB	root/root	0644	2024-02-12 09:07:14
show_exceptions.rb	text/x-ruby	13.73 KB	root/root	0644	2024-02-12 09:07:14
show_status.rb	text/x-ruby	3.58 KB	root/root	0644	2024-02-12 09:07:14
static.rb	text/x-ruby	6 KB	root/root	0644	2024-02-12 09:07:14
tempfile_reaper.rb	text/x-ruby	778 B	root/root	0644	2024-02-12 09:07:14
urlmap.rb	text/x-ruby	2.81 KB	root/root	0644	2024-02-12 09:07:14
utils.rb	text/x-ruby	21.1 KB	root/root	0644	2024-02-12 09:07:14
version.rb	text/x-ruby	958 B	root/root	0644	2024-02-12 09:07:14

Team Anon Force

https://t.me/Professor6T9x