Module: EasyDiff::Core

Defined in:
lib/easy_diff/core.rb

Class Method Summary collapse

Class Method Details

.easy_clone(original) ⇒ Object 



66
67
68
 
# File 'lib/easy_diff/core.rb', line 66

def self.easy_clone(original)
  Marshal::load(Marshal.dump(original))
end

.easy_diff(original, modified) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/easy_diff/core.rb', line 3

def self.easy_diff(original, modified)
  removed = nil
  added   = nil

  if original.nil?
    added = modified.safe_dup 
  elsif modified.nil?
    removed = original.safe_dup 
  elsif original.is_a?(Hash) && modified.is_a?(Hash)
    removed = {}
    added   = {}
    original_keys   = original.keys
    modified_keys   = modified.keys
    keys_in_common  = original_keys & modified_keys
    keys_removed    = original_keys - modified_keys
    keys_added      = modified_keys - original_keys
    keys_removed.each{ |key| removed[key] = original[key].safe_dup }
    keys_added.each{ |key| added[key] = modified[key].safe_dup }
    keys_in_common.each do |key|
      r, a = easy_diff original[key], modified[key]
      removed[key] = r unless r.nil?
      added[key] = a unless a.nil?
    end
  elsif original.is_a?(Array) && modified.is_a?(Array)
    removed = original - modified
    added   = modified - original
  elsif original != modified
    removed   = original
    added     = modified
  end
  return removed, added
end

.easy_merge!(original, added) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/easy_diff/core.rb', line 51

def self.easy_merge!(original, added)
  if added.nil?
    return original
  elsif original.is_a?(Hash) && added.is_a?(Hash)
    added_keys = added.keys
    added_keys.each{ |key| original[key] = easy_merge!(original[key], added[key])}
  elsif original.is_a?(Array) && added.is_a?(Array)
    original |=  added
    original.sort!
  else
    original = added.safe_dup
  end
  original
end

.easy_unmerge!(original, removed) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/easy_diff/core.rb', line 36

def self.easy_unmerge!(original, removed)
  if original.is_a?(Hash) && removed.is_a?(Hash)
    original_keys  = original.keys
    removed_keys   = removed.keys
    keys_in_common = original_keys & removed_keys
    keys_in_common.each{ |key| original.delete(key) if easy_unmerge!(original[key], removed[key]).nil? }
  elsif original.is_a?(Array) && removed.is_a?(Array)
    original.reject!{ |e| removed.include?(e) }
    original.sort!
  elsif original == removed
    original = nil
  end
  original
end