Class: Hash

Inherits:
Object show all
Defined in:
lib/ruby_core_extensions/hash.rb,
lib/ruby_core_extensions/compact/hash.rb,
lib/ruby_core_extensions/recursive/hash.rb

Instance Method Summary collapse

Instance Method Details

#compact ⇒ Object

Remove nil values



3
4
5
 
# File 'lib/ruby_core_extensions/compact/hash.rb', line 3

def compact
  self.dup.compact!
end

#compact! ⇒ Object

Remove nil values - !desctructively!



8
9
10
 
# File 'lib/ruby_core_extensions/compact/hash.rb', line 8

def compact!
  delete_if{|k,v| v.nil?}
end

#compact_blank ⇒ Object 



12
13
14
 
# File 'lib/ruby_core_extensions/compact/hash.rb', line 12

def compact_blank
  self.dup.compact_blank!
end

#compact_blank! ⇒ Object 



16
17
18
 
# File 'lib/ruby_core_extensions/compact/hash.rb', line 16

def compact_blank!
  delete_if{|k,v| v.blank?}
end

#convert ⇒ Object 



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

def convert
  self
end

#convert_keys(&converter) ⇒ Object 



18
19
20
21
22
23
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 18

def convert_keys(&converter)
  inject({}) do |hash, (key, value)|
    hash[converter.call(key)] = value
    hash
  end
end

#convert_keys_recursively(&converter) ⇒ Object 



32
33
34
35
36
37
38
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 32

def convert_keys_recursively(&converter)
  Hash[map do |key, value|
        k = converter.call(key)
        v = value.convert_keys_recursively(&converter)
        [k,v]
      end]
end

#convert_values(*keys, &converter) ⇒ Object 



25
26
27
28
29
30
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 25

def convert_values(*keys, &converter)
  inject(clone) do |hash, (key, value)|
    hash[key] = value.convert(&converter) if keys.blank? || keys.include?(key)
    hash
  end
end

#convert_values_recursively(&converter) ⇒ Object 



40
41
42
43
44
45
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 40

def convert_values_recursively(&converter)
  inject({}) do |hash, (key, value)|
    hash[key] = value.convert_values_recursively(&converter)
    hash
  end
end

#deep_dup ⇒ Object 



69
70
71
72
73
74
75
76
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 69

def deep_dup
  duplicate = self.dup
  duplicate.each_pair do |k,v|
    tv = duplicate[k]
    duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
  end
  duplicate
end

#extract!(*keys) ⇒ Object

Imported from Rails 3



5
6
7
8
9
 
# File 'lib/ruby_core_extensions/hash.rb', line 5

def extract!(*keys)
  result = {}
  keys.each { |key| result[key] = delete(key) }
  result
end

#make_indifferent_access_recursively ⇒ Object 



62
63
64
65
66
67
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 62

def make_indifferent_access_recursively
  HashWithIndifferentAccess.new(inject({}) do |options, (key, value)|
      options[key] = value.make_indifferent_access_recursively
      options
    end)
end

#map_key(method) ⇒ Object 



21
22
23
24
25
 
# File 'lib/ruby_core_extensions/hash.rb', line 21

def map_key(method)
  each.with_object({}) do |(k,v), new_hash|
    new_hash[k.send(method)] = v
  end
end

#map_key_value(key_method, value_method = nil) ⇒ Object 



13
14
15
16
17
18
 
# File 'lib/ruby_core_extensions/hash.rb', line 13

def map_key_value(key_method, value_method = nil)
  value_method ||= key_method
  each.with_object({}) do |(k,v), new_hash|
    new_hash[k.send(key_method)] = v.send(value_method)
  end
end

#map_value(method) ⇒ Object 



28
29
30
31
32
 
# File 'lib/ruby_core_extensions/hash.rb', line 28

def map_value(method)
  each.with_object({}) do |(k,v), new_hash|
    new_hash[k] = v.send(method)
  end
end

#recursive_blank? ⇒ Boolean

Returns:

  • (Boolean) 


3
4
5
6
7
8
9
10
11
12
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 3

def recursive_blank?
  each do |k, v|
    if v.respond_to?(:recursive_blank?)
      return false unless v.recursive_blank?
    else
      return false unless v.blank?
    end
  end
  true
end

#recursive_compact_blank! ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/ruby_core_extensions/compact/hash.rb', line 20

def recursive_compact_blank!
  delete_if do |k,v|
    if v.is_a?(Hash)
      v.recursive_compact_blank!
      v.recursive_blank?
    elsif v.is_a?(Array)
      v.recursive_compact_blank!
      v.recursive_blank?
    else
      v.blank?
    end
  end
end

#recursively(&block) ⇒ Object 



78
79
80
81
82
83
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 78

def recursively(&block)
  each do |key,value|
    block.call(key,value)
    value.recursively(&block) if value.respond_to?(:recursively)
  end
end

#stringify_values_recursively ⇒ Object 



55
56
57
58
59
60
 
# File 'lib/ruby_core_extensions/recursive/hash.rb', line 55

def stringify_values_recursively
  inject({}) do |options, (key, value)|
    options[key] = value.stringify_values_recursively
    options
  end
end

#symbolize_keys_recursively ⇒ Object 



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

def symbolize_keys_recursively
  Hash[map do |key, value|
        k = key.is_a?(String) ? key.to_sym : key
        v = value.symbolize_keys_recursively
        [k,v]
      end]
end