augmented 0.2.0 → 0.2.5

data/test/augmented/modules/refined_test.rb

@@ -1,27 +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.must_equal 'Hello world.'
-          'hello world'.fill('!').must_equal '!!!!!!!!!!!'
-        end
-      end
-    end
-
-    it 'creates a refinement module on the fly for the given class, with the procs supplied' do
-      TesterClass.new.do_test
-    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 }
-
-      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
-    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
-    end
-
-  end
-
-  describe '#unless' do
-
-    it 'returns the object if the condition evaluates to falsy' 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
-    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
-    end
-
-  end
-
-  describe '#else' 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
-    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
-    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
-
-      target.pick(:aaa, :ccc).must_equal({ 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}]
-    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 } } })
-
-      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 } })
-    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 } } })
-    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 }
-
-      obj.lorem.must_equal 123
-      obj.ipsum.object_id.must_equal obj.object_id
-    end
-
-    it 'returns self' do
-      obj = Object.new
-      obj.tack.object_id.must_equal 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 }
-
-      test.must_equal 'ABC'
-
-      subject.tap_if(Object.new) { |subj| test = subj.reverse }
-
-      test.must_equal 'cba'
-    end
-
-    it 'does not execute block if condition is falsy' do
-      subject = 'abc'
-      test = nil
-
-      subject.tap_if(false) { |subj| test = subj.upcase }
-
-      test.must_equal nil
-
-      subject.tap_if(nil) { |subj| test = subj.upcase }
-
-      test.must_equal nil
-    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 }
-
-      test.must_equal 'ABC'
-
-      subject.tap_if(condition_2) { |subj| test = subj.reverse }
-
-      test.must_equal '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 }
-
-      test.must_equal nil
-
-      subject.tap_if(condition_2) { |subj| test = subj.upcase }
-
-      test.must_equal nil
-    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
-    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 }
-
-      test.must_equal 'ABC'
-
-      subject.tap_unless(nil) { |subj| test = subj.reverse }
-
-      test.must_equal 'cba'
-    end
-
-    it 'does not execute block if condition is truish' do
-      subject = 'abc'
-      test = nil
-
-      subject.tap_unless(true) { |subj| test = subj.upcase }
-
-      test.must_equal nil
-
-      subject.tap_unless(Object.new) { |subj| test = subj.upcase }
-
-      test.must_equal nil
-    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 }
-
-      test.must_equal 'ABC'
-
-      subject.tap_unless(condition_2) { |subj| test = subj.reverse }
-
-      test.must_equal '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 }
-
-      test.must_equal nil
-
-      subject.tap_unless(condition_2) { |subj| test = subj.upcase }
-
-      test.must_equal nil
-    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
-    end
-
-  end
-
-end

data/test/augmented/objects/thru_test.rb

@@ -1,98 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/objects/thru'
-
-describe Augmented::Objects::Thru do
-  using Augmented::Objects::Thru
-
-  describe '#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
-    end
-
-    it 'returns the object untouched if called without arguments' do
-      obj = Object.new
-      obj.thru.object_id.must_equal obj.object_id
-    end
-
-  end
-
-  describe '#thru_if' 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
-    end
-
-    it 'applies the given function to the object if the condition evaluates to truish' do
-      plus_10 = -> i { i + 10 }
-
-      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
-    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
-    end
-
-    it 'returns the object without applying the function if the condition evaluates to falsy' do
-      plus_10 = -> i { i + 10 }
-
-      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
-    end
-
-  end
-
-  describe '#thru_unless' 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
-    end
-
-    it 'applies the given function to the object if the condition evaluates to falsy' do
-      plus_10 = -> i { i + 10 }
-
-      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
-    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
-    end
-
-    it 'returns the object without applying the function if the condition evaluates to truish' do
-      plus_10 = -> i { i + 10 }
-
-      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
-    end
-
-  end
-
-end

data/test/augmented/procs/chainable_test.rb

@@ -1,22 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/procs/chainable'
-
-describe Augmented::Procs::Chainable do
-  using Augmented::Procs::Chainable
-
-  describe '#|' do
-
-    it 'returns a function that invokes from left to right' do
-
-      add_one = -> (i) { i + 1 }
-      triple = -> (i) { i * 3 }
-      sub_two = -> (i) { i - 2 }
-      add_twenty = -> (i) { i + 20 }
-
-      chain = add_one | triple | sub_two | add_twenty
-
-      chain.call(1).must_equal 24
-    end
-
-  end
-end

data/test/augmented/procs/rescuable_test.rb

@@ -1,38 +0,0 @@
-require 'minitest/autorun'
-require 'augmented/procs/rescuable'
-
-describe Augmented::Procs::Rescuable do
-  using Augmented::Procs::Rescuable
-
-  describe '#rescues' do
-
-    it 'returns a proc which returns a provided value if the expected exception is raised' do
-      specific_exception_class = Class.new RuntimeError
-
-      unsafe_proc = -> { raise specific_exception_class }
-      rescued_proc = unsafe_proc.rescues specific_exception_class, 42
-
-      rescued_proc.call.must_equal 42
-    end
-
-    it 'returns a proc which returns the result of the provided block if the expected exception is raised' do
-      specific_exception_class = Class.new RuntimeError
-
-      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
-    end
-
-    it 'returns a proc which lets exceptions other than the expected one to be raised' do
-      specific_exception_class = Class.new RuntimeError
-
-      unsafe_proc = -> { raise RuntimeError }
-      rescued_proc = unsafe_proc.rescues specific_exception_class, 42
-
-      rescued_proc.must_raise RuntimeError
-    end
-
-  end
-
-end