Class: Rack::QueryParser

Inherits:
Object
  • Object
show all
Defined in:
lib/rack/query_parser.rb

Defined Under Namespace

Classes: InvalidParameterError, ParameterTypeError, Params, QueryLimitError

Constant Summary collapse

DEFAULT_SEP = 
/& */n
COMMON_SEP = 
{ ";" => /; */n, ";," => /[;,] */n, "&" => /& */n }
ParamsTooDeepError =

ParamsTooDeepError is the old name for the error that is raised when params are recursively nested over the specified limit. Make it the same as as QueryLimitError, so that code that rescues ParamsTooDeepError error to handle bad query strings also now handles other limits.

QueryLimitError

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(params_class, param_depth_limit, bytesize_limit: BYTESIZE_LIMIT, params_limit: PARAMS_LIMIT) ⇒ QueryParser

Returns a new instance of QueryParser.



60
61
62
63
64
65
 
# File 'lib/rack/query_parser.rb', line 60

def initialize(params_class, param_depth_limit, bytesize_limit: BYTESIZE_LIMIT, params_limit: PARAMS_LIMIT)
  @params_class = params_class
  @param_depth_limit = param_depth_limit
  @bytesize_limit = bytesize_limit
  @params_limit = params_limit
end

Instance Attribute Details

#param_depth_limit ⇒ Object (readonly)

Returns the value of attribute param_depth_limit.



40
41
42
 
# File 'lib/rack/query_parser.rb', line 40

def param_depth_limit
  @param_depth_limit
end

Class Method Details

.make_default(param_depth_limit, **options) ⇒ Object 



36
37
38
 
# File 'lib/rack/query_parser.rb', line 36

def self.make_default(param_depth_limit, **options)
  new(Params, param_depth_limit, **options)
end

Instance Method Details

#make_params ⇒ Object 



192
193
194
 
# File 'lib/rack/query_parser.rb', line 192

def make_params
  @params_class.new
end

#new_depth_limit(param_depth_limit) ⇒ Object 



196
197
198
 
# File 'lib/rack/query_parser.rb', line 196

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

#normalize_params(params, name, v, _depth = nil) ⇒ Object

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.



120
121
122
 
# File 'lib/rack/query_parser.rb', line 120

def normalize_params(params, name, v, _depth=nil)
  _normalize_params(params, name, v, 0)
end

#parse_nested_query(qs, separator = nil) ⇒ Object

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.



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/rack/query_parser.rb', line 99

def parse_nested_query(qs, separator = nil)
  params = make_params

  unless qs.nil? || qs.empty?
    check_query_string(qs, separator).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

#parse_query(qs, separator = nil, &unescaper) ⇒ Object

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 ‘&’).



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/rack/query_parser.rb', line 71

def parse_query(qs, separator = nil, &unescaper)
  unescaper ||= method(:unescape)

  params = make_params

  check_query_string(qs, separator).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