augmented 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a9a3e2008882b819fbc6dc68c9362aeaf6248d19
-  data.tar.gz: bb67deffad6d08202a575e58c7df7f21319439ae
+SHA256:
+  metadata.gz: d8cd8a8566eb16186e26909a2c32597cb2cf8d0e12e2f6785a55fa2cc43992ab
+  data.tar.gz: b19a9fd510664c6dc52e99b98ebf0faa5bc70c8c061143b7c4e57addb84f261f
 SHA512:
-  metadata.gz: fb0a1f8b46a34bb071478f515a981634f57e4b73791fcf139d51475cebd6cd79c7236f23b1d9b094dd09042cb703c9e78fc58b7dfd2386ab402b88514cb3608c
-  data.tar.gz: 24f16b6a859d76cab7d6f3befd0f2c665bb568d7a7ed2d50a946d3fc13e22ac2aaa6278ac0e27bf25989c1401af3477e000b0f734069cdd7e3c732640009d1a6
+  metadata.gz: de5a4fde6a7325acd6d90008bd4f7895da85a87b71691d4c7cc5cbb81b798576f46b34621cbd9f0857c6ae087ab7e684855d839b97885ad7f127118a00e92f88
+  data.tar.gz: f6185c773e2af7676f35e07d0732305bfc7c5882109a0248db835c77ebd41c361ee8946cc66dcdced3b3087fcfc14b8c6953299eea677e8b08019f70983323cd

data/README.md

@@ -2,7 +2,7 @@
 
 `Augmented` is a library with some core-type utility methods that I frequently find myself copying across projects. It uses refinements instead of class modification for maximum control and an easy sleep at night.
 
-Many of the methods in `Augmented` facilitate a more functional style of programming and cover a few tiny gaps in Ruby's solid functional support. See more thoughts on this [blog post](http://blog.brunze.com/2015/using-ruby-refinements-fun-flow/).
+Many of the methods in `Augmented` facilitate a more functional style of programming and cover a few tiny gaps in Ruby's solid functional support.
 
 
 ## Installation

data/augmented.gemspec

@@ -18,6 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", ">= 12.3.3"
 end

data/lib/augmented/arrays/tieable.rb

@@ -7,7 +7,7 @@ module Augmented
           raise ArgumentError, 'you must provide a non-nil tie object or block' if object.nil? && !block_given?
 
           tie_function = block_given? ? block : proc{ object }
-          ties = self.each_cons(2).map &tie_function
+          ties = self.each_cons(2).map(&tie_function)
 
           self.zip(ties).flatten(1)[0...-1]
         end

data/lib/augmented/objects/pickable.rb

@@ -7,14 +7,14 @@ module Augmented
           ensure_array = -> thing { thing.kind_of?(Array) ? thing : Array[thing] }
 
           if self.respond_to? :each
-            self.map{ |thing| thing.pick *picks }
+            self.map{ |thing| thing.pick(*picks) }
           else
             picks.each_with_object({}) do |pick, result|
 
               if pick.kind_of? Hash
 
                 pick.each do |attribute, nested_picks|
-                  result[attribute] = self.__send__(attribute.to_sym).pick *ensure_array[nested_picks]
+                  result[attribute] = self.__send__(attribute.to_sym).pick(*ensure_array[nested_picks])
                 end
 
               else

data/lib/augmented/procs/rescuable.rb

@@ -1,9 +1,9 @@
 module Augmented
   module Procs
     module Rescuable
-      refine Proc do
+      NOT_PROVIDED = Object.new
 
-        NOT_PROVIDED = Object.new
+      refine Proc do
 
         def rescues exception_class, return_value = NOT_PROVIDED, &block
           raise ArgumentError, 'must provide a return value or block' if return_value == NOT_PROVIDED && !block_given?
@@ -12,7 +12,7 @@ module Augmented
 
           Proc.new do |*args|
             begin
-              original.call *args
+              original.call(*args)
             rescue exception_class => exception
               block ? block.call(exception) : return_value
             end

data/lib/augmented/version.rb

@@ -1,3 +1,3 @@
 module Augmented
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/test/augmented/arrays/tieable_test.rb

@@ -12,15 +12,15 @@ describe Augmented::Arrays::Tieable do
         object = Object.new
         weaved = %w(a b c).tie object
 
-        weaved.must_equal ['a', object, 'b', object, 'c']
+        assert_equal weaved, ['a', object, 'b', object, 'c']
       end
 
       it 'returns an empty array if the original array is empty' do
-        [].tie(1).must_equal []
+        assert_equal [].tie(1), []
       end
 
       it 'returns the original array if it has only one element' do
