sixarm_ruby_minitest_equal_collection 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c621681113f3a8160ea03b92e570bebf99880b45
+  data.tar.gz: 779e7c18f08cadc8dd04b7afb8b64e2783ed0b3c
+SHA512:
+  metadata.gz: 255cbdf8967fbe2f69db6d834144108186138c1a2b243d89f763e382b43937e1c48ac08c1e4cd2ae5d8436a27ba4435ec64184de6ea5882cbb7a46be1b1e7d24
+  data.tar.gz: 2ec5aac7a02cf0c6f6008a479427673343e2d72abb39faf910f2b5dfca34edd3de18b2389f6d02c93a8b35369394c7f5cbc7ca4cc345f2a5b50de0c6bd7eed5c

checksums.yaml.gz.sig

@@ -0,0 +1,5 @@
+�o��{]����m�K�[58'$T���N��~\Io`5��6��'��p��K�c_Qot�ڈ�qz����pN�%0�U�$G\�������Z���mZ��K'��Z��S���m��}s��<RiV()�.Z����������4|ڼL�)-+Wu9~D�ٳ?�^�S
+���������������#סU	��.#�����2tdbc3�\���ܞ��M�ڢ��#���ۖ�Mke|���웛���=0���ك����)�����0���_�)s�)Xu�� @�C�^�
+S%כ߬�%���[6�[�H7}� �sֽ[42k�6�_r��l�u"�eTׇ�ni`���W �\��h��	��%��9!<���czP�j>�}�-��2�.�
+WobX��0�[���>Ӟ1�-�je����E��}qB�H����{M�q��
+|�Viբ7@�o2�����|�,S<�H2�$���χ���,F�*Cc���v$�|f����h��{ND��f��9���

data.tar.gz.sig

@@ -0,0 +1,4 @@
+ι'8B��c�<ci9�����O���)$�ݸ,8x��
+_�߸�E����[U���Ou�qOlù��������<�EJ!���DQ
�HP41\�j
��_yM
+��s�V <�C���d��͐��c	��P�,��T�x����.8�5IgYOv�����b�S�Md����Ҫ���U���o�t�tO��R�G\"�{���]:�����u�M���GHZ�R��6�_*��u��$S��Q+��t���z�fF����q�\f�Z��&�n�tU�!�o�
;Nj�
+O�t���a��b1R�൘�S�J����J��*�Zblg7��x����

data/Rakefile

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+require "rake"
+require "rake/testtask"
+
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs.push("lib", "test")
+  t.pattern = "test/**/*.rb"
+end

data/lib/sixarm_ruby_minitest_equal_collection.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+=begin rdoc
+Please see README
+=end
+
+unless defined?(Minitest) then
+  # Minitest 5 and MiniTest 4 use different capitalizations.
+  module Minitest; end
+  MiniTest = Minitest # prevents minitest.rb from requiring back to us
+  require "minitest"
+end
+
+MiniTest = Minitest unless defined?(MiniTest)
+
+require 'hashdiff'
+
+require 'sixarm_ruby_minitest_equal_collection/minitest/assertions/equal_collection'
+require 'sixarm_ruby_minitest_equal_collection/minitest/expectations/equal_collection'

data/lib/sixarm_ruby_minitest_equal_collection/minitest/assertions/equal_collection.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+=begin rdoc
+Please see README
+=end
+
+module MiniTest::Assertions
+ 
+  ##
+  # Succeeds when +exp+ and +act+ contain equal items and counts, regardless of order.
+
+  def assert_equal_collection(expect, actual, msg = nil)
+    shared_equal_collection(expect, actual, msg)
+    diff = shared_diff(expect, actual)
+    assert diff.empty?, 
+      "Expected collections to have the same items. Expect: #{ expect.inspect }. Actual #{ actual.inspect }. Diff: #{ diff.inspect }." + append_msg(msg)
+  end
+
+  ##
+  # Succeeds when +exp+ and +act+ contain different items and/or counts, regardless of order.
+
+  def refute_equal_collection(expect, actual, msg = nil)
+    shared_equal_collection(expect, actual)
+    diff = shared_diff(expect, actual)
+    refute diff.empty?,
+      "Expected collections to not have the same items. Expect: #{ expect.inspect }. Actual: #{ actual.inspect }. Diff: #{ diff.inspect }" + append_msg(msg)
+  end
+
+  private
+
+  def shared_equal_collection(expect, actual, msg = nil)
+    refute_nil(expect, "Expected `expect`, but got nil." + append_msg(msg))
+    refute_nil(actual, "Expected `actual`, but got nil." + append_msg(msg))
+    assert_respond_to(expect, :each, "Expected `expect` to respond to each." + append_msg(msg))
+    assert_respond_to(actual, :each, "Expected `actual` to respond to each." + append_msg(msg))
+  end
+
+  def append_msg(msg)
+    msg ? " #{msg}" : ""
+  end
+
+  def countize(a)
+    h = Hash.new(0)
+    a.each{|x| h[x] += 1}
+    h
+  end
+
+  def shared_diff(a, b)
+    HashDiff.diff countize(a), countize(b)
+  end
+
+end

data/lib/sixarm_ruby_minitest_equal_collection/minitest/expectations/equal_collection.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+=begin rdoc
+Please see README
+=end
+
+module Minitest::Expectations
+  infect_an_assertion :assert_equal_collection, :must_equal_collection
+  infect_an_assertion :refute_equal_collection, :wont_equal_collection
+end
+

data/test/sixarm_ruby_minitest_equal_collection_test.rb

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+require "minitest/autorun"
+require "simplecov"
+SimpleCov.start
+require "sixarm_ruby_minitest_equal_collection"
+
+require "sixarm_ruby_minitest_equal_collection_test/minitest/assertions/equal_collection_test"
+require "sixarm_ruby_minitest_equal_collection_test/minitest/expectations/equal_collection_test"

data/test/sixarm_ruby_minitest_equal_collection_test/minitest/assertions/equal_collection_test.rb

@@ -0,0 +1,364 @@
+# -*- coding: utf-8 -*-
+require "sixarm_ruby_minitest_equal_collection"
+
+describe "Minitest" do
+
+  describe "Assertions" do
+
+    describe "#assert_equal_collection" do
+
+      describe "empty collections => pass" do
+
+        describe "with array" do
+
+          specify "both empty => pass" do
+            assert_equal_collection([], [])
+          end
+
+          specify "only one empty => fail" do
+            err = proc { 
+              assert_equal_collection([], [:a])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+      
+        describe "with hash" do
+
+          specify "with both empty => pass" do
+            assert_equal_collection({}, {})
+          end
+
+          specify "with one empty => fail" do
+            err = proc { 
+              assert_equal_collection({}, {a: 1})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+
+      end
+
+      describe "equal collections => pass" do
+
+        describe "with array" do
+
+          specify "with equal => pass" do
+            assert_equal_collection([:a], [:a])
+          end
+
+          specify "with unequal => fail" do
+            err = proc {
+              assert_equal_collection([:a], [:b])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal => pass" do
+            assert_equal_collection({a: 1}, {a: 1})
+          end
+
+          specify "with unequal => fail" do
+            err = proc {
+              assert_equal_collection({a: 1}, {b: 1})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+
+      end
+
+      describe "count is relevant" do
+
+        describe "with array" do
+
+          specify "with equal count => pass" do
+            assert_equal_collection([:a], [:a])
+          end
+
+          specify "with unequal count => fail" do
+            err = proc { 
+              assert_equal_collection([:a], [:a, :a])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal count => pass" do
+              assert_equal_collection({a: 1}, {a: 1})
+          end
+
+          specify "with unequal count => fail" do
+            err = proc { 
+              assert_equal_collection({a: 1}, {a: 1, b: 1})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+
+      end
+
+      describe "order is irrelevant" do
+
+        describe "with array" do
+
+          specify "with same items and same order => pass" do
+            assert_equal_collection([:a, :b], [:a, :b])
+          end
+
+          specify "with same items and different order => pass" do
+            assert_equal_collection([:a, :b], [:b, :a])
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with same order => pass" do
+            assert_equal_collection({a: 1, b: 2}, {a: 1, b: 2})
+          end
+
+          specify "with different order => pass" do
+            assert_equal_collection({a: 1, b: 2}, {b: 2, a: 1})
+          end
+
+        end
+
+      end
+
+      describe "with degenerate cases" do
+
+        describe "with actual nil" do
+
+          specify "raise" do
+            err = proc {
+              assert_equal_collection([], nil)
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bactual\b.*\bnil\b/)
+          end
+
+        end
+
+        describe "with expect nil" do
+
+          specify "raise" do
+            err = proc {
+              assert_equal_collection(nil, [])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bexpect\b.*\bnil\b/)
+          end
+
+        end
+
+        describe "with actual that does not respond to each" do
+
+          specify "raise" do
+            err = proc {
+              assert_equal_collection([], Object.new)
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bactual\b.*\brespond to each\b/)
+          end
+
+        end
+
+        describe "with expect that does not respond to each" do
+
+          specify "raise" do
+            err = proc {
+              assert_equal_collection(Object.new, [])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bexpect\b.*\brespond to each\b/)
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#refute_equal_collection" do
+
+      describe "empty collections => fail" do
+
+        describe "with array" do
+
+          specify "both empty => fail" do
+            err = proc {
+              refute_equal_collection([], [])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "only one empty => pass" do
+            refute_equal_collection([], [:a])
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with both empty => fail" do
+            err = proc { 
+              refute_equal_collection({}, {})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "with one empty => pass" do
+            refute_equal_collection({}, {a: 1})
+          end
+
+        end
+
+      end
+
+      describe "equal collections => fail" do
+
+        describe "with array" do
+
+          specify "with equal => fail" do
+            err = proc {
+              refute_equal_collection([:a], [:a])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "with unequal => succes" do
+            refute_equal_collection([:a], [:b])
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal => fail" do
+            err = proc {
+              refute_equal_collection({a: 1}, {a: 1})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "with unequal => pass" do
+            refute_equal_collection({a: 1}, {b: 1})
+          end
+
+        end
+
+      end
+
+      describe "count is relevant" do
+
+        describe "with array" do
+
+          specify "with equal count => fail" do
+            err = proc { 
+              refute_equal_collection([:a], [:a])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "with unequal count => pass" do
+            refute_equal_collection([:a], [:a, :a])
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal count => fail" do
+            err = proc { 
+              refute_equal_collection({a: 1}, {a: 1})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "with unequal count => pass" do
+            refute_equal_collection({a: 1}, {a: 1, b: 1})
+          end
+
+        end
+
+      end
+
+      describe "order is irrelevant" do
+
+        describe "with array" do
+
+          specify "with same items and same order => fail" do
+            err = proc {
+              refute_equal_collection([:a, :b], [:a, :b])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "with same items but different order => fail" do
+            err = proc {
+              refute_equal_collection([:a, :b], [:b, :a])
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with same items and same order => fail" do
+            err = proc {
+              refute_equal_collection({a: 1, b: 2}, {a: 1, b: 2})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+          specify "with same items and different order => fail" do
+            err = proc {
+              refute_equal_collection({a: 1, b: 2}, {b: 2, a: 1})
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bhave the same items\b/)
+          end
+
+        end
+
+      end
+
+      describe "with degenerate cases" do
+
+        describe "with nil" do
+
+          specify "raise an error that explains nil" do
+            err = proc {
+              assert_equal_collection(nil, nil)
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bgot nil\b/)
+          end
+
+        end
+
+        describe "with an object that does not respond to each" do
+
+          specify "raise an error that explains respond to each" do
+            err = proc {
+              assert_equal_collection(Object.new, Object.new)
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\brespond to each\b/)
+          end
+
+        end
+
+      end
+      
+    end
+
+  end 
+
+end

data/test/sixarm_ruby_minitest_equal_collection_test/minitest/expectations/equal_collection_test.rb

@@ -0,0 +1,370 @@
+# -*- coding: utf-8 -*-
+require "sixarm_ruby_minitest_equal_collection"
+
+describe "Minitest" do
+
+  describe "Expectations" do
+
+    describe "#must_equal_collection" do
+
+      describe "empty collections => pass" do
+
+        describe "with array" do
+
+          specify "both empty => pass" do
+            expect([]).must_equal_collection []
+          end
+
+          specify "only one empty => fail" do
+            proc { 
+              expect([]).must_equal_collection [:a]
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+      
+        describe "with hash" do
+
+          specify "with both empty => pass" do
+            expect({}).must_equal_collection({})
+          end
+
+          specify "with one empty => fail" do
+            proc { 
+              expect({}).must_equal_collection({a: 1})
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+
+      end
+
+      describe "equal collections => pass" do
+
+        describe "with array" do
+
+          specify "with equal => pass" do
+            expect([:a]).must_equal_collection [:a]
+          end
+
+          specify "with unequal => fail" do
+            proc {
+              expect([:a]).must_equal_collection [:b]
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal => pass" do
+            expect({a: 1}).must_equal_collection({a: 1})
+          end
+
+          specify "with unequal => fail" do
+            proc {
+              expect({a: 1}).must_equal_collection({b: 1})
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+
+      end
+
+      describe "count is relevant" do
+
+        describe "with array" do
+
+          specify "with equal count => pass" do
+            expect([:a]).must_equal_collection [:a]
+          end
+
+          specify "with unequal count => fail" do
+            proc { 
+              expect([:a]).must_equal_collection [:a, :a]
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal count => pass" do
+            expect({a: 1}).must_equal_collection({a: 1})
+          end
+
+          specify "with unequal count => fail" do
+            proc { 
+              expect({a: 1}).must_equal_collection({a: 1, b: 1})
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+
+      end
+
+      describe "order is irrelevant" do
+
+        describe "with array" do
+
+          specify "with same items and same order => pass" do
+            expect([:a, :b]).must_equal_collection [:a, :b]
+          end
+
+          specify "with same items and different order => pass" do
+            expect([:a, :b]).must_equal_collection [:b, :a]
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with same order => pass" do
+            expect({a: 1, b: 2}).must_equal_collection({a: 1, b: 2})
+          end
+
+          specify "with different order => pass" do
+            expect({a: 1, b: 2}).must_equal_collection({b: 2, a: 1})
+          end
+
+        end
+
+      end
+
+      describe "with degenerate cases" do
+
+        describe "with `actual` nil" do
+
+          specify "raise" do
+            err = proc {
+              expect(nil).must_equal_collection []
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bactual\b.*\bnil\b/)
+          end
+
+        end
+
+        describe "with `expect` nil" do
+
+          specify "raise" do
+            err = proc {
+              expect([]).must_equal_collection nil
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bexpect\b.*\bnil\b/)
+          end
+
+        end
+
+        describe "with `actual` that does not respond to each" do
+
+          specify "raise" do
+            err = proc {
+              expect(Object.new).must_equal_collection []
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bactual\b.*\brespond to each\b/)
+          end
+
+        end
+
+        describe "with `expect` that does not respond to each" do
+
+          specify "raise" do
+            err = proc {
+              expect([]).must_equal_collection Object.new
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bexpect\b.*\brespond to each\b/)
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#wont_equal_collection" do
+
+      describe "empty collections => fail" do
+
+        describe "with array" do
+
+          specify "both empty => fail" do
+            proc {
+              expect([]).wont_equal_collection []
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "only one empty => pass" do
+            expect([]).wont_equal_collection [:a]
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with both empty => fail" do
+            proc { 
+              expect({}).wont_equal_collection({})
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "with one empty => pass" do
+            expect({}).wont_equal_collection({a: 1})
+          end
+
+        end
+
+      end
+
+      describe "equal collections => fail" do
+
+        describe "with array" do
+
+          specify "with equal => fail" do
+            proc {
+              expect([:a]).wont_equal_collection [:a]
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "with unequal => succes" do
+            expect([:a]).wont_equal_collection [:b]
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal => fail" do
+            proc {
+              expect({a: 1}).wont_equal_collection({a: 1})
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "with unequal => pass" do
+            expect({a: 1}).wont_equal_collection({b: 1})
+          end
+
+        end
+
+      end
+
+      describe "count is relevant" do
+
+        describe "with array" do
+
+          specify "with equal count => fail" do
+            proc { 
+              expect([:a]).wont_equal_collection [:a]
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "with unequal count => pass" do
+            expect([:a]).wont_equal_collection [:a, :a]
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with equal count => fail" do
+            proc { 
+              expect({a: 1}).wont_equal_collection({a: 1})
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "with unequal count => pass" do
+            expect({a: 1}).wont_equal_collection({a: 1, b: 1})
+          end
+
+        end
+
+      end
+
+      describe "order is irrelevant" do
+
+        describe "with array" do
+
+          specify "with same items and same order => fail" do
+            proc {
+              expect([:a, :b]).wont_equal_collection [:a, :b]
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "with same items but different order => fail" do
+            proc {
+              expect([:a, :b]).wont_equal_collection [:b, :a]
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+
+        describe "with hash" do
+
+          specify "with same items and same order => fail" do
+            proc {
+              expect({a: 1, b: 2}).wont_equal_collection({a: 1, b: 2})
+            }.must_raise MiniTest::Assertion
+          end
+
+          specify "with same items and different order => fail" do
+            proc {
+              expect({a: 1, b: 2}).wont_equal_collection({b: 2, a: 1})
+            }.must_raise MiniTest::Assertion
+          end
+
+        end
+
+      end
+
+      describe "with degenerate cases" do
+
+        describe "with `actual` nil" do
+
+          specify "raise" do
+            err = proc {
+              expect(nil).wont_equal_collection []
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bactual\b.*\bnil\b/)
+          end
+
+        end
+
+        describe "with `expect` nil" do
+
+          specify "raise" do
+            err = proc {
+              expect([]).wont_equal_collection nil
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bexpect\b.*\bnil\b/)
+          end
+
+        end
+
+        describe "with `actual` that does not respond to each" do
+
+          specify "raise" do
+            err = proc {
+              expect(Object.new).wont_equal_collection []
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bactual\b.*\brespond to each\b/)
+          end
+
+        end
+
+        describe "with `expect` that does not respond to each" do
+
+          specify "raise" do
+            err = proc {
+              expect([]).wont_equal_collection Object.new
+            }.must_raise MiniTest::Assertion
+            err.message.must_match(/\bexpect\b.*\brespond to each\b/)
+          end
+
+        end
+
+      end
+
+    end
+
+  end 
+
+end

metadata

@@ -0,0 +1,215 @@
+--- !ruby/object:Gem::Specification
+name: sixarm_ruby_minitest_equal_collection
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- SixArm
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIGCTCCA/GgAwIBAgIJAK3igyLv2hNNMA0GCSqGSIb3DQEBBQUAMGAxCzAJBgNV
+  BAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1TYW4gRnJhbmNp
+  c2NvMQ8wDQYDVQQKEwZTaXhBcm0xEzARBgNVBAMTCnNpeGFybS5jb20wHhcNMTUw
+  MzE0MjA0MTE5WhcNMTcxMjA4MjA0MTE5WjBgMQswCQYDVQQGEwJVUzETMBEGA1UE
+  CBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEPMA0GA1UEChMG
+  U2l4QXJtMRMwEQYDVQQDEwpzaXhhcm0uY29tMIICIjANBgkqhkiG9w0BAQEFAAOC
+  Ag8AMIICCgKCAgEA4et7SlePzuE46eK5BAVVGg+yWt6FkX7xcLt3Uun9RntKPSuR
+  TbS/+KBqbja5reZD64hdQ9npxpQPKafxUm+RlCd9F5KFxwi8G9usKzCTPOwUeDI2
+  TNEfC+1eRU19QuEW58ZC0pC/bx5Zmp6/DTD6VV+qxKEE9U1M5P85LNkwnxqmRIMR
+  AN8VKOG+GRGOMNDGZ8Kp4h5V3Wyu0N7anY8AUveIx1SyLrEbAhcWp1asLs+/H22q
+  92YFgnwTtnDpZsAmNgZrVw9xY0v79BXqPoyKIl2psPfZi2mOIWi/N+cx6LGF1G+B
+  b+NZdAgwuLyFOoVknkTqsuYEsFhxz0dqDUgM/RvGrADxZk6yUD/1lBNTWnIDVKaN
+  Onu08gOb1lfn21Sbd5r/K32hngasiEuDvh61pJVwszBuFv3v++hVlvNzHw9oT7wc
+  W0z258Qw6fkPhozF5l+zaR+xPZG/4Kk4vc3D4mnw5MEHna6Q9rVsVktqGuIOie8Q
+  5MQAyjdNxywnl7GDllX97oVN+35JbyTePeUyZZnk5tb4p6BlYrd3rtQ2Te7tkQRz
+  8T4Scy5THaPvxf8SsfDGSj3AVPARvSX//hSFFxJM+up+S1jsquU0RjBU52nCdh7p
+  1hBZ1nqfVPeSktx3F+R2RZBPA692UKjpSA7r2vOEfoh3rUTEsNUBQGpPg2MCAwEA
+  AaOBxTCBwjAdBgNVHQ4EFgQUHnpLsysq561sVXhWi+3NoSb9n94wgZIGA1UdIwSB
+  ijCBh4AUHnpLsysq561sVXhWi+3NoSb9n96hZKRiMGAxCzAJBgNVBAYTAlVTMRMw
+  EQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMQ8wDQYD
+  VQQKEwZTaXhBcm0xEzARBgNVBAMTCnNpeGFybS5jb22CCQCt4oMi79oTTTAMBgNV
+  HRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4ICAQCYcCnvJpEhpo5mdVM8JDUuUZFt
+  qP2Kvj9J6tqugO+cuUF2S/ro4gdEQhl7Gv6+DCWHd0FQWJBSXMsZ9a6RhFGAcE5C
+  egK706Gh40yNeobd1aoUh+Pn17kYH2WSBRC+KsIvhZaAnra/1JPZItoge64GS+lM
+  PJJbVrtSati++s39wnss1QlMy9TXoesmR8vqsOU0XdCnK5hOun5RA8SYDWLffsfG
+  E3hvCg4C5viEkPY0YdC0KMSqs5kIA2nCUiqpkwIOa36rVEwiKiU7OCfE3u3baDpL
+  FlfMBznZKOdxDFAmNaxvXBe2XeTzrZPvJtnNLWL6K4LaBHhq3bBdh1Hge0iMkpQ7
+  RTIGlfhlIFkMV3wT0LTsNznUPsoo6e+IW/tDrk23mrNRY6QynTETb+QVIevuzD9m
+  Drcxp/zlVhud+a0ezdnyNvF520arJWvqA4GrOo8F+TT2vVrjscgYjiVGdSq+8wQv
+  Efa5jhe8QwG7R1rdpMMP5yBSAqWuFBczMveX5j4rp9Ifw5/XsZbgwcmdm26bjhzh
+  w2grAHIhvR9mztm6uXQlZhv1fu3P+RWHDSYhnZSCJSCdxPzQJ1mG5T5ahiL3HvCZ
+  2AC9FOGkybW6DJEFSFFMlNk0IILsa/gNp8ufGuTVLWF9FUUdMNK+TMbghnifT8/1
+  n+ES/gQPOnvmVkLDGw==
+  -----END CERTIFICATE-----
+date: 2017-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashdiff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.7
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.7
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.21
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.21
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: A Minitest assertion & expectation to compare two collections, such as
+  enumerations or arrays, in any order, and with output that shows the difference
+email: sixarm@sixarm.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/sixarm_ruby_minitest_equal_collection.rb
+- lib/sixarm_ruby_minitest_equal_collection/minitest/assertions/equal_collection.rb
+- lib/sixarm_ruby_minitest_equal_collection/minitest/expectations/equal_collection.rb
+- test/sixarm_ruby_minitest_equal_collection_test.rb
+- test/sixarm_ruby_minitest_equal_collection_test/minitest/assertions/equal_collection_test.rb
+- test/sixarm_ruby_minitest_equal_collection_test/minitest/expectations/equal_collection_test.rb
+homepage: http://sixarm.com/
+licenses:
+- Apache-2.0
+- Artistic-2.0
+- BSD-3-Clause
+- GPL-3.0
+- MIT
+- MPL-2.0
+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.6.13
+signing_key: 
+specification_version: 4
+summary: SixArm.com → Ruby → Minitest → equal_collection assertion & extension
+test_files:
+- test/sixarm_ruby_minitest_equal_collection_test.rb
+- test/sixarm_ruby_minitest_equal_collection_test/minitest/assertions/equal_collection_test.rb
+- test/sixarm_ruby_minitest_equal_collection_test/minitest/expectations/equal_collection_test.rb

metadata.gz.sig

@@ -0,0 +1,2 @@
+ͽn6k�s�ڐǽ��$h�P��H �z���v`J,C_H����m:5n�m�M�|�������$o`r)C(�������-��m����
��8p��-��n������	���O�޲uݪ!���D<F'�J\�H
+de�ɐ�"x�x�'�s"5�0�U[���T��X �z-şU��7i(E�ã�8{#�"2D����Z]!{	n؛