structure_compare 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad5bf30bbf0c94e5ea5dec89456c7a4cd4c763bc
-  data.tar.gz: 2c683dcc8cabcbe96ce4810e804a33719e4a4ad2
+  metadata.gz: e8c287f81bf6a357ccd1aba5c8c703696ebaccab
+  data.tar.gz: 1647b3afd3d1e259cb5c019bafdc17a15bd2179c
 SHA512:
-  metadata.gz: 002d954268e5900d71db1d4519088a184357a81374187ddf581a28333abd4208c431d36e45572ae21ac22bd3133d5a6b56a4578a72f396c79a0d902de9890f89
-  data.tar.gz: c0f4d36ba46c4536c0a90301cda3834c8a9d03d983be97c4fe502d0f74da4c7236ba063383690cebeb378100f35f4395bc3db14cc23142925fba615e5936f449
+  metadata.gz: 2bb1354657e93c9d83df484233f5660ae50adfe7dacc31fae9b1f944f6961c14c8c2f8f9ae4feb8a789a6c492c577b57de26695fd4227b143e8709faa8d8ee9a
+  data.tar.gz: c198a58a79d70d6521c6b0e93dda95872034ad70a4bee0b3fd2280b3723ef8274444a1d3526e0511489c42155aff39a607d432cd2b995be329b3725fcdcf84b1

data/README.md

@@ -1,6 +1,138 @@
 # structure_compare
+
 Compares the structure of two deep nested Ruby structures
 
-Useful for testing API responses.
+## General
+
+Use case: you're writing an API response or a JSON export and want to unit test it.
+
+## Installation
+
+```
+gem install structure_compare
+```
+
+or add it to your `Gemfile`
+
+### quick-n-dirty example:
+```ruby
+require 'structure_compare'
+comparison = StructureCompare::StructureComparison.new
+
+expected = { a: 1, b: 2, c: [1, 2, 3] }
+actual   = { a: 1, b: 2, c: [1, 2, "A"] }
+
+comparison.structures_are_equal?(expected, actual)
+puts comparison.error
+# => root[:c][2] : expected String to be kind of Fixnum
+```
+
+### MiniTest
+```ruby
+require 'structure_compare'
+require 'structure_compare/minitest'
+
+assert_structures_equal({ a: 1, b: 2 }, { a: 1, b: 2 })
+refute_structures_equal({ a: 1, b: 2 }, { c: 1, d: 2 })
+```
+
+### Options
+
+#### Strict key ordering
+name: `strict_key_order`
+default: false
+
+```ruby
+expected = { a: 1, b: 2 }
+actual   = { b: 2, a: 1 }
+
+comparison = StructureCompare::StructureComparison.new(strict_key_order: false)
+comparison.structures_are_equal?(expected, actual)
+# => true
+```
+
+#### Value checking
+name: `strict_key_order`
+default: true
+
+```ruby
+expected = { a: 1, b: { c: 1 } }
+actual   = { a: 8, b: { c: 8 } }
+
+comparison = StructureCompare::StructureComparison.new
+comparison.structures_are_equal?(expected, actual)
+# => false
+
+comparison = StructureCompare::StructureComparison.new(check_values: false)
+comparison.structures_are_equal?(expected, actual)
+# => true
+```
+
+#### Indifferent Access
+Hash symbol keys are treated as equal to string keys
+NOTE: an exception will be raised if there's a key present as symbol _and_ string
+
+name: `indifferent_access`
+default: false
+
+expected = { a: 1 }
+actual   = { "a" => 1 }
+
+```ruby
+comparison = StructureCompare::StructureComparison.new
+comparison.structures_are_equal?(expected, actual)
+# => false
+
+comparison = StructureCompare::StructureComparison.new(indifferent_access: true)
+comparison.structures_are_equal?(expected, actual)
+# => true
+
+hash = { a: 1, "a" => 2 }
+comparison = StructureCompare::StructureComparison.new(indifferent_access: true)
+comparison.structures_are_equal?(hash, hash)
+# => StructureCompare::IndifferentAccessError
+```
+
+#### Float tolerance
+
+When dealing with floats, you will want to introduce a tolerance.
+NOTE: Float::EPSILON is _always_ used for comparing Float type values.
+NOTE: The `check_values` option must be set.
+
+name: `float_tolerance_factor`
+default: 0
+
+```
+tolerance = +- (expected * (1.0 + tolerance_factor) + Float::EPSILON)
+```
+
+This means a `float_tolerance_factor` setting of 0.01 means that `actual`
+can be 1% different from `expected` to still be treated equal.
+
+```ruby
+expected = { a: 10.0 }
+actual_1 = { a: 10.1 }
+actual_2 = { a: 10.11 }
+
+# 1% tolerance factor
+comparison = StructureCompare::StructureComparison.new(
+  float_tolerance_factor: 0.01, check_values: true
+)
+comparison.structures_are_equal?(expected, actual_1)
+# => true
+
+comparison.structures_are_equal?(expected, actual_2)
+# => false
+```
+
+## TODOS
+
+RSpec helpers.
+
+## Contribution
+
+Fork me and send me a pull request with working tests.
+
+## License
 
-TODO: usage, example
+MIT License, see `LICENSE` file in the root directory

data/lib/structure_compare/structure_comparison.rb

@@ -4,7 +4,7 @@ module StructureCompare
     def initialize(options = {})
       @options = {
         strict_key_order: false,
-        check_values: false,
+        check_values: true,
         indifferent_access: false,
         float_tolerance_factor: 0
       }.merge(options)
@@ -118,7 +118,7 @@ module StructureCompare
     end
 
     def check_values_equal!(expected, actual, failure_message = nil)
-      if expected.is_a?(Float) && actual.is_a?(Float)
+      if expected.is_a?(Float) || actual.is_a?(Float)
         is_equal = float_equal_with_tolerance_factor?(
           expected, actual, @options[:float_tolerance_factor]
         )

data/lib/structure_compare/version.rb

@@ -1,3 +1,3 @@
 module StructureCompare
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end

data/test/structure_compare_test.rb

@@ -34,7 +34,7 @@ class StructureCompareTest < MiniTest::Test
   end
 
   def test_leaf_values_are_compared_if_option_set
-    assert_structures_equal({a: 1, b: 2}, {a: 111, b: 222})
+    assert_structures_equal({a: 1, b: 2}, {a: 111, b: 222}, check_values: false)
     refute_structures_equal({a: 1, b: 2}, {a: 111, b: 222}, check_values: true)
 
     assert_structures_equal(%w(a b c d), %w(a b c d))
@@ -71,7 +71,8 @@ class StructureCompareTest < MiniTest::Test
     structure_a = { x: 1, a: [{ b: [1, "FOO", 1] }] }
     structure_b = { x: 1, a: [{ b: [1, "BAR", 1] }] }
 
-    assert_structures_equal(structure_a, structure_b)
+    assert_structures_equal(structure_a, structure_b, check_values: false)
+
     comparison = StructureCompare::StructureComparison.new(check_values: true)
     comparison.structures_are_equal?(structure_a, structure_b)
     assert_match "FOO", comparison.error

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure_compare
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Markus Seeger