-        [42].tie(1).must_equal [42]
+        assert_equal [42].tie(1), [42]
       end
 
     end
@@ -31,34 +31,34 @@ describe Augmented::Arrays::Tieable do
         values = [10 ,20].each
         weaved = %w(a b c).tie{ values.next }
 
-        weaved.must_equal ['a', 10, 'b', 20, 'c']
+        assert_equal weaved, ['a', 10, 'b', 20, 'c']
       end
 
       it 'passes both neighbour values as arguments to the supplied block' do
         weaved = [1, 5, 12].tie{ |a, b| a + b }
 
-        weaved.must_equal [1, 6, 5, 17, 12]
+        assert_equal weaved, [1, 6, 5, 17, 12]
       end
 
       it 'will weave nils if the block does not return anything else' do
         weaved = [1, 2, 3].tie{}
 
-        weaved.must_equal [1, nil, 2, nil, 3]
+        assert_equal weaved, [1, nil, 2, nil, 3]
       end
 
       it 'returns an empty array if the original arrays is empty' do
-        [].tie{ 1 }.must_equal []
+        assert_equal [].tie{ 1 }, []
       end
 
       it 'returns the original array if it has only one element' do
-        [42].tie{ 1 }.must_equal [42]
+        assert_equal [42].tie{ 1 }, [42]
       end
 
     end
 
     it 'raises an ArgumentError if not passed a non-nil object or block' do
-      proc{ [].tie }.must_raise ArgumentError
-      proc{ [].tie nil }.must_raise ArgumentError
+      assert_raises(ArgumentError){ [].tie }
+      assert_raises(ArgumentError){ [].tie nil }
     end
 
   end

data/test/augmented/enumerators/indexing_test.rb

@@ -7,7 +7,7 @@ describe Augmented::Enumerators::Indexing do
   describe '#index_by' do
 
     it 'returns a hash keyed by the results of invoking the criterion on every collection element and the values are the last element matching the criterion' do
-      ['a', 'bbb', 'c', 'dd'].to_enum.index_by(&:length).must_equal({ 1 => 'c', 2 => 'dd', 3 => 'bbb' })
+      assert_equal ['a', 'bbb', 'c', 'dd'].to_enum.index_by(&:length), ({ 1 => 'c', 2 => 'dd', 3 => 'bbb' })
     end
 
   end

data/test/augmented/hashes/mappable_test.rb

@@ -7,14 +7,14 @@ describe Augmented::Hashes::Mappable do
   describe '#map_values' do
 
     it 'returns a new hash with the same keys but transformed values' do
-      { aa: 11, bb: 22 }.map_values{ |i| i * 3 }.must_equal({ aa: 33, bb: 66 })
+      assert_equal ({ aa: 11, bb: 22 }.map_values{ |i| i * 3 }), ({ aa: 33, bb: 66 })
     end
 
     it 'also provides the key and hash to the tranformer function as additional arguments' do
       hash = { aa: 11, bb: 22 }
       result = hash.map_values{ |i, key, h| [key, h.object_id] }
 
-      result.values.must_equal [[:aa, hash.object_id], [:bb, hash.object_id]]
+      assert_equal result.values, [[:aa, hash.object_id], [:bb, hash.object_id]]
     end
 
   end
@@ -22,14 +22,14 @@ describe Augmented::Hashes::Mappable do
   describe '#map_keys' do
 
     it 'returns a new hash with the same values but transformed keys' do
-      { aa: 11, bb: 22 }.map_keys{ |k| k.to_s[0] }.must_equal({ 'a' => 11, 'b' => 22 })
+      assert_equal ({ aa: 11, bb: 22 }.map_keys{ |k| k.to_s[0] }), ({ 'a' => 11, 'b' => 22 })
     end
 
     it 'also provides the value and hash to the tranformer function as additional arguments' do
       hash = { aa: 11, bb: 22 }
       result = hash.map_keys{ |k, value, h| [value, h.object_id] }
 
-      result.keys.must_equal [[11, hash.object_id], [22, hash.object_id]]
+      assert_equal result.keys, [[11, hash.object_id], [22, hash.object_id]]
     end
 
   end

data/test/augmented/hashes/polymorphable_test.rb

@@ -10,34 +10,34 @@ describe Augmented::Hashes::Polymorphable do
     it 'returns an object of the class specified by the `:type` attribute, initialized with the hash itself' do
       object = { type: 'OpenStruct', speak: 'meeehh' }.polymorph
 
-      object.must_be_instance_of OpenStruct
-      object.speak.must_equal 'meeehh'
+      assert_instance_of OpenStruct, object
+      assert_equal object.speak, 'meeehh'
     end
 
     describe 'type attribute' do
 
       it 'can also be a string key in the hash' do
