Module: HaveStructureMatcher

Defined in:
lib/support_methods.rb

Defined Under Namespace

Modules: Methods

Class Method Summary collapse

Class Method Details

.build_array_diff(actual_value, expected_value) ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/support_methods.rb', line 50

def self.build_array_diff(actual_value, expected_value)
  if expected_value.length == 1 && actual_value.is_a?(Array)
    actual_value.map { |a| build_diff(a, expected_value[0]) }
  else
    expected_value.zip(actual_value).map { |(e,a)| build_diff(a, e) }
  end
end

.build_diff(actual, expected) ⇒ Object 



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

def self.build_diff(actual, expected)
  if actual.is_a?(Array) && expected.is_a?(Array)
    build_array_diff(actual, expected)
  elsif actual.is_a?(Hash) && expected.is_a?(Hash)
    build_hash_diff(actual, expected)
  elsif actual.is_a?(Hash)
    expected
  elsif value_match?(actual, expected)
    actual
  else
    expected
  end
end

.build_hash_diff(actual, expected) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/support_methods.rb', line 26

def self.build_hash_diff(actual, expected)
  keys = actual.keys | expected.keys

  keys.each_with_object({}) do |key, memo|
    if actual.key?(key) && expected.key?(key)
      actual_value = actual[key]
      expected_value = expected[key]

      if expected_value.is_a?(Hash)
        memo[key] = build_diff(actual_value, expected_value)
      elsif expected_value.is_a?(Array)
        memo[key] = build_array_diff(actual_value, expected_value)
      elsif value_match?(actual_value, expected_value)
        memo[key] = actual_value
      else
        memo[key] = print_expected_value(expected_value)
      end
    elsif expected.key?(key)
      expected_value = expected[key]
      memo[key] = print_expected_value(expected_value)
    end
  end
end

.match?(actual, expected) ⇒ Boolean

Returns:

  • (Boolean) 


8
9
10
 
# File 'lib/support_methods.rb', line 8

def self.match?(actual, expected)
  actual == build_diff(actual, expected)
end

.print_expected_value(expected_value) ⇒ Object 



58
59
60
61
62
63
64
 
# File 'lib/support_methods.rb', line 58

def self.print_expected_value(expected_value)
  if expected_value.respond_to?(:call)
    "Proc [#{expected_value.source_location.join(':')}]"
  else
    expected_value
  end
end

.value_match?(actual_value, expected_value) ⇒ Boolean

Returns:

  • (Boolean) 


66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/support_methods.rb', line 66

def self.value_match?(actual_value, expected_value)
  if expected_value.is_a?(Regexp)
    actual_value =~ expected_value
  elsif expected_value.is_a?(Class)
    actual_value.is_a?(expected_value)
  elsif expected_value.respond_to?(:call)
    expected_value.call(actual_value)
  else
    actual_value == expected_value
  end
end