Class: Mongrel2::Table

Inherits:
Object
  • Object
show all
Extended by:
Forwardable, Loggability
Defined in:
lib/mongrel2/table.rb

Overview

The Mongrel2 Table class. Instances of this class provide a case-insensitive hash-like object that can store multiple values per key.

headers = Mongrel2::Table.new
headers['User-Agent'] = 'PornBrowser 1.1.5'
headers['user-agent']  # => 'PornBrowser 1.1.5'
headers[:user_agent]   # => 'PornBrowser 1.1.5'
headers.user_agent     # => 'PornBrowser 1.1.5'

Author/s

Constant Summary collapse

KEYED_METHODS =

Methods that understand case-insensitive keys

[ :"[]", :"[]=", :delete, :fetch, :has_key?, :include?, :member?, :store ]

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(initial_values = {}) ⇒ Table

Create a new Mongrel2::Table using the given hash for initial values.



53
54
55
56
 
# File 'lib/mongrel2/table.rb', line 53

def initialize( initial_values={} )
  @hash = {}
  initial_values.each {|k,v| self.append(k => v) }
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args) ⇒ Object (protected)

Proxy method: handle getting/setting headers via methods instead of the index operator.



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/mongrel2/table.rb', line 161

def method_missing( sym, *args )
  # work magic
  return super unless sym.to_s =~ /^([a-z]\w+)(=)?$/

  # If it's an assignment, the (=)? will have matched
  key, assignment = $1, $2

  method_body = nil
  if assignment
    method_body = self.make_setter( key )
  else
    method_body = self.make_getter( key )
  end

  self.class.send( :define_method, sym, &method_body )
  return self.method( sym ).call( *args )
end

Class Method Details

.def_normalized_delegators(delegate, *syms) ⇒ Object

Auto-generate methods which call the given delegate after normalizing their first argument via normalize_key



36
37
38
39
40
41
42
43
44
 
# File 'lib/mongrel2/table.rb', line 36

def self::def_normalized_delegators( delegate, *syms )
  syms.each do |methodname|
    define_method( methodname ) do |key, *args|
      nkey = normalize_key( key )
      instance_variable_get( delegate ).
        __send__( methodname, nkey, *args )
    end
  end
end

Instance Method Details

#append(hash) ⇒ Object

Append the keys and values in the given hash to the table, transforming each value into an array if there was an existing value for the same key.



83
84
85
86
87
 
# File 'lib/mongrel2/table.rb', line 83

def append( hash )
  self.merge!( hash ) do |key,origval,newval|
    [ origval, newval ].flatten
  end
end

#each_header(&block) ⇒ Object

Enumerator for iterating over the table contents, yielding each as an RFC822 header.



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/mongrel2/table.rb', line 104

def each_header( &block )
  enum = Enumerator.new do |yielder|
    @hash.each do |header, value|
      Array( value ).each do |val|
        yielder.yield( normalize_header(header), val.to_s )
      end
    end
  end

  if block
    return enum.each( &block )
  else
    return enum
  end
end

#initialize_copy ⇒ Object

Make sure the inner Hash is unique on duplications.



60
61
62
 
# File 'lib/mongrel2/table.rb', line 60

def initialize_copy( * ) # :nodoc:
  @hash = deep_copy( @hash )
end

#merge(other_table, &merge_callback) ⇒ Object Also known as: update

Return a new table which is the result of merging the receiver with other_table in the same fashion as Hash#merge. If the optional merge_callback block is provided, it is called whenever there is a key collision between the two.



140
141
142
143
144
 
# File 'lib/mongrel2/table.rb', line 140

def merge( other_table, &merge_callback ) # :yields: key, original_value, new_value
  other = self.dup
  other.merge!( other_table, &merge_callback )
  return other
end

#merge!(other_table, &merge_callback) ⇒ Object Also known as: update!

Merge other_table into the receiver.



129
130
131
132
 
# File 'lib/mongrel2/table.rb', line 129

def merge!( other_table, &merge_callback )
  nhash = normalize_hash( other_table.to_hash )
  @hash.merge!( nhash, &merge_callback )
end

#to_h ⇒ Object Also known as: to_hash

Return the Table as a hash.



122
123
124
 
# File 'lib/mongrel2/table.rb', line 122

def to_h
  @hash.dup
end

#to_s ⇒ Object

Return the Table as RFC822 headers in a String



91
92
93
94
95
96
97
98
99
100
 
# File 'lib/mongrel2/table.rb', line 91

def to_s
  @hash.collect do |header,value|
    Array( value ).collect {|val|
      "%s: %s" % [
        normalize_header( header ),
        val
      ]
    }
  end.flatten.sort.join( "\r\n" ) + "\r\n"
end

#values_at(*keys) ⇒ Object

Return an array containing the values associated with the given keys.



150
151
152
 
# File 'lib/mongrel2/table.rb', line 150

def values_at( *keys )
  @hash.values_at( *(keys.collect {|k| normalize_key(k)}) )
end