-        { 'type' => 'OpenStruct' }.polymorph.must_be_instance_of OpenStruct
+        assert_instance_of OpenStruct, { 'type' => 'OpenStruct' }.polymorph
       end
 
       it 'can be an arbitrary attribute in the hash' do
-        { lorem_ipsum: 'OpenStruct' }.polymorph(:lorem_ipsum).must_be_instance_of OpenStruct
-        { 'lorem_ipsum' => 'OpenStruct' }.polymorph(:lorem_ipsum).must_be_instance_of OpenStruct
+        assert_instance_of OpenStruct, { lorem_ipsum: 'OpenStruct' }.polymorph(:lorem_ipsum)
+        assert_instance_of OpenStruct, { 'lorem_ipsum' => 'OpenStruct' }.polymorph(:lorem_ipsum)
       end
 
       it 'can be a class' do
-        { type: OpenStruct }.polymorph().must_be_instance_of OpenStruct
+        assert_instance_of OpenStruct, { type: OpenStruct }.polymorph()
       end
 
       it 'can be a class passed directly to the method, ignoring the type attribute in the hash' do
-        { type: 'TotallyIgnoredClass' }.polymorph(OpenStruct).must_be_instance_of OpenStruct
+        assert_instance_of OpenStruct, { type: 'TotallyIgnoredClass' }.polymorph(OpenStruct)
       end
 
     end
 
     it 'raises an error if it cannot find a type class' do
-      proc{ {}.polymorph }.must_raise ArgumentError
-      proc{ { type: nil }.polymorph }.must_raise ArgumentError
+      assert_raises(ArgumentError){ {}.polymorph }
+      assert_raises(ArgumentError){ { type: nil }.polymorph }
     end
 
   end

data/test/augmented/hashes/transformable_test.rb

@@ -12,8 +12,8 @@ describe Augmented::Hashes::Transformable do
 
       new_hash = hash.transform thing1: -> i { i * 3 }, thing2: :random_method_name
 
-      new_hash[:thing1].must_equal 300
-      new_hash[:thing2].must_equal 900
+      assert_equal new_hash[:thing1], 300
+      assert_equal new_hash[:thing2], 900
 
 
       # mutable version test:
@@ -21,8 +21,8 @@ describe Augmented::Hashes::Transformable do
 
       hash.transform! thing1: -> i { i * 3 }, thing2: :random_method_name
 
-      hash[:thing1].must_equal 300
-      hash[:thing2].must_equal 900
+      assert_equal hash[:thing1], 300
+      assert_equal hash[:thing2], 900
     end
 
     it 'applies procables recursively when given a hash' do
@@ -30,7 +30,7 @@ describe Augmented::Hashes::Transformable do
 
       new_hash = hash.transform({ a: { b: { c: -> i { i * 3 } } } })
 
-      new_hash[:a][:b][:c].must_equal 300
+      assert_equal new_hash[:a][:b][:c], 300
 
 
       # mutable version test:
@@ -38,7 +38,7 @@ describe Augmented::Hashes::Transformable do
 
       hash.transform!({ a: { b: { c: -> i { i * 3 } } } })
 
-      hash[:a][:b][:c].must_equal 300
+      assert_equal hash[:a][:b][:c], 300
     end
 
     it 'applies procables to all elements of a collection if a value is iterable (iterable MUST be a collection of hashes)' do
@@ -46,7 +46,7 @@ describe Augmented::Hashes::Transformable do
 
       new_hash = hash.transform(a: { my_value: -> i { i * 3 } })
 
-      new_hash[:a].must_equal [ { my_value: 30 }, { my_value: 60 } ]
+      assert_equal new_hash[:a], [ { my_value: 30 }, { my_value: 60 } ]
 
 
       # mutable version test:
@@ -54,7 +54,7 @@ describe Augmented::Hashes::Transformable do
 
       hash.transform!(a: { my_value: -> i { i * 3 } })
 
-      hash[:a].must_equal [ { my_value: 30 }, { my_value: 60 } ]
+      assert_equal hash[:a], [ { my_value: 30 }, { my_value: 60 } ]
     end
 
     it 'can apply several procables to a value, supplied in an array, executed from left to right' do
@@ -65,7 +65,7 @@ describe Augmented::Hashes::Transformable do
 
       new_hash = hash.transform a: [ :to_i, add_ten, double ]
 
-      new_hash[:a].must_equal 24
+      assert_equal new_hash[:a], 24
 
 
       # mutable version test:
@@ -73,14 +73,14 @@ describe Augmented::Hashes::Transformable do
 
       hash.transform! a: [ :to_i, add_ten, double ]
 
