structure_compare 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 535404ee3a6c198af0c7788bee7f0a31d15fee6c
-  data.tar.gz: c133617419e3d5b8e3338e63ae08b123b74a3ad3
+  metadata.gz: 7ebebf0cb0eafd7f627df962d71f2553c3de2d62
+  data.tar.gz: 3a858990738e61837a4a47d0497667ba94dacf52
 SHA512:
-  metadata.gz: 4decfee7c6aafed708585478a69be43475a2a52db8b1484bc179df16c53610f7c47dbf98b77a8d0249615f9a9d5832b882ad1c4d0235b3cffb9b1bdbb506693c
-  data.tar.gz: 78f2b98c8c8af06034ffada10178cd343ee479e4004732caff6a8bb70f47ae122fe299755d5247435e8389ca7c62158cc91a0d45a0a3d36716fae96f6d6c5c14
+  metadata.gz: b4e814993fe0e4fe32345c1908f739f337aea61fb6880387bdc33d76245925e9e485a0ab06278ebcdefa5bfd9fc4e2487eef1b272bd160a0e216ab800b42ea2b
+  data.tar.gz: 643bb740f4c6e0392c06cb5b17f812329fa36b008446a14f2997661a5a9719e66c971ffe727bdb10ef1295e9bdc2ea75474a77c07c3b6b5c7a5156760cb571ae

data/lib/structure_compare.rb

@@ -1,156 +1,8 @@
-# TODO rename to structure_compare
-# TODO Enumerable to support non-array enumerables
-# TODO doc
+# TODO: doc (interface, assertions, ...)
 module StructureCompare
-
   class StructuresNotEqualError < RuntimeError; end
   class ArgumentError < ArgumentError; end
-
-  class StructureComparison
-    def initialize(options = {})
-      @options = {
-        strict_key_order: false,
-        check_values: false,
-        treat_hash_symbols_as_strings: false,
-        float_tolerance_factor: 0
-      }.merge(options)
-    end
-
-    # TODO doc
-    def structures_are_equal?(expected, actual)
-      @path = []
-      @error = nil
-
-      begin
-        check_structures_equal!(expected, actual)
-      rescue StructuresNotEqualError => _error
-        return false
-      end
-
-      return true
-    end
-
-    # TODO doc
-    def error
-      "#{@path.join} : #{@error}"
-    end
-
-    protected
-
-    def check_structures_equal!(expected, actual)
-      check_kind_of!(expected, actual)
-
-      case expected
-      when Array
-        check_arrays_equal!(expected, actual)
-      when Hash
-        check_hashes_equal!(expected, actual)
-      else
-        check_leafs_equal!(expected, actual)
-      end
-    end
-
-    def check_arrays_equal!(expected, actual)
-      check_equal!(
-        expected.count, actual.count, "array length: #{expected.count} != #{actual.count}"
-      )
-
-      expected.each_with_index do |expected_value, index|
-        path_segment = "[#{index}]"
-        @path.push(path_segment)
-
-        check_structures_equal!(expected_value, actual[index])
-        @path.pop
-      end
-    end
-
-    def check_hashes_equal!(expected, actual)
-      check_hash_keys_equal!(expected, actual)
-
-      expected_values = expected.values
-      actual_values = actual.values
-
-      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])
-        @path.pop
-      end
-    end
-
-    def check_hash_keys_equal!(expected, actual)
-      expected_keys = expected.keys
-      actual_keys = actual.keys
-
-      if @options[:treat_hash_symbols_as_strings]
-        # 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
-
-      if @options[:strict_key_order]
-        check_equal!(expected_keys, actual_keys)
-      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.'
-          )
-        end
-
-        check_equal!(expected_keys, actual_keys)
-      end
-    end
-
-    def check_leafs_equal!(expected, actual)
-      check_equal!(expected, actual) if @options[:check_values]
-    end
-
-    def check_kind_of!(expected, actual)
-      unless actual.kind_of?(expected.class)
-        failure_message = "expected #{actual.class.to_s} to be kind of #{expected.class.to_s}"
-        not_equal_error!(expected, actual, failure_message)
-      end
-    end
-
-    def check_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]
-        )
-      else
-        is_equal = (expected == actual)
-      end
-
-      if !is_equal
-        failure_message ||= "expected: #{expected.inspect}, got: #{actual.inspect}"
-        not_equal_error!(expected, actual, failure_message)
-      end
-    end
-
-    def float_equal_with_tolerance_factor?(expected, actual, tolerance_factor)
-      raise StructureCompare::ArgumentError.new("tolerance_factor must be > 0") if tolerance_factor < 0
-
-      lower_bound = (expected * (1.0 - tolerance_factor) - Float::EPSILON)
-      upper_bound = (expected * (1.0 + tolerance_factor) + Float::EPSILON)
-
-      return (lower_bound <= actual) && (actual <= upper_bound)
-    end
-
-    # TODO make this part of an overridden exception?
-    def not_equal_error!(expected, actual, failure_message)
-      @error = failure_message
-      raise StructuresNotEqualError.new() # TODO error message, path
-    end
-  end
-
 end
 
-# TODO test if monkeypatching MiniTest::Assertions works
-
-require 'version'
+require 'structure_compare/version'
+require 'structure_compare/structure_comparison'

data/lib/structure_compare/minitest.rb

