structure_compare 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 535404ee3a6c198af0c7788bee7f0a31d15fee6c
+  data.tar.gz: c133617419e3d5b8e3338e63ae08b123b74a3ad3
+SHA512:
+  metadata.gz: 4decfee7c6aafed708585478a69be43475a2a52db8b1484bc179df16c53610f7c47dbf98b77a8d0249615f9a9d5832b882ad1c4d0235b3cffb9b1bdbb506693c
+  data.tar.gz: 78f2b98c8c8af06034ffada10178cd343ee479e4004732caff6a8bb70f47ae122fe299755d5247435e8389ca7c62158cc91a0d45a0a3d36716fae96f6d6c5c14

data/.gitignore

@@ -0,0 +1,40 @@
+# SimpleCov
+test/coverage
+
+# Bundler
+Gemfile.lock
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.simplecov

@@ -0,0 +1,13 @@
+SimpleCov.start do
+  coverage_dir "test/coverage"
+  command_name "tests"
+
+  use_merging true
+  merge_timeout 3600
+
+  add_filter "test/"
+
+  add_group "All", "/lib/*.rb"
+
+  formatter SimpleCov::Formatter::HTMLFormatter
+end

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Guardfile

@@ -0,0 +1,13 @@
+guard :minitest do
+
+  # run all tests when lib main module file changes
+  watch(%r{^lib/structure_compare.rb$}) { "test" }
+
+  # run accompanying test for single source file if it changes
+  watch(%r{^lib/(.*)\.rb$}) {|m| "test/#{m[1]}_test.rb" }
+
+  # run test whenever it changes
+  watch(%r{^test/(.*)\/?(.*)?_test\.rb$})
+
+end
+

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Markus Seeger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,6 @@
+# structure_compare
+Compares the structure of two deep nested Ruby structures
+
+Useful for testing API responses.
+
+TODO: usage, example

data/Rakefile

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'bundler/gem_tasks'
+require 'rake'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+RuboCop::RakeTask.new(:rubocop) do |task|
+  # NOTE: do not define task.patterns here, since this
+  #       would override the .rubocop.yml include/exclude
+  #       definition
+
+  task.formatters = ['offenses', 'simple']
+  task.options = ['-D'] # Display cop name
+
+  # don't abort rake on failure
+  task.fail_on_error = false
+end
+
+task default: [:test, :rubocop]

data/lib/structure_compare.rb

@@ -0,0 +1,156 @@
+# TODO rename to structure_compare
+# TODO Enumerable to support non-array enumerables
+# TODO doc
+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'

data/lib/version.rb

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

data/structure_compare.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "structure_compare"
+  gem.version       = StructureCompare::VERSION
+  gem.authors       = ["Markus Seeger"]
+  gem.email         = ["mail@codegourmet.de"]
+  gem.description   = "Compares the structure of two deep nested Ruby structures"
+  gem.summary       = ""
+  gem.homepage      = "https://github.com/codegourmet/structure_compare"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake",  "~> 10.1"
+  gem.add_development_dependency "guard"
+  gem.add_development_dependency "guard-minitest"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "minitest-reporters"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "rubocop"
+end

data/test/structure_compare_test.rb

