class HTTP::Headers

def self.coerce(object)

Returns:
  • (Headers) -

Parameters:
  • object (#to_hash, #to_h, #to_a) --

Raises:
  • (Error) - if given object can't be coerced 
def self.coerce(object)
  unless object.is_a? self
    object = case
            when object.respond_to?(:to_hash) then object.to_hash
            when object.respond_to?(:to_h)    then object.to_h
            when object.respond_to?(:to_a)    then object.to_a
            else fail Error, "Can't coerce #{object.inspect} to Headers"
            end
  end
  headers = new
  object.each { |k, v| headers.add k, v }
  headers
end

def ==(other)

Returns:
  • (Boolean) - 
def ==(other)
  return false unless other.respond_to? :to_a
  @pile == other.to_a
end

def [](name)

Returns:
  • (Array) - if header has more than one value
  • (Object) - if header has exactly one value
  • (NilClass) - if header was not set 
    • def [](name)
  values = get(name)
  case values.count
  when 0 then nil
  when 1 then values.first
  else        values
  end
end

    def add(name, value)

    Returns:
    • (void) - 
    def add(name, value)
  name = canonicalize_header name.to_s
  Array(value).each { |v| @pile << [name, v] }
end

    def canonicalize_header(name)

    Returns:
    • (String) -

    Parameters:
    • name (String) -- 
    def canonicalize_header(name)
  name[CANONICAL_HEADER] || name.split(/[\-_]/).map(&:capitalize).join('-')
end

    def delete(name)

    Returns:
    • (void) - 
    def delete(name)
  name = canonicalize_header name.to_s
  @pile.delete_if { |k, _| k == name }
end

    def get(name)

    Returns:
    • (Array) - 
    def get(name)
  name = canonicalize_header name.to_s
  @pile.select { |k, _| k == name }.map { |_, v| v }
end

    def initialize

    :nodoc: 
    def initialize
  @pile = []
end

    def initialize_copy(orig)

    :nodoc: 
    def initialize_copy(orig)
  super
  @pile = to_a
end

    def inspect

    :nodoc: 
    def inspect
  "#<#{self.class} #{to_h.inspect}>"
end

    def keys

    Returns:
    • (Array) - 
    def keys
  @pile.map { |k, _| k }.uniq
end

    def merge(other)

    Returns:
    • (Headers) -

    Other tags:
      See: #merge! - 
    def merge(other)
  dup.tap { |dupped| dupped.merge! other }
end

    def merge!(other)

    Returns:
    • (void) -

    Other tags:
      See: #merge - 
    def merge!(other)
  self.class.coerce(other).to_h.each { |name, values| set name, values }
end

    def set(name, value)

    Returns:
    • (void) - 
    def set(name, value)
  delete(name)
  add(name, value)
end

    def to_a

    Returns:
    • (Array<[String, String]>) - 
    def to_a
  @pile.map { |pair| pair.map(&:dup) }
end

    def to_h

    Returns:
    • (Hash) - 
    def to_h
  Hash[keys.map { |k| [k, self[k]] }]
end