structure_compare 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ebebf0cb0eafd7f627df962d71f2553c3de2d62
-  data.tar.gz: 3a858990738e61837a4a47d0497667ba94dacf52
+  metadata.gz: 38ec4e210b5674286a4e88ea6011ae71facb4ebc
+  data.tar.gz: 65755bdd48627fa619460f2abe6142a179f3ac00
 SHA512:
-  metadata.gz: b4e814993fe0e4fe32345c1908f739f337aea61fb6880387bdc33d76245925e9e485a0ab06278ebcdefa5bfd9fc4e2487eef1b272bd160a0e216ab800b42ea2b
-  data.tar.gz: 643bb740f4c6e0392c06cb5b17f812329fa36b008446a14f2997661a5a9719e66c971ffe727bdb10ef1295e9bdc2ea75474a77c07c3b6b5c7a5156760cb571ae
+  metadata.gz: 63c5810ee73f6325340d89ea0dfa99a1fbcf88f5c3270b413abf6d9e470597bd4e86b8497929109fe6cce157a774bfc9c3bc8df7ecd458ea503057e8338d3684
+  data.tar.gz: 4b0309d805073de85b67b74c6c497350fc21817e230301802b0c58eb84bfc0b3f1f27d601a661eaa4cda20e9d223160427d0fdeedda339fd499b84f26bbdbbf7

data/lib/structure_compare.rb

@@ -1,7 +1,10 @@
 # TODO: doc (interface, assertions, ...)
 module StructureCompare
+  class ArgumentError < ::ArgumentError; end
+  class RuntimeError < ::RuntimeError; end
+
   class StructuresNotEqualError < RuntimeError; end
-  class ArgumentError < ArgumentError; end
+  class IndifferentAccessError < RuntimeError; end
 end
 
 require 'structure_compare/version'

data/lib/structure_compare/structure_comparison.rb

@@ -5,7 +5,7 @@ module StructureCompare
       @options = {
         strict_key_order: false,
         check_values: false,
-        treat_hash_symbols_as_strings: false,
+        indifferent_access: false,
         float_tolerance_factor: 0
       }.merge(options)
     end
@@ -45,7 +45,7 @@ module StructureCompare
     end
 
     def check_arrays_equal!(expected, actual)
