Module: DeeplyEnumerable::HashExtension

Included in:
Hash
Defined in:
lib/deeply_enumerable/hash.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(klass) ⇒ Object 



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

def self.included klass
  klass.class_eval do
    include DeeplyEnumerable::Enumerable
  end
end

Instance Method Details

#deep_compact(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements) ⇒ Object 



51
52
53
 
# File 'lib/deeply_enumerable/hash.rb', line 51

def deep_compact(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
  dup.deep_compact!(remove_emptied_elements, remove_empty_elements)
end

#deep_compact!(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/deeply_enumerable/hash.rb', line 32

def deep_compact!(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
  each do |key, value|
    next if unenumerable_object?(value)

    value = rebuild(value) unless value.respond_to?(:reverse_deep_merge)
    compact_method = i[deep_compact! deep_compact compact! compact].detect{ |m| value.respond_to?(m) }
    next unless compact_method

    original_empty = value.respond_to?(:empty?) ? value.empty? : value.respond_to?(:none?) ? value.none? : false
    compact_value = value.send(*[compact_method].concat(value.method(compact_method).parameters.collect { |_,param| binding.local_variable_get(param) } ).compact) || value
    compact_empty = compact_value.respond_to?(:empty?) ? compact_value.empty? : compact_value.respond_to?(:none?) ? compact_value.none? : false

    self[key] = (original_empty && remove_empty_elements) || (!original_empty && compact_empty && remove_emptied_elements) ? nil : compact_value
  end
  compact!

  self
end

#reverse_deep_merge(other_hash) ⇒ Object Also known as: deep_reverse_merge 



27
28
29
 
# File 'lib/deeply_enumerable/hash.rb', line 27

def reverse_deep_merge(other_hash)
  dup.reverse_deep_merge!(other_hash)
end

#reverse_deep_merge!(other_hash) ⇒ Object Also known as: deep_reverse_merge! 



11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/deeply_enumerable/hash.rb', line 11

def reverse_deep_merge!(other_hash)
  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 = ebuild(this_value) unless this_value.respond_to?(:reverse_deep_merge)
      this_value.reverse_deep_merge(other_value)
    else
      key?(current_key) ? this_value : other_value
    end
  end

  self
end