augmented 0.2.2 → 0.2.3

data/test/augmented/enumerators/indexing_test.rb

@@ -1,15 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/enumerators/indexing'
-
-describe Augmented::Enumerators::Indexing do
-  using Augmented::Enumerators::Indexing
-
-  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
-      assert_equal ['a', 'bbb', 'c', 'dd'].to_enum.index_by(&:length), ({ 1 => 'c', 2 => 'dd', 3 => 'bbb' })
-    end
-
-  end
-
-end

data/test/augmented/hashes/mappable_test.rb

@@ -1,37 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/hashes/mappable'
-
-describe Augmented::Hashes::Mappable do
-  using Augmented::Hashes::Mappable
-
-  describe '#map_values' do
-
-    it 'returns a new hash with the same keys but transformed values' do
-      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] }
-
-      assert_equal result.values, [[:aa, hash.object_id], [:bb, hash.object_id]]
-    end
-
-  end
-
-  describe '#map_keys' do
-
-    it 'returns a new hash with the same values but transformed keys' do
-      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] }
-
-      assert_equal result.keys, [[11, hash.object_id], [22, hash.object_id]]
-    end
-
-  end
-
-end

data/test/augmented/hashes/polymorphable_test.rb

@@ -1,45 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/hashes/polymorphable'
-require 'ostruct'
-
-describe Augmented::Hashes::Polymorphable do
-  using Augmented::Hashes::Polymorphable
-
-  describe '#polymorph' 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
-
-      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
-        assert_instance_of OpenStruct, { 'type' => 'OpenStruct' }.polymorph
-      end
-
-      it 'can be an arbitrary attribute in the hash' do
-        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
-        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
-        assert_instance_of OpenStruct, { type: 'TotallyIgnoredClass' }.polymorph(OpenStruct)
-      end
-
-    end
-
-    it 'raises an error if it cannot find a type class' do
-      assert_raises(ArgumentError){ {}.polymorph }
-      assert_raises(ArgumentError){ { type: nil }.polymorph }
-    end
-
-  end
-
-end

data/test/augmented/hashes/transformable_test.rb

@@ -1,87 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/hashes/transformable'
-require 'ostruct'
-
-describe Augmented::Hashes::Transformable do
-  using Augmented::Hashes::Transformable
-
-  describe '#transform(!)' do
-
-    it 'mutates the values of the given keys by applying their respective procables' do
-      hash = { thing1: 100, thing2: OpenStruct.new(random_method_name: 900) }.freeze
-
-      new_hash = hash.transform thing1: -> i { i * 3 }, thing2: :random_method_name
-
-      assert_equal new_hash[:thing1], 300
-      assert_equal new_hash[:thing2], 900
-
-
-      # mutable version test:
-      hash = { thing1: 100, thing2: OpenStruct.new(random_method_name: 900) }
-
-      hash.transform! thing1: -> i { i * 3 }, thing2: :random_method_name
-
-      assert_equal hash[:thing1], 300
-      assert_equal hash[:thing2], 900
-    end
-
-    it 'applies procables recursively when given a hash' do
-      hash = { a: { b: { c: 100 } } }.freeze
-
-      new_hash = hash.transform({ a: { b: { c: -> i { i * 3 } } } })
-
-      assert_equal new_hash[:a][:b][:c], 300
-
-
-      # mutable version test:
-      hash = { a: { b: { c: 100 } } }
-
-      hash.transform!({ a: { b: { c: -> i { i * 3 } } } })
-
-      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
-      hash = { a: [ { my_value: 10 }, { my_value: 20 } ] }.freeze
-
-      new_hash = hash.transform(a: { my_value: -> i { i * 3 } })
-
-      assert_equal new_hash[:a], [ { my_value: 30 }, { my_value: 60 } ]
-
-
-      # mutable version test:
-      hash = { a: [ { my_value: 10 }, { my_value: 20 } ] }
-
-      hash.transform!(a: { my_value: -> i { i * 3 } })
-
-      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
-      add_ten = -> i { i + 10 }
-      double = -> i { i * 2 }
-
-      hash = { a: 2.5 }.freeze
-
-      new_hash = hash.transform a: [ :to_i, add_ten, double ]
-
-      assert_equal new_hash[:a], 24
-
-
-      # mutable version test:
-      hash = { a: 2.5 }
-
-      hash.transform! a: [ :to_i, add_ten, double ]
-
-      assert_equal hash[:a], 24
-    end
-
-    it 'returns itself (mutable version only)' do
-      hash = {}
-      same_hash = hash.transform! Hash.new
-
-      assert_equal same_hash.object_id, hash.object_id
-    end
-
-  end
-end

data/test/augmented/modules/refined_test.rb

@@ -1,29 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/modules/refined'
-
-describe Augmented::Modules::Refined do
-  using Augmented::Modules::Refined
-
-  describe '#refined' do
-
-    before do
-      class TesterClass
-        using refined String,
-          as_phrase: -> { self.capitalize.gsub(/\.?\z/, '.') },
-          fill:      -> filler { (filler * self.length)[0..length] }
-
-        def do_test
-          [
-            '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
-      assert_equal TesterClass.new.do_test, [true, true]
-    end
-
-  end
-end

data/test/augmented/objects/iffy_test.rb

@@ -1,69 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/objects/iffy'
-
-describe Augmented::Objects::Iffy do
-  using Augmented::Objects::Iffy
-
-  describe '#if' do
-
-    it 'returns the object if the condition evaluates to truish' do
-      subject = 'abc'
-      condition = -> subj { subj.length == 3 }
-
-      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 }
-
-      assert_nil subject.if(false)
-      assert_nil subject.if(nil)
-      assert_nil subject.if(&condition)
-    end
-
-  end
-
-  describe '#unless' do
-
-    it 'returns the object if the condition evaluates to falsy' do
-      subject = 'abc'
-      condition = -> subj { subj.length == 0 }
-
-      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 }
-
-      assert_nil subject.unless(true)
-      assert_nil subject.unless(Object.new)
-      assert_nil subject.unless(&condition)
-    end
-
-  end
-
-  describe '#else' do
-
-    it 'returns the alternative if the object is falsy' do
-      alternative = Object.new
-
-      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
-
-      assert_same true.else(123), true
-      assert_same subject.else(123), subject
-    end
-
-  end
-
-end

