Comparing ruby hashes [duplicate]

by

here is a slightly modified version from colin’s. 

class Hash
  def diff(other)
    (self.keys + other.keys).uniq.inject({}) do |memo, key|
      unless self[key] == other[key]
        if self[key].kind_of?(Hash) &&  other[key].kind_of?(Hash)
          memo[key] = self[key].diff(other[key])
        else
          memo[key] = [self[key], other[key]] 
        end
      end
      memo
    end
  end
end

It recurses into the hashes for more efficient left and right

{a: {c: 1, b: 2}, b: 2}.diff({a: {c: 2, b: 2}})

returns

{:a=>{:c=>[1, 2]}, :b=>[2, nil]}

instead of 

{:a=>[{:c=>1, :b=>2}, {:c=>2, :b=>2}], :b=>[2, nil]}

Great idea colin

here is how to apply the diff to the original hashes

  def apply_diff!(changes, direction = :right)
    path = [[self, changes]]
    pos, local_changes = path.pop
    while local_changes
      local_changes.each_pair {|key, change|
        if change.kind_of?(Array)
          pos[key] = (direction == :right) ? change[1] : change[0]
        else
          path.push([pos[key], change])
        end
      }
      pos, local_changes = path.pop
    end
    self
  end
  def apply_diff(changes, direction = :right)
    cloned = self.clone
    path = [[cloned, changes]]
    pos, local_changes = path.pop
    while local_changes
      local_changes.each_pair {|key, change|
        if change.kind_of?(Array)
          pos[key] = (direction == :right) ? change[1] : change[0]
        else
          pos[key] = pos[key].clone
          path.push([pos[key], change])
        end
      }
      pos, local_changes = path.pop
    end
    cloned
  end

so to make the left look like the right you run

{a: {c: 1, b: 2}, b: 2}.apply_diff({:a=>{:c=>[1, 2]}, :b=>[2, nil]})

to get 

{a: {c: 2, b: 2}, b: nil}

to get exact we would have to go a little farther and record a difference between between nil and no key
and it would also be nice to shorten long arrays by just providing adds and removes

More Related Contents:

  1. How to remove empty string in hash
  2. Strange, unexpected behavior (disappearing/changing values) when using Hash default value, e.g. Hash.new([])
  3. What’s the difference between equal?, eql?, ===, and ==?
  4. Is there any difference between the `:key => “value”` and `key: “value”` hash notations?
  5. Converting a nested hash into a flat hash
  6. Is Hash Rocket deprecated?
  7. Ruby Style: How to check whether a nested hash element exists
  8. Group hashes by keys and sum the values
  9. How do I search within an array of hashes by hash values in ruby?
  10. Ruby Hash with duplicate keys?
  11. Performance of Arrays and Hashes in Ruby
  12. obj.nil? vs. obj == nil
  13. Find key/value pairs deep inside a hash containing an arbitrary number of nested hashes and arrays
  14. Ruby method Array#
  15. How to get a specific output iterating a hash in Ruby?
  16. Accessing elements of nested hashes in ruby [duplicate]
  17. How do I create a SHA1 hash in ruby?
  18. Convert array of 2-element arrays into a hash, where duplicate keys append additional values
  19. How to assign hash[‘a’][‘b’]= ‘c’ if hash[‘a’] doesn’t exist?
  20. Is order of a Ruby hash literal guaranteed?
  21. How do methods use hash arguments in Ruby?
  22. ruby using the “&:methodname” shortcut from array.map(&:methodname) for hash key strings rather than methodname
  23. Test if variable matches any of several strings w/o long if-elsif chain, or case-when
  24. How do I compare two hashes?
  25. how to i add objects to an array ? ruby
  26. Converting an array of numbers to characters ruby [closed]
  27. Valid email address regular expression? [duplicate]
  28. In Ruby, why does Array.new(size, object) create an array consisting of multiple references to the same object?
  29. RVM and thin, root vs. local user
  30. Ruby array subtraction without removing items more than once

Leave a Comment