-      hash[:a].must_equal 24
+      assert_equal hash[:a], 24
     end
 
     it 'returns itself (mutable version only)' do
       hash = {}
       same_hash = hash.transform! Hash.new
 
-      same_hash.object_id.must_equal hash.object_id
+      assert_equal same_hash.object_id, hash.object_id
     end
 
   end

data/test/augmented/modules/refined_test.rb

@@ -9,18 +9,20 @@ describe Augmented::Modules::Refined do
     before do
       class TesterClass
         using refined String,
-          as_phrase: -> { self.capitalize.gsub /\.?\z/, '.' },
+          as_phrase: -> { self.capitalize.gsub(/\.?\z/, '.') },
           fill:      -> filler { (filler * self.length)[0..length] }
 
         def do_test
-          'hello world'.as_phrase.must_equal 'Hello world.'
-          'hello world'.fill('!').must_equal '!!!!!!!!!!!'
+          [
+            'hello world'.as_phrase == 'Hello world.',
+            'hello world'.fill('!') == '!!!!!!!!!!!',
+          ]
         end
       end
     end
 
     it 'creates a refinement module on the fly for the given class, with the procs supplied' do
-      TesterClass.new.do_test
+      assert_equal TesterClass.new.do_test, [true, true]
     end
 
   end

data/test/augmented/objects/iffy_test.rb

@@ -10,18 +10,18 @@ describe Augmented::Objects::Iffy do
       subject = 'abc'
       condition = -> subj { subj.length == 3 }
 
-      subject.if(true).must_be_same_as subject
-      subject.if(Object.new).must_be_same_as subject
-      subject.if(&condition).must_be_same_as subject
+      assert_same subject.if(true), subject
+      assert_same subject.if(Object.new), subject
+      assert_same subject.if(&condition), subject
     end
 
     it 'returns nil if the condition evaluates to falsy' do
       subject = 'abc'
       condition = -> subj { subj.length == 0 }
 
-      subject.if(false).must_be_same_as nil
-      subject.if(nil).must_be_same_as nil
-      subject.if(&condition).must_be_same_as nil
+      assert_nil subject.if(false)
+      assert_nil subject.if(nil)
+      assert_nil subject.if(&condition)
     end
 
   end
@@ -32,18 +32,18 @@ describe Augmented::Objects::Iffy do
       subject = 'abc'
       condition = -> subj { subj.length == 0 }
 
-      subject.unless(false).must_be_same_as subject
-      subject.unless(nil).must_be_same_as subject
-      subject.unless(&condition).must_be_same_as subject
+      assert_same subject.unless(false), subject
+      assert_same subject.unless(nil), subject
+      assert_same subject.unless(&condition), subject
     end
 
     it 'returns nil if the condition evaluates to truish' do
       subject = 'abc'
       condition = -> subj { subj.length == 3 }
 
-      subject.unless(true).must_be_same_as nil
-      subject.unless(Object.new).must_be_same_as nil
-      subject.unless(&condition).must_be_same_as nil
+      assert_nil subject.unless(true)
+      assert_nil subject.unless(Object.new)
+      assert_nil subject.unless(&condition)
     end
 
   end
@@ -53,15 +53,15 @@ describe Augmented::Objects::Iffy do
     it 'returns the alternative if the object is falsy' do
       alternative = Object.new
 
-      false.else(alternative).must_be_same_as alternative
-      nil.else(alternative).must_be_same_as alternative
+      assert_same false.else(alternative), alternative
+      assert_same nil.else(alternative), alternative
     end
 
     it 'returns the object if the object is truish' do
       subject = Object.new
 
-      true.else(123).must_be_same_as true
-      subject.else(123).must_be_same_as subject
+      assert_same true.else(123), true
+      assert_same subject.else(123), subject
     end
 
   end

data/test/augmented/objects/pickable_test.rb

@@ -10,29 +10,29 @@ describe Augmented::Objects::Pickable do
     it 'returns a hash with the results of invoking the list of picks in the target' do
       target = OpenStruct.new aaa: 111, bbb: 222, ccc: 333
 
-      target.pick(:aaa, :ccc).must_equal({ aaa: 111, ccc: 333 })
+      assert_equal target.pick(:aaa, :ccc), { aaa: 111, ccc: 333 }
     end
 
     it 'returns the result of invoking `pick` on every element of an enumerable target' do
       target = [ OpenStruct.new(val: 11), OpenStruct.new(val: 22), OpenStruct.new(val: 33) ]
 
-      target.pick(:val).must_equal [{val: 11}, {val: 22}, {val: 33}]
+      assert_equal target.pick(:val), [{val: 11}, {val: 22}, {val: 33}]
     end
 
     it 'applies picks recursively when provided with hashes' do
       target = OpenStruct.new(aa: (OpenStruct.new bb: (OpenStruct.new cc: 33)))
 