data/test/augmented/objects/pickable_test.rb

@@ -1,39 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/objects/pickable'
-require 'ostruct'
-
-describe Augmented::Objects::Pickable do
-  using Augmented::Objects::Pickable
-
-  describe '#pick' 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
-
-      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) ]
-
-      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)))
-
-      assert_equal target.pick(aa: { bb: :cc }), { aa: { bb: { cc: 33 } } }
-
-      target = OpenStruct.new(dd: OpenStruct.new(ee: 55), ff: OpenStruct.new(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))
-
-      assert_equal target.pick(aa: [:bb, cc: [:dd, :ee]]), { aa: { bb: 22, cc: { dd: 44, ee: 55 } } }
-    end
-
-  end
-end

data/test/augmented/objects/tackable_test.rb

@@ -1,25 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/objects/tackable'
-
-describe Augmented::Objects::Tackable do
-  using Augmented::Objects::Tackable
-
-  describe '#tack' do
-
-    it 'attaches new methods to an object' do
-      obj = Object.new
-
-      obj.tack lorem: 123, ipsum: -> { self }
-
-      assert_equal obj.lorem, 123
-      assert_equal obj.ipsum.object_id, obj.object_id
-    end
-
-    it 'returns self' do
-      obj = Object.new
-      assert_equal obj.tack.object_id, obj.object_id
-    end
-
-  end
-
-end

data/test/augmented/objects/tappable_test.rb

@@ -1,141 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/objects/tappable'
-
-describe Augmented::Objects::Tappable do
-  using Augmented::Objects::Tappable
-
-  describe '#tap_if' do
-
-    it 'executes block if condition is truish' do
-      subject = 'abc'
-      test = nil
-
-      subject.tap_if(true) { |subj| test = subj.upcase }
-
-      assert_equal test, 'ABC'
-
-      subject.tap_if(Object.new) { |subj| test = subj.reverse }
-
-      assert_equal test, 'cba'
-    end
-
-    it 'does not execute block if condition is falsy' do
-      subject = 'abc'
-      test = nil
-
-      subject.tap_if(false) { |subj| test = subj.upcase }
-
-      assert_nil test
-
-      subject.tap_if(nil) { |subj| test = subj.upcase }
-
-      assert_nil test
-    end
-
-    it 'executes block if condition evaluates to truish' do
-      subject = 'abc'
-      test = nil
-      condition_1 = -> subj { subj.length == 3 }
-      condition_2 = -> subj { subj.length }
-
-      subject.tap_if(condition_1) { |subj| test = subj.upcase }
-
-      assert_equal test, 'ABC'
-
-      subject.tap_if(condition_2) { |subj| test = subj.reverse }
-
-      assert_equal test, 'cba'
-    end
-
-    it 'does not execute block if condition evaluates to falsy' do
-      subject = 'abc'
-      test = nil
-      condition_1 = -> subj { subj.length == 0 }
-      condition_2 = -> subj { nil }
-
-      subject.tap_if(condition_1) { |subj| test = subj.upcase }
-
-      assert_nil test
-
-      subject.tap_if(condition_2) { |subj| test = subj.upcase }
-
-      assert_nil test
-    end
-
-    it 'always returns the object' do
-      subject = 'abc'
-
-      assert_same subject.tap_if(true){}, subject
-      assert_same subject.tap_if(false){}, subject
-    end
-
-  end
-
-  describe '#tap_unless' do
-
-    it 'executes block if condition is falsy' do
-      subject = 'abc'
-      test = nil
-
-      subject.tap_unless(false) { |subj| test = subj.upcase }
-
-      assert_equal test, 'ABC'
-
-      subject.tap_unless(nil) { |subj| test = subj.reverse }
-
-      assert_equal test, 'cba'
-    end
-
-    it 'does not execute block if condition is truish' do
-      subject = 'abc'
-      test = nil
-
-      subject.tap_unless(true) { |subj| test = subj.upcase }
-
-      assert_nil test
-
-      subject.tap_unless(Object.new) { |subj| test = subj.upcase }
-
-      assert_nil test
-    end
-
-    it 'executes block if condition evaluates to falsy' do
-      subject = 'abc'
-      test = nil
-      condition_1 = -> subj { subj.length == 0 }
-      condition_2 = -> subj { nil }
-
-      subject.tap_unless(condition_1) { |subj| test = subj.upcase }
-
-      assert_equal test, 'ABC'
-
-      subject.tap_unless(condition_2) { |subj| test = subj.reverse }
-
-      assert_equal test, 'cba'
-    end
-
-    it 'does not execute block if condition evaluates to truish' do
-      subject = 'abc'
-      test = nil
-      condition_1 = -> subj { subj.length == 3 }
-      condition_2 = -> subj { subj.length }
-
-      subject.tap_unless(condition_1) { |subj| test = subj.upcase }
-
-      assert_nil test
-
-      subject.tap_unless(condition_2) { |subj| test = subj.upcase }
-
-      assert_nil test
-    end
-
-    it 'always returns the object' do
-      subject = 'abc'
-
-      assert_same subject.tap_unless(true){}, subject
-      assert_same subject.tap_unless(false){}, subject
-    end
-
-  end
-
-end