Class: Hash::NormalizeKeys

Inherits:
Object
  • Object
show all
Defined in:
lib/hash/normalizekeys.rb

Overview

Hash::NormalizeKeys

Direct Known Subclasses

String

Constant Summary collapse

VERSION =

version

'1.3'

Instance Method Summary collapse

Constructor Details

#initialize(*opts, &block) ⇒ NormalizeKeys

new() takes the same params as Hash.new.



9
10
11
 
# File 'lib/hash/normalizekeys.rb', line 9

def initialize(*opts, &block)
  @hsh = Hash.new(*opts, &block)
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *args, &block) ⇒ Object (private)

All methods not already defined are passed to @hsh. If the method is listed in COERCES then the first arg is normalized.



115
116
117
118
119
120
121
122
 
# File 'lib/hash/normalizekeys.rb', line 115

def method_missing(m, *args, &block)
  if COERCES.include?(m.to_s) and (args.length > 0)
    args = *args
    args[0] = self.class.normalize_key(args[0])
  end
  
  return @hsh.send(m, *args, &block)
end

Instance Method Details

#invert ⇒ Object

Works like Hash#invert, except the new object is a NormalizeKey object and the keys have been normalized.



83
84
85
86
87
88
89
90
91
 
# File 'lib/hash/normalizekeys.rb', line 83

def invert
  rv = self.class.new
  
  self.each do |k, v|
    rv[v] = k
  end
  
  return rv
end

#merge(other) ⇒ Object

Returns a new NormalizeKeys object by combining this object and the other object, with keys being normalized.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/hash/normalizekeys.rb', line 20

def merge(other)
  rv = self.class.new
  
  # initialize with own elements
  self.each do |k, v|
    rv[k] = v
  end
  
  # merge in other's elements
  other.each do |k, v|
    rv[k] = v
  end
  
  # return
  return rv
end

#merge!(other) ⇒ Object Also known as: update

Merges other into the NormalizeKey object, with other’s keys being normalized.



38
39
40
41
42
43
44
45
46
 
# File 'lib/hash/normalizekeys.rb', line 38

def merge!(other)
  # merge in other's elements
  other.each do |k, v|
    self[k] = v
  end
  
  # return
  return self
end

#replace(other) ⇒ Object

Works like Hash#replace, with keys being normalized.



52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/hash/normalizekeys.rb', line 52

def replace(other)
  # reset @hsh
  @hsh.clear
  
  # merge in other's elements
  other.each do |k, v|
    self[k] = v
  end
  
  # return
  return self
end

#respond_to?(m) ⇒ Boolean

Returns the underlying hash’s respond_to? method.

Returns:

  • (Boolean) 


14
15
16
 
# File 'lib/hash/normalizekeys.rb', line 14

def respond_to?(m)
  return @hsh.respond_to?(m)
end

#slice(*org_keys) ⇒ Object

Works just like Hash#slice, except the key values are normalized.



66
67
68
69
70
71
72
73
74
 
# File 'lib/hash/normalizekeys.rb', line 66

def slice(*org_keys)
  use_keys = {}
  
  org_keys.each do |org_key|
    use_keys[self.class.normalize_key(org_key)] = nil
  end
  
  return @hsh.slice(*use_keys.keys)
end

#to_s ⇒ Object

Returns the results of the underlying hash’s to_s method.



77
78
79
 
# File 'lib/hash/normalizekeys.rb', line 77

def to_s
  return @hsh.to_s
end

#values_at(*keys) ⇒ Object

Works like Hash#values_at, except the key values are normalized.



94
95
96
97
98
99
100
101
102
 
# File 'lib/hash/normalizekeys.rb', line 94

def values_at(*keys)
  rv = []
  
  keys.each do |key|
    rv.push self[key]
  end
  
  return rv
end