augmented 0.2.2 → 0.2.7

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

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 }
-
-      assert_equal 5.thru(&plus_10), 15
-    end
-
-    it 'returns the object untouched if called without arguments' do
-      obj = Object.new
-      assert_equal obj.thru.object_id, 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 }
-
-      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
-      plus_10 = -> i { i + 10 }
-
-      condition_1 = -> i { i == 5 }
-      condition_2 = -> i { i.to_s }
-
-      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 }
-
-      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
-      plus_10 = -> i { i + 10 }
-
-      condition_1 = -> i { i == 10 }
-      condition_2 = -> i { nil }
-
-      assert_equal 5.thru_if(condition_1, &plus_10), 5
-      assert_equal 5.thru_if(condition_2, &plus_10), 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 }
-
-      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
-      plus_10 = -> i { i + 10 }
-
-      condition_1 = -> i { i == 10 }
-      condition_2 = -> i { nil }
-
-      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 }
-
-      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
-      plus_10 = -> i { i + 10 }
-
-      condition_1 = -> i { i == 5 }
-      condition_2 = -> i { i.to_s }
-
-      assert_equal 5.thru_unless(condition_1, &plus_10), 5
-      assert_equal 5.thru_unless(condition_2, &plus_10), 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
-
-      assert_equal chain.call(1), 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
-
-      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
-      specific_exception_class = Class.new RuntimeError
-
-      unsafe_proc = -> { raise specific_exception_class }
-      rescued_proc = unsafe_proc.rescues(specific_exception_class){ |exception| exception }
-
-      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
-      specific_exception_class = Class.new RuntimeError
-
-      unsafe_proc = -> { raise RuntimeError }
-      rescued_proc = unsafe_proc.rescues specific_exception_class, 42
-
-      assert_raises(RuntimeError){ rescued_proc.call }
-    end
-
-  end
-
-end