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 



194
195
196
 
# File 'lib/rack/query_parser.rb', line 194

def make_params
  @params_class.new
end

#new_depth_limit(param_depth_limit) ⇒ Object 



198
199
200
 
# File 'lib/rack/query_parser.rb', line 198

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.



122
123
124
 
# File 'lib/rack/query_parser.rb', line 122

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.



107
108
109
110
111
112
113
114
115
 
# File 'lib/rack/query_parser.rb', line 107

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

  each_query_pair(qs, separator) do |k, v|
    _normalize_params(params, k, v, 0)
  end

  return params.to_h
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
 
# File 'lib/rack/query_parser.rb', line 71

def parse_query(qs, separator = nil, &unescaper)
  params = make_params

  each_query_pair(qs, separator, unescaper) do |k, v|
    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_query_pairs(qs, separator = nil) ⇒ Object

Parses a query string by breaking it up at the ‘&’, returning all key-value pairs as an array of [key, value] arrays. Unlike parse_query, this preserves all duplicate keys rather than collapsing them.



92
93
94
95
96
97
98
99
100
 
# File 'lib/rack/query_parser.rb', line 92

def parse_query_pairs(qs, separator = nil)
  pairs = []

  each_query_pair(qs, separator) do |k, v|
    pairs << [k, v]
  end

  pairs
end