-      target.pick(aa: { bb: :cc }).must_equal({ aa: { bb: { cc: 33 } } })
+      assert_equal target.pick(aa: { bb: :cc }), { aa: { bb: { cc: 33 } } }
 
       target = OpenStruct.new(dd: OpenStruct.new(ee: 55), ff: OpenStruct.new(gg: 77))
 
-      target.pick(dd: :ee, ff: :gg).must_equal({ dd: { ee: 55 }, ff: { gg: 77 } })
+      assert_equal target.pick(dd: :ee, ff: :gg), { dd: { ee: 55 }, ff: { gg: 77 } }
     end
 
     it 'allows you to specify pick lists with arrays when picking recursively' do
       target = OpenStruct.new aa: (OpenStruct.new bb: 22, cc: (OpenStruct.new dd: 44, ee: 55))
 
-      target.pick(aa: [:bb, cc: [:dd, :ee]]).must_equal({ aa: { bb: 22, cc: { dd: 44, ee: 55 } } })
+      assert_equal target.pick(aa: [:bb, cc: [:dd, :ee]]), { aa: { bb: 22, cc: { dd: 44, ee: 55 } } }
     end
 
   end

data/test/augmented/objects/tackable_test.rb

@@ -11,13 +11,13 @@ describe Augmented::Objects::Tackable do
 
       obj.tack lorem: 123, ipsum: -> { self }
 
-      obj.lorem.must_equal 123
-      obj.ipsum.object_id.must_equal obj.object_id
+      assert_equal obj.lorem, 123
+      assert_equal obj.ipsum.object_id, obj.object_id
     end
 
     it 'returns self' do
       obj = Object.new
-      obj.tack.object_id.must_equal obj.object_id
+      assert_equal obj.tack.object_id, obj.object_id
     end
 
   end

data/test/augmented/objects/tappable_test.rb

@@ -12,11 +12,11 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_if(true) { |subj| test = subj.upcase }
 
-      test.must_equal 'ABC'
+      assert_equal test, 'ABC'
 
       subject.tap_if(Object.new) { |subj| test = subj.reverse }
 
-      test.must_equal 'cba'
+      assert_equal test, 'cba'
     end
 
     it 'does not execute block if condition is falsy' do
@@ -25,11 +25,11 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_if(false) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
 
       subject.tap_if(nil) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
     end
 
     it 'executes block if condition evaluates to truish' do
@@ -40,11 +40,11 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_if(condition_1) { |subj| test = subj.upcase }
 
-      test.must_equal 'ABC'
+      assert_equal test, 'ABC'
 
       subject.tap_if(condition_2) { |subj| test = subj.reverse }
 
-      test.must_equal 'cba'
+      assert_equal test, 'cba'
     end
 
     it 'does not execute block if condition evaluates to falsy' do
@@ -55,18 +55,18 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_if(condition_1) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
 
       subject.tap_if(condition_2) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
     end
 
     it 'always returns the object' do
       subject = 'abc'
 
-      subject.tap_if(true){}.must_be_same_as subject
-      subject.tap_if(false){}.must_be_same_as subject
+      assert_same subject.tap_if(true){}, subject
+      assert_same subject.tap_if(false){}, subject
     end
 
   end
@@ -79,11 +79,11 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_unless(false) { |subj| test = subj.upcase }
 
-      test.must_equal 'ABC'
+      assert_equal test, 'ABC'
 
       subject.tap_unless(nil) { |subj| test = subj.reverse }
 
-      test.must_equal 'cba'
+      assert_equal test, 'cba'
     end
 
     it 'does not execute block if condition is truish' do
@@ -92,11 +92,11 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_unless(true) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
 
       subject.tap_unless(Object.new) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
     end
 
     it 'executes block if condition evaluates to falsy' do
@@ -107,11 +107,11 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_unless(condition_1) { |subj| test = subj.upcase }
 
-      test.must_equal 'ABC'
+      assert_equal test, 'ABC'
 
       subject.tap_unless(condition_2) { |subj| test = subj.reverse }
 
-      test.must_equal 'cba'
+      assert_equal test, 'cba'
     end
 
     it 'does not execute block if condition evaluates to truish' do
@@ -122,18 +122,18 @@ describe Augmented::Objects::Tappable do
 
       subject.tap_unless(condition_1) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
 
       subject.tap_unless(condition_2) { |subj| test = subj.upcase }
 
-      test.must_equal nil
+      assert_nil test
     end
 
     it 'always returns the object' do
       subject = 'abc'
 
