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 



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

def convert
  self
end

#convert_keys(&converter) ⇒ Object 



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

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

#convert_keys_recursively(&converter) ⇒ Object 



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

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 



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

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 



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

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

#deep_dup ⇒ Object 



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

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

#make_indifferent_access_recursively ⇒ Object 



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

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 



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

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 



2
3
4
5
6
7
 
# File 'lib/ruby_core_extensions/hash.rb', line 2

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 



17
18
19
20
21
 
# File 'lib/ruby_core_extensions/hash.rb', line 17

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) 


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

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 



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

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 



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

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

#symbolize_keys_recursively ⇒ Object 



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

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