@@ -0,0 +1,16 @@
+class Minitest::Test
+
+  protected
+
+  def assert_structures_equal(expected, actual, options = {})
+    comparison = StructureCompare::StructureComparison.new(options)
+    is_equal = comparison.structures_are_equal?(expected, actual)
+    assert is_equal, comparison.error
+  end
+
+  def refute_structures_equal(expected, actual, options = {})
+    comparison = StructureCompare::StructureComparison.new(options)
+    is_equal = comparison.structures_are_equal?(expected, actual)
+    refute is_equal, "structures are not expected to be equal"
+  end
+end

data/lib/structure_compare/structure_comparison.rb

@@ -0,0 +1,145 @@
+module StructureCompare
+  # TODO: Enumerable to support non-array enumerables
+  class StructureComparison
+    def initialize(options = {})
+      @options = {
+        strict_key_order: false,
+        check_values: false,
+        treat_hash_symbols_as_strings: false,
+        float_tolerance_factor: 0
+      }.merge(options)
+    end
+
+    # TODO doc
+    def structures_are_equal?(expected, actual)
+      @path = []
+      @error = nil
+
+      begin
+        check_structures_equal!(expected, actual)
+      rescue StructuresNotEqualError => _error
+        return false
+      end
+
+      return true
+    end
+
+    # TODO doc
+    def error
+      "#{@path.join} : #{@error}"
+    end
+
+    protected
+
+    def check_structures_equal!(expected, actual)
+      check_kind_of!(expected, actual)
+
+      case expected
+      when Array
+        check_arrays_equal!(expected, actual)
+      when Hash
+        check_hashes_equal!(expected, actual)
+      else
+        check_leafs_equal!(expected, actual)
+      end
+    end
+
+    def check_arrays_equal!(expected, actual)
+      check_equal!(
+        expected.count, actual.count, "array length: #{expected.count} != #{actual.count}"
+      )
+
+      expected.each_with_index do |expected_value, index|
+        path_segment = "[#{index}]"
+        @path.push(path_segment)
+
+        check_structures_equal!(expected_value, actual[index])
+        @path.pop
+      end
+    end
+
+    def check_hashes_equal!(expected, actual)
+      check_hash_keys_equal!(expected, actual)
+
+      expected_values = expected.values
+      actual_values = actual.values
+
+      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])
+        @path.pop
+      end
+    end
+
+    def check_hash_keys_equal!(expected, actual)
+      expected_keys = expected.keys
+      actual_keys = actual.keys
+
+      if @options[:treat_hash_symbols_as_strings]
+        # 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
+
+      if @options[:strict_key_order]
+        check_equal!(expected_keys, actual_keys)
+      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.'
+          )
+        end
+
+        check_equal!(expected_keys, actual_keys)
+      end
+    end
+
+    def check_leafs_equal!(expected, actual)
+      check_equal!(expected, actual) if @options[:check_values]
+    end
+
+    def check_kind_of!(expected, actual)
+      unless actual.kind_of?(expected.class)
+        failure_message = "expected #{actual.class.to_s} to be kind of #{expected.class.to_s}"
+        not_equal_error!(expected, actual, failure_message)
+      end
+    end
+
+    def check_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]
+        )
+      else
+        is_equal = (expected == actual)
+      end
+
+      if !is_equal
+        failure_message ||= "expected: #{expected.inspect}, got: #{actual.inspect}"
+        not_equal_error!(expected, actual, failure_message)
+      end
+    end
+
+    def float_equal_with_tolerance_factor?(expected, actual, tolerance_factor)
+      raise StructureCompare::ArgumentError.new("tolerance_factor must be > 0") if tolerance_factor < 0
+
+      lower_bound = (expected * (1.0 - tolerance_factor) - Float::EPSILON)
+      upper_bound = (expected * (1.0 + tolerance_factor) + Float::EPSILON)
+
+      return (lower_bound <= actual) && (actual <= upper_bound)
+    end
+
+    # TODO make this part of an overridden exception?
+    def not_equal_error!(expected, actual, failure_message)
+      @error = failure_message
+      raise StructuresNotEqualError.new() # TODO error message, path
+    end
+  end
+end

data/lib/{version.rb → structure_compare/version.rb}

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

data/structure_compare.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'version'
+require 'structure_compare/version'
 
 Gem::Specification.new do |gem|
   gem.name          = "structure_compare"

data/test/structure_compare_test.rb

@@ -1,5 +1,6 @@
 require_relative "test_helper"
-require_relative "../lib/structure_compare"
+require_relative '../lib/structure_compare'
+require_relative '../lib/structure_compare/minitest'
 
 class StructureCompareTest < MiniTest::Test
 
@@ -158,19 +159,4 @@ class StructureCompareTest < MiniTest::Test
       )
     end
   end
-
-  protected
-
-    def assert_structures_equal(expected, actual, options = {})
-      comparison = StructureCompare::StructureComparison.new(options)
-      is_equal = comparison.structures_are_equal?(expected, actual)
-      assert is_equal, comparison.error
-    end
-
-    def refute_structures_equal(expected, actual, options = {})
-      comparison = StructureCompare::StructureComparison.new(options)
-      is_equal = comparison.structures_are_equal?(expected, actual)
-      refute is_equal, "structures are not expected to be equal"
-    end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure_compare
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Markus Seeger
@@ -123,7 +123,9 @@ files:
 - README.md
 - Rakefile
 - lib/structure_compare.rb
-- lib/version.rb
+- lib/structure_compare/minitest.rb
+- lib/structure_compare/structure_comparison.rb
+- lib/structure_compare/version.rb
 - structure_compare.gemspec
 - test/structure_compare_test.rb
 - test/test_helper.rb