Class: CaselessHash

Inherits:
Hash
  • Object
show all
Defined in:
lib/caselesshash.rb

Overview

Creating our own caseless subclass of Hash.

Instance Method Summary collapse

Constructor Details

#initialize(hash = nil) ⇒ CaselessHash

Returns a new instance of CaselessHash.



3
4
5
6
7
 
# File 'lib/caselesshash.rb', line 3

def initialize(hash = nil)
  super
  @table = {}
  hash.each { |key,value| store(key, value) } if hash.kind_of?(Hash)
end

Instance Method Details

#[](key) ⇒ Object 



9
10
11
12
13
 
# File 'lib/caselesshash.rb', line 9

def [](key)
  lowkey = key.to_s.downcase
  lowkey = @table.key?(lowkey) ? @table[lowkey] : key
  super lowkey
end

#[]=(key, value) ⇒ Object 



15
16
17
 
# File 'lib/caselesshash.rb', line 15

def []=(key, value)
  store(key, value)
end

#clear ⇒ Object 



26
27
28
29
 
# File 'lib/caselesshash.rb', line 26

def clear
  super
  @table.clear
end

#default(key = nil) ⇒ Object 



31
32
33
34
35
 
# File 'lib/caselesshash.rb', line 31

def default(key = nil)
  lowkey = key ? key.to_s.downcase : nil
  lowkey = @table[lowkey] if @table.key?(lowkey)
  super(lowkey)
end

#delete(key, &block) ⇒ Object 



37
38
39
40
41
42
43
44
45
 
# File 'lib/caselesshash.rb', line 37

def delete(key, &block)
  lowkey = key.to_s.downcase
  if @table.key?(lowkey)
    super(@table[lowkey])
    @table.delete(lowkey)
  elsif block_given?
    block.call(key)
  end
end

#delete_if(&block) ⇒ Object 



47
48
49
50
51
52
53
 
# File 'lib/caselesshash.rb', line 47

def delete_if(&block)
  super do |key, value|
    bool = block.call(key, value)
    @table.delete(@table.index(key)) if bool
    bool
  end
end

#fetch(key, default = nil, &block) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/caselesshash.rb', line 55

def fetch(key, default = nil, &block)
  lowkey = key.to_s.downcase
  lowkey = @table.key?(lowkey) ? @table[lowkey] : key

  if block_given?
    super(lowkey, &block)
  elsif default
    super(lowkey, default)
  else
    super(lowkey)
  end
end

#has_key?(key) ⇒ Boolean Also known as: key?, include?, member?

Returns:

  • (Boolean) 


72
73
74
 
# File 'lib/caselesshash.rb', line 72

def has_key?(key)
  @table.key?(key.to_s.downcase)
end

#invert ⇒ Object 



76
77
78
79
80
81
 
# File 'lib/caselesshash.rb', line 76

def invert
  hsh    = super
  keys   = hsh.keys
  @table = Hash[*[keys.map { |key| key.to_s.downcase }, keys].transpose.flatten]
  hsh
end

#merge(hsh, &block) ⇒ Object 



88
89
90
91
 
# File 'lib/caselesshash.rb', line 88

def merge(hsh, &block)
  this = dup
  this.merge!(hsh, &block)
end

#merge!(hsh, &block) ⇒ Object Also known as: update 



93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/caselesshash.rb', line 93

def merge!(hsh, &block)
  hsh.each do |key, value|
    lowkey = key.to_s.downcase
    if @table.key?(lowkey)
      block.call(@table[lowkey], fetch(@table[lowkey]), value) if block_given?
      delete(key)
      store(key, value)
    end
  end
  self
end

#replace(hsh) ⇒ Object 



68
69
70
 
# File 'lib/caselesshash.rb', line 68

def replace(hsh)
  super(self.class.new(hsh))
end

#store(key, value) ⇒ Object 



19
20
21
22
23
24
 
# File 'lib/caselesshash.rb', line 19

def store(key, value)
  lowkey = key.to_s.downcase
  delete(key) if @table.key?(lowkey)
  @table[lowkey] = key
  super(@table[lowkey], value)
end

#to_hash ⇒ Object 



105
106
107
 
# File 'lib/caselesshash.rb', line 105

def to_hash
  Hash[*to_a.flatten]
end

#values_at(*keys) ⇒ Object 



83
84
85
86
 
# File 'lib/caselesshash.rb', line 83

def values_at(*keys)
  keys_ = keys.map { |key| @table.key?(lowkey = key.to_s.downcase) ? @table[lowkey] : key }
  super(*keys_)
end