Class: Hash

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

Defined Under Namespace

Classes: DeepHashConstructor, KeyChanger, ValueChanger

Instance Method Summary collapse

Instance Method Details

#append_to_keys(str, options = {}) ⇒ Object

append a string to all keys options 

recursive: true,
type: :keep [keep, string, symbol] (key type to be returned)

ex: { :a => 1, “b”=> 2 }.append_to_keys(“_bar”) == { :a_bar => 1, “b_bar”=> 2 }



115
116
117
118
119
 
# File 'lib/hash.rb', line 115

def append_to_keys(str, options = {})
  change_key_text(options) do |key|
    "#{key}#{str}"
  end
end

#camelize_keys(options = {}) ⇒ Object 



59
60
61
 
# File 'lib/hash.rb', line 59

def camelize_keys(options = {})
  dup.camelize_keys!(options)
end

#camelize_keys!(options = {}) ⇒ Object 



63
64
65
 
# File 'lib/hash.rb', line 63

def camelize_keys!(options = {})
  Hash::KeyChanger.new(self).camelize_keys(options)
end

#chain_fetch(*keys) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/hash.rb', line 6

def chain_fetch(*keys)
  value = self

  if block_given?
    value = value.fetch(keys.shift) do |*args|
      missed_keys = keys
      keys = []
      yield(*(args + [missed_keys]))
    end until keys.empty?
  else
    value = value.fetch(keys.shift) until keys.empty?
  end

  value
end

#change_keys(options = {}, &block) ⇒ Object

change all keys returning the new map options: { recursive: true } ex: { “a”:1 }.change_keys{ |key| key.upcase } == { “A”:1 }



86
87
88
 
# File 'lib/hash.rb', line 86

def change_keys(options = {}, &block)
  deep_dup.change_keys!(options, &block)
end

#change_keys!(options = {}, &block) ⇒ Object

change all keys returning the new map options: { recursive: true } ex: { “a”:1 }.change_keys{ |key| key.upcase } == { “A”:1 }



93
94
95
 
# File 'lib/hash.rb', line 93

def change_keys!(options = {}, &block)
  Hash::KeyChanger.new(self).change_keys(options, &block)
end

#change_values(options = {}, &block) ⇒ Object

creates a new hash with changes in its values options: 

recursive: true,
skip_hash:true

ex: { a:1, b:2 }.change_values{ |v| v+1 } == { a:2, b:3 } ex: { a:1, b:{ c:1 } }.change_values(skip_hash:false) { |v| v.to_s } == { a:“1”, b:“{ c=>1 } ex: { a:1, b:{ c:1 } }.change_values(skip_hash:true) { |v| v.to_s } == { a:”1“, b:{ c=>”1“ } }



146
147
148
 
# File 'lib/hash.rb', line 146

def change_values(options = {}, &block)
  deep_dup.change_values!(options, &block)
end

#change_values!(options = {}, &block) ⇒ Object 



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

def change_values!(options = {}, &block)
  Hash::ValueChanger.new(options, &block).change(self)
end

#exclusive_merge(hash) ⇒ Object 



75
76
77
 
# File 'lib/hash.rb', line 75

def exclusive_merge(hash)
  dup.exclusive_merge!(hash)
end

#exclusive_merge!(hash) ⇒ Object 



79
80
81
 
# File 'lib/hash.rb', line 79

def exclusive_merge!(hash)
  merge!(hash.slice(*keys))
end

#lower_camelize_keys(options = {}) ⇒ Object 



49
50
51
 
# File 'lib/hash.rb', line 49

def lower_camelize_keys(options = {})
  dup.lower_camelize_keys!(options)
end

#lower_camelize_keys!(options = {}) ⇒ Object 



53
54
55
56
57
 
# File 'lib/hash.rb', line 53

def lower_camelize_keys!(options = {})
  options = options.merge({ uppercase_first_letter: false })

  camelize_keys!(options)
end

#prepend_to_keys(str, options = {}) ⇒ Object

prepend a string to all keys options 

recursive: true,
type: :keep [keep, string, symbol] (key type to be returned)

ex: { :a => 1, “b”=> 2 }.prepend_to_keys(“foo_”) == { :foo_a => 1, “foo_b”=> 2 }



103
104
105
106
107
 
# File 'lib/hash.rb', line 103

def prepend_to_keys(str, options = {})
  change_key_text(options) do |key|
    "#{str}#{key}"
  end
end

#remap_keys(remap) ⇒ Object 



37
38
39
 
# File 'lib/hash.rb', line 37

def remap_keys(remap)
  dup.remap_keys!(remap)
end

#remap_keys!(remap) ⇒ Object 



41
42
43
44
45
46
47
 
# File 'lib/hash.rb', line 41

def remap_keys!(remap)
  new_hash = {}
  remap.each do |o, n|
    new_hash[n] = delete o
  end
  merge! new_hash
end

#sort_keys(options = {}) ⇒ Object

sorts keys for hash options: { recursive: true } ex: { b:1, a:2 }.sort_keys == { a:2, b:1 }



124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/hash.rb', line 124

def sort_keys(options = {})
  options = {
    recursive: true
  }.merge(options)

  {}.tap do |hash|
    keys.sort.each do |key|
      value = self[key]
      hash[key] = value unless value.is_a?(Hash) && options[:recursive]
      hash[key] = value.sort_keys(options) if value.is_a?(Hash) && options[:recursive]
    end
  end
end

#squash ⇒ Object 



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

def squash
  {}.tap do |hash|
    each do |key, value|
      if value.is_a? Hash
        value.squash.each do |k, v|
          new_key = [key, k].join('.')
          hash[new_key] = v
        end
      else
        hash[key] = value
      end
    end
  end
end

#to_deep_hash(separator = '.') ⇒ Object 



154
155
156
 
# File 'lib/hash.rb', line 154

def to_deep_hash(separator = '.')
  Hash::DeepHashConstructor.new(separator).deep_hash(self)
end

#underscore_keys(options = {}) ⇒ Object 



67
68
69
 
# File 'lib/hash.rb', line 67

def underscore_keys(options = {})
  dup.underscore_keys!(options)
end

#underscore_keys!(options = {}) ⇒ Object 



71
72
73
 
# File 'lib/hash.rb', line 71

def underscore_keys!(options = {})
  Hash::KeyChanger.new(self).underscore_keys(options)
end