-      subject.tap_unless(true){}.must_be_same_as subject
-      subject.tap_unless(false){}.must_be_same_as subject
+      assert_same subject.tap_unless(true){}, subject
+      assert_same subject.tap_unless(false){}, subject
     end
 
   end

data/test/augmented/objects/thru_test.rb

@@ -9,12 +9,12 @@ describe Augmented::Objects::Thru do
     it 'returns the result of applying the given function to the object' do
       plus_10 = -> i { i + 10 }
 
-      5.thru(&plus_10).must_equal 15
+      assert_equal 5.thru(&plus_10), 15
     end
 
     it 'returns the object untouched if called without arguments' do
       obj = Object.new
-      obj.thru.object_id.must_equal obj.object_id
+      assert_equal obj.thru.object_id, obj.object_id
     end
 
   end
@@ -24,8 +24,8 @@ describe Augmented::Objects::Thru do
     it 'applies the given function to the object if the condition is truish' do
       plus_10 = -> i { i + 10 }
 
-      5.thru_if(true, &plus_10).must_equal 15
-      5.thru_if(Object.new, &plus_10).must_equal 15
+      assert_equal 5.thru_if(true, &plus_10), 15
+      assert_equal 5.thru_if(Object.new, &plus_10), 15
     end
 
     it 'applies the given function to the object if the condition evaluates to truish' do
@@ -34,15 +34,15 @@ describe Augmented::Objects::Thru do
       condition_1 = -> i { i == 5 }
       condition_2 = -> i { i.to_s }
 
-      5.thru_if(condition_1, &plus_10).must_equal 15
-      5.thru_if(condition_2, &plus_10).must_equal 15
+      assert_equal 5.thru_if(condition_1, &plus_10), 15
+      assert_equal 5.thru_if(condition_2, &plus_10), 15
     end
 
     it 'returns the object without applying the function if the condition is falsy' do
       plus_10 = -> i { i + 10 }
 
-      5.thru_if(false, &plus_10).must_equal 5
-      5.thru_if(nil,   &plus_10).must_equal 5
+      assert_equal 5.thru_if(false, &plus_10), 5
+      assert_equal 5.thru_if(nil,   &plus_10), 5
     end
 
     it 'returns the object without applying the function if the condition evaluates to falsy' do
@@ -51,8 +51,8 @@ describe Augmented::Objects::Thru do
       condition_1 = -> i { i == 10 }
       condition_2 = -> i { nil }
 
-      5.thru_if(condition_1, &plus_10).must_equal 5
-      5.thru_if(condition_2, &plus_10).must_equal 5
+      assert_equal 5.thru_if(condition_1, &plus_10), 5
+      assert_equal 5.thru_if(condition_2, &plus_10), 5
     end
 
   end
@@ -62,8 +62,8 @@ describe Augmented::Objects::Thru do
     it 'applies the given function to the object if the condition is falsy' do
       plus_10 = -> i { i + 10 }
 
-      5.thru_unless(false, &plus_10).must_equal 15
-      5.thru_unless(nil,   &plus_10).must_equal 15
+      assert_equal 5.thru_unless(false, &plus_10), 15
+      assert_equal 5.thru_unless(nil,   &plus_10), 15
     end
 
     it 'applies the given function to the object if the condition evaluates to falsy' do
@@ -72,15 +72,15 @@ describe Augmented::Objects::Thru do
       condition_1 = -> i { i == 10 }
       condition_2 = -> i { nil }
 
-      5.thru_unless(condition_1, &plus_10).must_equal 15
-      5.thru_unless(condition_2, &plus_10).must_equal 15
+      assert_equal 5.thru_unless(condition_1, &plus_10), 15
+      assert_equal 5.thru_unless(condition_2, &plus_10), 15
     end
 
     it 'returns the object without applying the function if the condition is truish' do
       plus_10 = -> i { i + 10 }
 
-      5.thru_unless(true, &plus_10).must_equal 5
-      5.thru_unless(Object.new, &plus_10).must_equal 5
+      assert_equal 5.thru_unless(true, &plus_10), 5
+      assert_equal 5.thru_unless(Object.new, &plus_10), 5
     end
 
     it 'returns the object without applying the function if the condition evaluates to truish' do
@@ -89,8 +89,8 @@ describe Augmented::Objects::Thru do
       condition_1 = -> i { i == 5 }
       condition_2 = -> i { i.to_s }
 
-      5.thru_unless(condition_1, &plus_10).must_equal 5
-      5.thru_unless(condition_2, &plus_10).must_equal 5
+      assert_equal 5.thru_unless(condition_1, &plus_10), 5
+      assert_equal 5.thru_unless(condition_2, &plus_10), 5
     end
 
   end

