class Rack::QueryParser::Params

Public Class Methods

Source

# File lib/rack/query_parser.rb, line 208
def initialize(limit)
  @limit  = limit
  @size   = 0
  @params = {}
end

Public Instance Methods

[] (key)

Source

# File lib/rack/query_parser.rb, line 214
def [](key)
  @params[key]
end

[]= (key, value)

Source

# File lib/rack/query_parser.rb, line 218
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)

Source

# File lib/rack/query_parser.rb, line 224
def key?(key)
  @params.key?(key)
end

to_h ()

Source

# File lib/rack/query_parser.rb, line 246
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

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.

Also aliased as: to_params_hash

to_params_hash ()

Alias for: to_h