Class: Rack::QueryParser

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

Defined Under Namespace

Classes: InvalidParameterError, ParameterTypeError, Params, ParamsTooDeepError

Constant Summary collapse

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(params_class, param_depth_limit) ⇒ QueryParser

Returns a new instance of QueryParser.



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

def initialize(params_class, param_depth_limit)
  @params_class = params_class
  @param_depth_limit = param_depth_limit
end

Instance Attribute Details

#param_depth_limit ⇒ Object (readonly)

Returns the value of attribute param_depth_limit.



34
35
36
 
# File 'lib/rack/query_parser.rb', line 34

def param_depth_limit
  @param_depth_limit
end

Class Method Details

.make_default(param_depth_limit) ⇒ Object 



30
31
32
 
# File 'lib/rack/query_parser.rb', line 30

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

Instance Method Details

#make_params ⇒ Object 



166
167
168
 
# File 'lib/rack/query_parser.rb', line 166

def make_params
  @params_class.new
end

#new_depth_limit(param_depth_limit) ⇒ Object 



170
171
172
 
# File 'lib/rack/query_parser.rb', line 170

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.



94
95
96
 
# File 'lib/rack/query_parser.rb', line 94

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.



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/rack/query_parser.rb', line 73

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

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



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/rack/query_parser.rb', line 45

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