data/test/augmented/procs/chainable_test.rb

@@ -15,7 +15,7 @@ describe Augmented::Procs::Chainable do
 
       chain = add_one | triple | sub_two | add_twenty
 
-      chain.call(1).must_equal 24
+      assert_equal chain.call(1), 24
     end
 
   end

data/test/augmented/procs/rescuable_test.rb

@@ -12,7 +12,7 @@ describe Augmented::Procs::Rescuable do
       unsafe_proc = -> { raise specific_exception_class }
       rescued_proc = unsafe_proc.rescues specific_exception_class, 42
 
-      rescued_proc.call.must_equal 42
+      assert_equal rescued_proc.call, 42
     end
 
     it 'returns a proc which returns the result of the provided block if the expected exception is raised' do
@@ -21,7 +21,7 @@ describe Augmented::Procs::Rescuable do
       unsafe_proc = -> { raise specific_exception_class }
       rescued_proc = unsafe_proc.rescues(specific_exception_class){ |exception| exception }
 
-      rescued_proc.call.must_be_instance_of specific_exception_class
+      assert_instance_of specific_exception_class, rescued_proc.call
     end
 
     it 'returns a proc which lets exceptions other than the expected one to be raised' do
@@ -30,7 +30,7 @@ describe Augmented::Procs::Rescuable do
       unsafe_proc = -> { raise RuntimeError }
       rescued_proc = unsafe_proc.rescues specific_exception_class, 42
 
-      rescued_proc.must_raise RuntimeError
+      assert_raises(RuntimeError){ rescued_proc.call }
     end
 
   end

data/test/augmented/symbols/arguable_test.rb

@@ -23,17 +23,17 @@ describe Augmented::Symbols::Arguable do
     end
 
     it 'returns a function that calls the method named <symbol> while also passing the arguments supplied' do
-      :add.with(9).call(@eleven).must_equal 20
-      :add_many.with(3, 6, 10, 20, 50).call(@eleven).must_equal 100
+      assert_equal :add.with(9).call(@eleven), 20
+      assert_equal :add_many.with(3, 6, 10, 20, 50).call(@eleven), 100
     end
 
     describe 'the returned function' do
 
       it "it preserves Symbol's `to_proc` behavior of passing extra arguments, if supplied" do
-        :add.to_proc.call(@eleven, 4).must_equal 15
-        :add.with().call(@eleven, 4).must_equal 15
+        assert_equal :add.to_proc.call(@eleven, 4), 15
+        assert_equal :add.with().call(@eleven, 4), 15
 
-        :add_many.with(10, 20).call(@eleven, 4, 5).must_equal 50
+        assert_equal :add_many.with(10, 20).call(@eleven, 4, 5), 50
       end
 
       it 'passes along the block supplied to `with`, if any' do
@@ -42,7 +42,7 @@ describe Augmented::Symbols::Arguable do
 
         :do_whatever.with(&set_result).call(@eleven)
 
-        result.must_equal 11
+        assert_equal result, 11
       end
 
     end

data/test/augmented/symbols/comparing_test.rb

@@ -16,15 +16,15 @@ describe Augmented::Symbols::Comparing do
     it 'returns a function that sends <symbol> to two objects and compares the results with `==`' do
       comparator = :lorem_ipsum.eq
 
-      comparator.call(thing_A, thing_B).must_equal true
-      comparator.call(thing_A, thing_C).must_equal false
+      assert_equal comparator.call(thing_A, thing_B), true
+      assert_equal comparator.call(thing_A, thing_C), false
     end
 
     it 'if you give it a value, it returns a function that sends <symbol> to an object and compares the result to a given value using `==`' do
       comparator = :lorem_ipsum.eq(123)
 
-      comparator.call(thing_A).must_equal true
-      comparator.call(thing_C).must_equal false
+      assert_equal comparator.call(thing_A), true
+      assert_equal comparator.call(thing_C), false
     end
 
   end
@@ -34,15 +34,15 @@ describe Augmented::Symbols::Comparing do
     it 'returns a function that sends <symbol> to two objects and compares the results with `!=`' do
       comparator = :lorem_ipsum.neq
 
-      comparator.call(thing_A, thing_B).must_equal false
-      comparator.call(thing_A, thing_C).must_equal true
+      assert_equal comparator.call(thing_A, thing_B), false
+      assert_equal comparator.call(thing_A, thing_C), true
     end
 
     it 'if you give it a value, it returns a function that sends <symbol> to an object and compares the result to a given value using `!=`' do
       comparator = :lorem_ipsum.neq(123)
 
