Class: Rack::QueryParser::Params

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

Instance Method Summary collapse

Constructor Details

#initialize(limit) ⇒ Params

Returns a new instance of Params.



163
164
165
166
167
 
# File 'lib/rack/query_parser.rb', line 163

def initialize(limit)
  @limit  = limit
  @size   = 0
  @params = {}
end

Instance Method Details

#[](key) ⇒ Object 



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

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

#[]=(key, value) ⇒ Object

Raises:



173
174
175
176
177
 
# File 'lib/rack/query_parser.rb', line 173

def []=(key, value)
  @size += key.size if key && !@params.key?(key)
  raise ParamsTooDeepError, 'exceeded available parameter key space' if @size > @limit
  @params[key] = value
end

#key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


179
180
181
 
# File 'lib/rack/query_parser.rb', line 179

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

#to_h ⇒ Object Also known as: to_params_hash

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.



201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/rack/query_parser.rb', line 201

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