class Headers

def self.[] headers
	if headers.nil?
		return self.new
	end
	
	if headers.is_a?(self)
		if headers.frozen?
			return headers.dup
		else
			return headers
		end
	end
	
	fields = headers.to_a
	
	if fields.frozen?
		fields = fields.dup
	end
	
	return self.new(fields)
end

parameter　key　String

The header key.

returns　String | Array | Object

The header value.

def [] key
	to_h[key]
end

parameter　fields　Array

An array of [key, value] pairs.

parameter　indexed　Hash

A hash table of normalized headers, if available.

def initialize(fields = [], indexed = nil)
	@fields = fields
	@indexed = indexed
	
	# Marks where trailer start in the @fields array.
	@tail = nil
end

parameter　other　Headers

The headers to copy.

def initialize_dup(other)
	super
	
	@fields = @fields.dup
	@indexed = @indexed.dup
end

def clear
	@fields.clear
	@indexed = nil
	@tail = nil
end

def flatten!
	if @tail
		self.delete(TRAILER)
		@tail = nil
	end
	
	return self
end

def flatten
	self.dup.flatten!
end

attribute　Array

An array of [key, value] pairs.

returns　Boolean

Whether there are any trailers.

def trailer?
	@tail != nil
end

parameter　names　Array

The trailer header names which will be added later.

yields　{|name, value| ...}

the trailing headers if a block is given.

def trailer!(&block)
	@tail ||= @fields.size
	
	return trailer(&block)
end

def trailer(&block)
	return to_enum(:trailer) unless block_given?
	
	if @tail
		@fields.drop(@tail).each(&block)
	end
end

def freeze
	return if frozen?
	
	# Ensure @indexed is generated:
	self.to_h
	
	@fields.freeze
	@indexed.freeze
	
	super
end

returns　Boolean

Whether the headers are empty.

def empty?
	@fields.empty?
end

yields　{|key, value| ...}

parameter　key　String

The header key.

parameter　value　String

The header value.

def each(&block)
	@fields.each(&block)
end

returns　Boolean

Whether the headers include the specified key.

def include? key
	self[key] != nil
end

returns　Array

All the keys of the headers.

def keys
	self.to_h.keys
end

parameter　keys　Array

The keys to extract.

def extract(keys)
	deleted, @fields = @fields.partition do |field|
		keys.include?(field.first.downcase)
	end
	
	if @indexed
		keys.each do |key|
			@indexed.delete(key)
		end
	end
	
	return deleted
end

parameter　key　String

the header key.

parameter　value　String

the header value to assign.

def add(key, value)
	self[key] = value
end

parameter　key　String

the header key to replace.

parameter　value　String

the header value to assign.

def set(key, value)
	# TODO This could be a bit more efficient:
	self.delete(key)
	self.add(key, value)
end

def merge!(headers)
	headers.each do |key, value|
		self[key] = value
	end
	
	return self
end

def merge(headers)
	self.dup.merge!(headers)
end

parameter　key　String

The header key.

parameter　value　String

The header value.

def []= key, value
	if @indexed
		merge_into(@indexed, key.downcase, value)
	end
	
	@fields << [key, value]
end

POLICY = {
	# Headers which may only be specified once:
	"content-type" => false,
	"content-disposition" => false,
	"content-length" => false,
	"user-agent" => false,
	"referer" => false,
	"host" => false,
	"from" => false,
	"location" => false,
	"max-forwards" => false,
	"retry-after" => false,
	
	# Custom headers:
	"connection" => Header::Connection,
	"cache-control" => Header::CacheControl,
	"vary" => Header::Vary,
	"priority" => Header::Priority,
	
	# Headers specifically for proxies:
	"via" => Split,
	"x-forwarded-for" => Split,
	
	# Authorization headers:
	"authorization" => Header::Authorization,
	"proxy-authorization" => Header::Authorization,
	
	# Cache validations:
	"etag" => Header::ETag,
	"if-match" => Header::ETags,
	"if-none-match" => Header::ETags,
	
	# Headers which may be specified multiple times, but which can't be concatenated:
	"www-authenticate" => Multiple,
	"proxy-authenticate" => Multiple,
	
	# Custom headers:
	"set-cookie" => Header::SetCookie,
	"cookie" => Header::Cookie,
	
	# Date headers:
	# These headers include a comma as part of the formatting so they can't be concatenated.
	"date" => Header::Date,
	"expires" => Header::Date,
	"last-modified" => Header::Date,
	"if-modified-since" => Header::Date,
	"if-unmodified-since" => Header::Date,
}.tap{|hash| hash.default = Split}

parameter　key　String

The header key.

returns　String | Array | Object

The merged header value.

def delete(key)
	deleted, @fields = @fields.partition do |field|
		field.first.downcase == key
	end
	
	if deleted.empty?
		return nil
	end
	
	if @indexed
		return @indexed.delete(key)
	elsif policy = POLICY[key]
		(key, value), *tail = deleted
		merged = policy.new(value)
		
		tail.each{|k,v| merged << v}
		
		return merged
	else
		key, value = deleted.last
		return value
	end
end

returns　Hash

A hash table of {key, value} pairs.

def to_h
	@indexed ||= @fields.inject({}) do |hash, (key, value)|
		merge_into(hash, key.downcase, value)
		
		hash
	end
end

returns　String

A string representation of the headers.

def inspect
	"#<#{self.class} #{@fields.inspect}>"
end

returns　Boolean

Whether the other object is equal to this one.

def == other
	case other
	when Hash
		to_h == other
	when Headers
		@fields == other.fields
	else
		@fields == other
	end
end