@@ -0,0 +1,176 @@
+require_relative "test_helper"
+require_relative "../lib/structure_compare"
+
+class StructureCompareTest < MiniTest::Test
+
+  def setup
+  end
+
+  def test_compares_keys_of_hashes
+    refute_structures_equal({a: 1, b: 2}, {a: 1, other_key: 2})
+    refute_structures_equal({a: 1, b: 2}, {a: 1, b: 2, c: 3})
+  end
+
+  def test_hash_key_order_is_compared_if_option_set
+    assert_structures_equal({a: 1, b: 2}, {b: 2, a: 1})
+    assert_structures_equal({a: 1, b: 2}, {b: 2, a: 1}, strict_key_order: false)
+    refute_structures_equal({a: 1, b: 2}, {b: 2, a: 1}, strict_key_order: true)
+  end
+
+  def test_compares_leaf_value_types
+    assert_structures_equal({a: 1, b: 2}, {b: 2, a: 1})
+    refute_structures_equal({a: 1, b: 2}, {a: 1, b: 2.0})
+
+    assert_structures_equal(%w(a b c d), %w(a b c d))
+    refute_structures_equal(%w(a b c d), ['a', 'b', 'c', 111])
+  end
+
+  def test_leaf_values_are_compared_if_option_set
+    assert_structures_equal({a: 1, b: 2}, {a: 111, b: 222})
+    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))
+    refute_structures_equal(%w(a b c d), %w(A b c d), check_values: true)
+  end
+
+  def test_compares_arrays
+    assert_structures_equal([1, 2, 3], [1, 2, 3])
+    refute_structures_equal([1, 2], [1, 2, 3])
+  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] }] }
+
+    comparison = StructureCompare::StructureComparison.new(check_values: true)
+    comparison.structures_are_equal?(structure_a, structure_b)
+    assert_match "[:a][0][:b][1]", comparison.error
+  end
+
+  def test_shows_values_for_expected_and_actual_if_error
+    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)
+    comparison = StructureCompare::StructureComparison.new(check_values: true)
+    comparison.structures_are_equal?(structure_a, structure_b)
+    assert_match "FOO", comparison.error
+    assert_match "BAR", comparison.error
+  end
+
+  def test_compares_deep_structures
+    structure_a = { x: 1, a: [{ b: [1, 1, 1] }] }
+    structure_b = { x: 1, a: [{ b: [1, 9, 1] }] }
+
+    assert_structures_equal(structure_a, structure_a, check_values: true)
+    refute_structures_equal(structure_a, structure_b, check_values: true)
+  end
+
+  def test_mixed_type_hash_keys_trigger_error_unless_strict_order_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)
+  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}
+
+    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
+    )
+  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(
+      [1.0 - Float::EPSILON * 0.5, 2.0 + Float::EPSILON * 0.5, 3.0],
+      [1.0, 2.0, 3.0],
+      check_values: true
+    )
+
+    refute_structures_equal(
+      [1.0 - Float::EPSILON * 2, 2.0, 3.0],
+      [1.0, 2.0, 3.0],
+      check_values: true
+    )
+
+    refute_structures_equal(
+      [1.0 + Float::EPSILON * 2, 2.0, 3.0],
+      [1.0, 2.0, 3.0],
+      check_values: true
+    )
+  end
+
+  def test_compares_with_tolerance_if_options_set
+    assert_structures_equal(%w(a b c d), %w(a b c d), {
+      # just to catch bugs with this option concerning non-floats
+      check_values: true, float_tolerance_factor: 0.1
+    })
+
+    refute_structures_equal([1.0, 2.0, 3.0], [1.0001, 2.0001, 3.0001], {
+      check_values: true
+    })
+
+    assert_structures_equal([1.0, 2.0, 3.0], [1.0001, 2.0001, 3.0001], {
+      check_values: true, float_tolerance_factor: 0.1
+    })
+    assert_structures_equal([1.0, 2.0, 3.0], [1.1, 2.1, 3.1], {
+      check_values: true, float_tolerance_factor: 0.1
+    })
+    assert_structures_equal([1.0, 2.0, 3.0], [0.9, 1.9, 2.9], {
+      check_values: true, float_tolerance_factor: 0.1
+    })
+
+    assert_structures_equal(
+      [1.0, 2.0, 3.0],
+      [0.9 - Float::EPSILON * 0.5, 2.1, 3.1],
+      { check_values: true, float_tolerance_factor: 0.1 }
+    )
+    refute_structures_equal(
+      [1.0, 2.0, 3.0],
+      [0.9 - Float::EPSILON * 2, 2.1, 3.1],
+      { check_values: true, float_tolerance_factor: 0.1 }
+    )
+
+    assert_structures_equal(
+      [1.0, 2.0, 3.0],
+      [1.1 + Float::EPSILON * 0.5, 2.1, 3.1],
+      { check_values: true, float_tolerance_factor: 0.1 }
+    )
+    refute_structures_equal(
+      [1.0, 2.0, 3.0],
+      [1.1 + Float::EPSILON * 2, 2.1, 3.1],
+      { check_values: true, float_tolerance_factor: 0.1 }
+    )
+  end
+
+  def test_ensures_tolerance_factor_is_gt_0
+    assert_raises StructureCompare::ArgumentError do
+      assert_structures_equal(
+        [1.0], [1.0], check_values: true, float_tolerance_factor: -0.1
+      )
+    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

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'simplecov' # has to be at top, will execute ../.simplecov
+
+require 'structure_compare'
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+if ENV["RM_INFO"] || ENV["TEAMCITY_VERSION"]
+  MiniTest::Reporters.use! MiniTest::Reporters::RubyMineReporter.new
+else
+  MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: structure_compare
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Markus Seeger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Compares the structure of two deep nested Ruby structures
+email:
+- mail@codegourmet.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".simplecov"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/structure_compare.rb
+- lib/version.rb
+- structure_compare.gemspec
+- test/structure_compare_test.rb
+- test/test_helper.rb
+homepage: https://github.com/codegourmet/structure_compare
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- test/structure_compare_test.rb
+- test/test_helper.rb