Class: Hash

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

Overview

Useful hash method necessary for determining if a dataset is valid; we remove all empty elements until just key/vals with non-empty error message arrays are left

Instance Method Summary collapse

Instance Method Details

#assert_valid_keys(*valid_keys) ⇒ Object

Validates all keys in a hash match *valid_keys, raising ArgumentError on a mismatch.

Note that keys are treated differently than HashWithIndifferentAccess, meaning that string and symbol keys will not match.

{ name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
{ name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
{ name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing



123
124
125
126
127
128
129
130
 
# File 'lib/rulix/core_ext/hash.rb', line 123

def assert_valid_keys(*valid_keys)
  valid_keys.flatten!
  each_key do |k|
    unless valid_keys.include?(k)
      raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
    end
  end
end

#deep_compact ⇒ Object

Returns a hash, removing all elements that respond to and return true from :empty? Iterates recursively over nested hashes Will continue to call itself until the second run does not differ from the first (kind of gross) TODO: Try to make this less gross



231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/rulix/core_ext/hash.rb', line 231

def deep_compact
  result = dup.deep_compact!
  result2 = result.dup.deep_compact!

  if result != result2
    result = result2

    result.deep_compact
  end

  result
end

#deep_compact! ⇒ Object 



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
 
# File 'lib/rulix/core_ext/hash.rb', line 244

def deep_compact!
  each_pair do |current_key, value|
    this_value = self[current_key]

    if this_value.respond_to?(:empty?)
      if this_value.empty?
        self.delete current_key
      elsif this_value.is_a?(Hash)          
        self[current_key] = this_value.deep_compact
      elsif this_value.is_a?(Array)
        if this_value.all? { |v| v.respond_to?(:empty?) && v.empty? }
          self.delete current_key
        elsif this_value.all? { |v| v.respond_to?(:deep_compact) }
          self[current_key] = this_value.map(&:deep_compact)
        end
      end
    else
      self.delete current_key if this_value.nil?
    end
  end
end

#deep_merge(other_hash, &block) ⇒ Object

Returns a new hash with self and other_hash merged recursively.

h1 = { a: true, b: { c: [1, 2, 3] } }
h2 = { a: false, b: { x: [3, 4, 5] } }

h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }

Like with Hash#merge in the standard library, a block can be provided to merge values:

h1 = { a: 100, b: 200, c: { c1: 100 } }
h2 = { b: 250, c: { c1: 200 } }
h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
# => { a: 100, b: 450, c: { c1: 300 } }



20
21
22
 
# File 'lib/rulix/core_ext/hash.rb', line 20

def deep_merge(other_hash, &block)
  dup.deep_merge!(other_hash, &block)
end

#deep_merge!(other_hash, &block) ⇒ Object

Same as deep_merge, but modifies self.



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/rulix/core_ext/hash.rb', line 25

def deep_merge!(other_hash, &block)
  other_hash.each_pair do |current_key, other_value|
    this_value = self[current_key]

    self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
      this_value.deep_merge(other_value, &block)
    else
      if block_given? && key?(current_key)
        block.call(current_key, this_value, other_value)
      else
        other_value
      end
    end
  end

  self
end

#deep_stringify_keys ⇒ Object

Returns a new hash with all keys converted to strings. This includes the keys from the root hash and from all nested hashes and arrays.

hash = { person: { name: 'Rob', age: '28' } }

hash.deep_stringify_keys
# => {"person"=>{"name"=>"Rob", "age"=>"28"}}



159
160
161
 
# File 'lib/rulix/core_ext/hash.rb', line 159

def deep_stringify_keys
  deep_transform_keys(&:to_s)
end

#deep_stringify_keys! ⇒ Object

Destructively converts all keys to strings. This includes the keys from the root hash and from all nested hashes and arrays.



166
167
168
 
# File 'lib/rulix/core_ext/hash.rb', line 166

def deep_stringify_keys!
  deep_transform_keys!(&:to_s)
end

#deep_symbolize_keys ⇒ Object

Returns a new hash with all keys converted to symbols, as long as they respond to to_sym. This includes the keys from the root hash and from all nested hashes and arrays.

hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }

hash.deep_symbolize_keys
# => {:person=>{:name=>"Rob", :age=>"28"}}



178
179
180
 
# File 'lib/rulix/core_ext/hash.rb', line 178

def deep_symbolize_keys
  deep_transform_keys{ |key| key.to_sym rescue key }
end

#deep_symbolize_keys! ⇒ Object

Destructively converts all keys to symbols, as long as they respond to to_sym. This includes the keys from the root hash and from all nested hashes and arrays.



185
186
187
 
# File 'lib/rulix/core_ext/hash.rb', line 185

def deep_symbolize_keys!
  deep_transform_keys!{ |key| key.to_sym rescue key }
end

#deep_transform_keys(&block) ⇒ Object

Returns a new hash with all keys converted by the block operation. This includes the keys from the root hash and from all nested hashes and arrays.

hash = { person: { name: 'Rob', age: '28' } }

hash.deep_transform_keys{ |key| key.to_s.upcase }
# => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}



140
141
142
 
# File 'lib/rulix/core_ext/hash.rb', line 140

def deep_transform_keys(&block)
  _deep_transform_keys_in_object(self, &block)
end

#deep_transform_keys!(&block) ⇒ Object

Destructively converts all keys by using the block operation. This includes the keys from the root hash and from all nested hashes and arrays.



147
148
149
 
# File 'lib/rulix/core_ext/hash.rb', line 147

def deep_transform_keys!(&block)
  _deep_transform_keys_in_object!(self, &block)
end

#stringify_keys ⇒ Object

Returns a new hash with all keys converted to strings.

hash = { name: 'Rob', age: '28' }

hash.stringify_keys
# => {"name"=>"Rob", "age"=>"28"}



85
86
87
 
# File 'lib/rulix/core_ext/hash.rb', line 85

def stringify_keys
  transform_keys(&:to_s)
end

#stringify_keys! ⇒ Object

Destructively converts all keys to strings. Same as stringify_keys, but modifies self.



91
92
93
 
# File 'lib/rulix/core_ext/hash.rb', line 91

def stringify_keys!
  transform_keys!(&:to_s)
end

#symbolize_keys ⇒ Object Also known as: to_options

Returns a new hash with all keys converted to symbols, as long as they respond to to_sym.

hash = { 'name' => 'Rob', 'age' => '28' }

hash.symbolize_keys
# => {:name=>"Rob", :age=>"28"}



102
103
104
 
# File 'lib/rulix/core_ext/hash.rb', line 102

def symbolize_keys
  transform_keys{ |key| key.to_sym rescue key }
end

#symbolize_keys! ⇒ Object Also known as: to_options!

Destructively converts all keys to symbols, as long as they respond to to_sym. Same as symbolize_keys, but modifies self.



109
110
111
 
# File 'lib/rulix/core_ext/hash.rb', line 109

def symbolize_keys!
  transform_keys!{ |key| key.to_sym rescue key }
end

#transform_keys ⇒ Object

Returns a new hash with all keys converted using the block operation.

hash = { name: 'Rob', age: '28' }

hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}

If you do not provide a block, it will return an Enumerator for chaining with other methods:

hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}



60
61
62
63
64
65
66
67
 
# File 'lib/rulix/core_ext/hash.rb', line 60

def transform_keys
  return enum_for(:transform_keys) { size } unless block_given?
  result = {}
  each_key do |key|
    result[yield(key)] = self[key]
  end
  result
end

#transform_keys! ⇒ Object

Destructively converts all keys using the block operations. Same as transform_keys but modifies self.



71
72
73
74
75
76
77
 
# File 'lib/rulix/core_ext/hash.rb', line 71

def transform_keys!
  return enum_for(:transform_keys!) { size } unless block_given?
  keys.each do |key|
    self[yield(key)] = delete(key)
  end
  self
end