-      check_equal!(
+      check_values_equal!(
         expected.count, actual.count, "array length: #{expected.count} != #{actual.count}"
       )
 
@@ -61,48 +61,52 @@ module StructureCompare
     def check_hashes_equal!(expected, actual)
       check_hash_keys_equal!(expected, actual)
 
-      expected_values = expected.values
-      actual_values = actual.values
+      expected.each do |key, expected_value|
+        if @options[:indifferent_access]
+          actual_value = with_indifferent_access!(actual, key)
+        else
+          actual_value = actual[key]
+        end
 
-      expected_values.each_with_index do |expected_value, index|
-        key = expected.keys[index]
         path_segment = key.is_a?(Symbol) ? "[:#{key}]" : "[\"#{key}\"]"
         @path.push(path_segment)
 
-        check_structures_equal!(expected_value, actual_values[index])
+        check_structures_equal!(expected_value, actual_value)
         @path.pop
       end
     end
 
+    # TODO safeguard in case there's a key as symbol _and_ hash
     def check_hash_keys_equal!(expected, actual)
       expected_keys = expected.keys
       actual_keys = actual.keys
 
-      if @options[:treat_hash_symbols_as_strings]
+      if @options[:indifferent_access]
         # NOTE: not all hash keys are symbols/strings, only convert symbols
         expected_keys.map! { |key| key.is_a?(Symbol) ? key.to_s : key }
         actual_keys.map! { |key| key.is_a?(Symbol) ? key.to_s : key }
       end
 
+      failure_message = "hash keys aren't equal"
+
       if @options[:strict_key_order]
-        check_equal!(expected_keys, actual_keys)
+        if expected_keys != actual_keys
+          not_equal_error!(expected_keys, actual_keys, failure_message)
+        end
       else
-        begin
-          expected_keys.sort!
-          actual_keys.sort!
-        rescue ::ArgumentError => error
-          raise StructureCompare::ArgumentError.new(
-            "Unable to sort hash keys: \"#{error}\"." +
-            'Try enabling :strict_key_order option to prevent sorting of mixed-type hash keys.'
-          )
+        # NOTE: first did this with sorting, but can't sort mixed type keys
+        all_keys_present = (
+          expected_keys.all?{ |key| actual.has_key?(key) } &&
+          actual_keys.all?{ |key| expected.has_key?(key) }
+        )
+        if !all_keys_present
+          not_equal_error!(expected_keys, actual_keys, failure_message)
         end
-
-        check_equal!(expected_keys, actual_keys)
       end
     end
 
     def check_leafs_equal!(expected, actual)
-      check_equal!(expected, actual) if @options[:check_values]
+      check_values_equal!(expected, actual) if @options[:check_values]
     end
 
     def check_kind_of!(expected, actual)
@@ -112,7 +116,7 @@ module StructureCompare
       end
     end
 
-    def check_equal!(expected, actual, failure_message = nil)
+    def check_values_equal!(expected, actual, failure_message = nil)
       if expected.is_a?(Float) && actual.is_a?(Float)
         is_equal = float_equal_with_tolerance_factor?(
           expected, actual, @options[:float_tolerance_factor]
@@ -141,5 +145,23 @@ module StructureCompare
       @error = failure_message
       raise StructuresNotEqualError.new() # TODO error message, path
     end
+
+    def with_indifferent_access!(actual, key)
+      if [Symbol, String].include?(key.class)
+        has_both_types = (actual.has_key?(key) && actual.has_key?(key.to_s))
+        duplicate_key_error!(key) if has_both_types
+
+        actual.has_key?(key.to_s) ? actual[key.to_s] : actual[key.to_sym]
+      else
+        actual[key]
+      end
+    end
+
+    def duplicate_key_error!(key)
+      raise StructureCompare::IndifferentAccessError.new(
+        "#{@path.join}: key is present as string and symbol. " \
+        "can not use indifferent_access option!"
+      )
+    end
   end
 end

data/lib/structure_compare/version.rb

@@ -1,3 +1,3 @@
 module StructureCompare
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/test/structure_compare_test.rb

@@ -39,6 +39,18 @@ class StructureCompareTest < MiniTest::Test
     refute_structures_equal([1, 2], [1, 2, 3])
   end
 
+  def test_with_strict_key_order_off_compares_correct_values
+    structure_a = { a: 1, b: 2 }
+    structure_b = { b: 2, a: 1 }
+    assert_structures_equal(
+      structure_a, structure_b, check_values: true, strict_key_order: false
+    )
+
+    structure_a = { a: { c: 1 }, b: 2 }
+    structure_b = { b: 2, a: { c: 1 } }
+    assert_structures_equal(structure_a, structure_b, strict_key_order: false)
+  end
+
   def test_stores_error_with_path_in_getter
     structure_a = { x: 1, a: [{ b: [1, 1, 1] }] }
     structure_b = { x: 1, a: [{ b: [1, 9, 1] }] }
@@ -67,27 +79,35 @@ class StructureCompareTest < MiniTest::Test
     refute_structures_equal(structure_a, structure_b, check_values: true)
   end
 
-  def test_mixed_type_hash_keys_trigger_error_unless_strict_order_set
+  # this was a bug where we compared keys by sorting them, resulting in
+  # an ArgumentError if keys weren't comparable (String vs. Fixnum)
+  def test_mixed_type_hash_works_if_strict_key_order_not_set
     hash = { a: 1, 5 => 6 }
-
-    assert_raises StructureCompare::ArgumentError do
-      assert_structures_equal(hash, hash)
-    end
-
-    assert_structures_equal(hash, hash, strict_key_order: true)
+    assert_structures_equal(hash, hash, strict_key_order: false)
   end
 
-  def test_symbol_keys_are_strings_if_option_set
-    string_hash = {"a" => 1, "b" => 2, 5 => 6}
-    symbol_hash = {a: 1, b: 2, 5 => 6}
+  def test_indifferent_access_option_works_as_expected
+    string_hash = { "a" => 1, "b" => 2, 5 => 6 }
+    symbol_hash = { a: 1, b: 2, 5 => 6 }
 
     refute_structures_equal(string_hash, symbol_hash, strict_key_order: true)
     assert_structures_equal(
       string_hash, symbol_hash,
-      treat_hash_symbols_as_strings: true, strict_key_order: true
+      indifferent_access: true, strict_key_order: true
     )
   end
 
+  def test_option_for_indifferent_access_raises_if_symbol_and_string_key_present
+    hash = { "a" => 1, a: 2 }
+    assert_structures_equal(hash, hash, strict_key_order: true)
+
+    assert_raises StructureCompare::IndifferentAccessError do
+      assert_structures_equal(
+        hash, hash, strict_key_order: true, indifferent_access: true
+      )
+    end
+  end
+
   def test_compares_floats_correctly
     assert_structures_equal([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], check_values: true)
     assert_structures_equal(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: structure_compare
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Markus Seeger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake