Class: HashDeepDiff::Factories::Comparison

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/hash_deep_diff/factories/comparison.rb

Overview

Factory for Comparison

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(reporting_engine:) ⇒ Comparison (private)

Returns a new instance of Comparison.



34
35
36
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 34

def initialize(reporting_engine:)
  @reporting_engine = reporting_engine
end

Instance Attribute Details

#delta ⇒ Object (readonly, private)

Returns the value of attribute delta.



32
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 32

attr_reader :reporting_engine, :delta

#reporting_engine ⇒ HashDeepDiff::Reports::Base (readonly, private)

Returns descendant of.

Returns:



32
33
34
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 32

def reporting_engine
  @reporting_engine
end

Instance Method Details

#comparison(delta:, modifier: :change) ⇒ HashDeepDiff::Comparison

factory function

Returns:



16
17
18
19
20
21
22
23
24
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 16

def comparison(delta:, modifier: :change)
  @delta = delta

  fragments(modifier).map do |(left, right, change_key)|
    HashDeepDiff::Comparison.new(left, right, change_key,
                                 delta_engine: delta.class,
                                 reporting_engine: reporting_engine)
  end
end

#fragments(mode) ⇒ Array (private)

entities for further comparison

Returns:

  • (Array) 


40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 40

def fragments(mode)
  case mode
  when :change
    return [[value_left, value_right, change_key]] unless complex?

    [[value_left, value_right, change_key + [ChangeKey::ARRAY_VALUE]],
     [nesting_left, nesting_right, change_key + [ChangeKey::NESTED_HASH]]]
  when :deletion
    [[value_left, NO_VALUE, change_key]]
  when :addition
    [[NO_VALUE, value_right, change_key]]
  end
end

#nesting_left ⇒ Array<Hash> (private)

nested hashes from original value

Returns:

  • (Array<Hash>) 


74
75
76
77
78
79
80
81
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 74

def nesting_left
  return left if left.respond_to?(:to_hash)
  return NO_VALUE unless complex_left?

  left
    .select { |el| el.respond_to?(:to_hash) }
    .each_with_object({}) { |el, memo| memo.merge!(el) }
end

#nesting_right ⇒ Array<Hash> (private)

nested hashes from changed value

Returns:

  • (Array<Hash>) 


85
86
87
88
89
90
91
92
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 85

def nesting_right
  return right if right.respond_to?(:to_hash)
  return NO_VALUE unless complex_right?

  right
    .select { |el| el.respond_to?(:to_hash) }
    .each_with_object({}) { |el, memo| memo.merge!(el) }
end

#value_left ⇒ Object (private)

original value without nested hashes

Returns:

  • (Object) 


56
57
58
59
60
61
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 56

def value_left
  return NO_VALUE if left.respond_to?(:to_hash) && right.respond_to?(:to_ary)
  return left unless left.respond_to?(:to_ary)

  left.reject { |el| el.respond_to?(:to_hash) }
end

#value_right ⇒ Object (private)

changed value without nested hashes

Returns:

  • (Object) 


65
66
67
68
69
70
 
# File 'lib/hash_deep_diff/factories/comparison.rb', line 65

def value_right
  return NO_VALUE if right.respond_to?(:to_hash) && left.respond_to?(:to_ary)
  return right unless right.respond_to?(:to_ary)

  right.reject { |el| el.respond_to?(:to_hash) }
end