-      comparator.call(thing_A).must_equal false
-      comparator.call(thing_C).must_equal true
+      assert_equal comparator.call(thing_A), false
+      assert_equal comparator.call(thing_C), true
     end
 
   end
@@ -52,17 +52,17 @@ describe Augmented::Symbols::Comparing do
     it 'returns a function that sends <symbol> to two objects and compares the results with `<`' do
       comparator = :lorem_ipsum.lt
 
-      comparator.call(thing_A, thing_B).must_equal false
-      comparator.call(thing_A, thing_C).must_equal true
-      comparator.call(thing_C, thing_B).must_equal false
+      assert_equal comparator.call(thing_A, thing_B), false
+      assert_equal comparator.call(thing_A, thing_C), true
+      assert_equal comparator.call(thing_C, thing_B), false
     end
 
     it 'if you give it a value, it returns a function that sends <symbol> to an object and compares the result to a given value using `<`' do
       comparator = :lorem_ipsum.lt(123)
 
-      comparator.call(thing_A).must_equal false
-      comparator.call(thing_C).must_equal false
-      comparator.call(thing_D).must_equal true
+      assert_equal comparator.call(thing_A), false
+      assert_equal comparator.call(thing_C), false
+      assert_equal comparator.call(thing_D), true
     end
 
   end
@@ -72,17 +72,17 @@ describe Augmented::Symbols::Comparing do
     it 'returns a function that sends <symbol> to two objects and compares the results with `<=`' do
       comparator = :lorem_ipsum.lte
 
-      comparator.call(thing_A, thing_B).must_equal true
-      comparator.call(thing_A, thing_C).must_equal true
-      comparator.call(thing_C, thing_B).must_equal false
+      assert_equal comparator.call(thing_A, thing_B), true
+      assert_equal comparator.call(thing_A, thing_C), true
+      assert_equal comparator.call(thing_C, thing_B), false
     end
 
     it 'if you give it a value, it returns a function that sends <symbol> to an object and compares the result to a given value using `<=`' do
       comparator = :lorem_ipsum.lte(123)
 
-      comparator.call(thing_A).must_equal true
-      comparator.call(thing_C).must_equal false
-      comparator.call(thing_D).must_equal true
+      assert_equal comparator.call(thing_A), true
+      assert_equal comparator.call(thing_C), false
+      assert_equal comparator.call(thing_D), true
     end
 
   end
@@ -92,17 +92,17 @@ describe Augmented::Symbols::Comparing do
     it 'returns a function that sends <symbol> to two objects and compares the results with `>`' do
       comparator = :lorem_ipsum.gt
 
-      comparator.call(thing_A, thing_B).must_equal false
-      comparator.call(thing_A, thing_C).must_equal false
-      comparator.call(thing_C, thing_B).must_equal true
+      assert_equal comparator.call(thing_A, thing_B), false
+      assert_equal comparator.call(thing_A, thing_C), false
+      assert_equal comparator.call(thing_C, thing_B), true
     end
 
     it 'if you give it a value, it returns a function that sends <symbol> to an object and compares the result to a given value using `>`' do
       comparator = :lorem_ipsum.gt(123)
 
-      comparator.call(thing_A).must_equal false
-      comparator.call(thing_C).must_equal true
-      comparator.call(thing_D).must_equal false
+      assert_equal comparator.call(thing_A), false
+      assert_equal comparator.call(thing_C), true
+      assert_equal comparator.call(thing_D), false
     end
 
   end
@@ -112,17 +112,17 @@ describe Augmented::Symbols::Comparing do
     it 'returns a function that sends <symbol> to two objects and compares the results with `>=`' do
       comparator = :lorem_ipsum.gte
 
-      comparator.call(thing_A, thing_B).must_equal true
-      comparator.call(thing_A, thing_C).must_equal false
-      comparator.call(thing_C, thing_B).must_equal true
+      assert_equal comparator.call(thing_A, thing_B), true
+      assert_equal comparator.call(thing_A, thing_C), false
+      assert_equal comparator.call(thing_C, thing_B), true
     end
 
     it 'if you give it a value, it returns a function that sends <symbol> to an object and compares the result to a given value using `>=`' do
       comparator = :lorem_ipsum.gte(123)
 
-      comparator.call(thing_A).must_equal true
-      comparator.call(thing_C).must_equal true
-      comparator.call(thing_D).must_equal false
+      assert_equal comparator.call(thing_A), true
+      assert_equal comparator.call(thing_C), true
+      assert_equal comparator.call(thing_D), false
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: augmented
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - bruno
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-21 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 description: Adds a few useful extra methods to some of Ruby's core types, available
   as refinements.
 email:
@@ -110,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Useful extra methods for some Ruby core types.