augmented 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab72b071901020afba04d0c492f1bc6363545a2b
+  data.tar.gz: 529677d1369c9d9125212faa80a6f71cef648e81
+SHA512:
+  metadata.gz: 3376e35d3240db0dd12e8dca2ae0798200d8b75fda9b1a6b90d6c6638de1f5d2df8dda2d26ca0763dd8b9e20f24183c9930005f1bf5cdb168a33c2985fc2a65c
+  data.tar.gz: 09f783c3f13bd508fe7d012955ade5c12d7c9dce2e215fa7d065a72669567a06cad27c3478d3a391d55386a8a5a01f334c0ec696d667dd67593a6cf37b6aff0f

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.sublime-*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in augmented.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 brunze
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,170 @@
+# Augmented
+
+`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.
+
+## Installation
+
+In your Gemfile:
+
+```ruby
+gem 'augmented'
+```
+
+Or:
+
+    $ gem install augmented
+
+## Usage
+
+You have 3 ways of loading the refinements. You can load all of them at once:
+
+```ruby
+using Augmented
+```
+
+You can load all refinements for just one type:
+
+```ruby
+using Augmented::Objects
+using Augmented::Hashes
+using Augmented::Symbols
+# etc.
+```
+
+Or you can load just the methods you need:
+
+```ruby
+using Augmented::Objects::Pickable
+using Augmented::Symbols::Arguable
+using Augmented::Procs::Chainable
+# etc.
+```
+
+## Quick Examples
+
+##### `Enumerator#index_by`
+
+Builds an index of all elements of an enumerator according to the given criterion.
+
+```ruby
+['a', 'bb', 'ccccc'].to_enum.index_by(&:length)
+# {1=>"a", 2=>"bb", 5=>"ccccc"}
+```
+
+##### `Hash#polymorph`
+
+Creates an object from an Hash.
+
+```ruby
+class Sheep
+  def initialize attributes
+    @sound = attributes[:sound]
+  end
+
+  def speak
+    puts @sound
+  end
+end
+
+{ type: 'Sheep', sound: 'meeehh' }.polymorph.speak
+# meeehh
+```
+
+##### `Hash#transform`, `Hash#transform!`
+
+Recursively applies functions to a tree of hashes.
+
+```ruby
+tree = { lorem: 'ipsum', dolor: [ { sit: 10}, { sit: 20 } ] }
+triple =  -> i { i * 3 }
+
+tree.transform({ lorem: :upcase, dolor: { sit: triple } })
+# {:lorem=>"IPSUM", :dolor=>[{:sit=>30}, {:sit=>60}]}
+```
+
+##### `Object#pick`
+
+Calls a bunch of methods on an object and collects the results.
+
+```ruby
+class MyThing
+  def lorem; 'hello'; end
+  def ipsum; 'cruel'; end
+  def dolor; 'world'; end
+end
+
+MyThing.new.pick :lorem, :dolor
+# {:lorem=>"hello", :dolor=>"world"}
+```
+
+##### `Object#tack`
+
+Appends a bunch of singleton methods to an object.
+
+```ruby
+Object.new.tack(id: 11, greet: -> { puts "hello I'm #{id}" }).greet
+# hello I'm 11
+```
+
+##### `Object#thru`
+
+Applies a function to an object and returns the result.
+
+```ruby
+filter_words = -> s { s.gsub(/bad/, '').squeeze(' ').strip }
+
+'BAD WORDS, BAD WORDS'.downcase.thru(&filter_words).capitalize
+# Words, words
+```
+
+##### `Proc#|`
+
+Chains several procs together so they execute from left to right.
+
+```ruby
+sub_two = -> i { i - 2 }
+triple = -> i { i * 3 }
+add_twenty = -> i { i + 20 }
+
+(sub_two | triple | add_twenty)[5]
+# 29
+```
+
+##### `Symbol#with`
+
+Like [`Symbol#to_proc`](http://ruby-doc.org/core-2.3.0/Symbol.html#method-i-to_proc) but allows you to pass some arguments along.
+
+```ruby
+class Eleven
+  def add_many *others
+    11 + others.reduce(0, :+)
+  end
+end
+
+:add_many.with(1, 2, 3).call(Eleven.new)
+# 17
+```
+
+##### `Symbol#eq`, `Symbol#neq`, `Symbol#lt`, `Symbol#lte`, `Symbol#gt`, `Symbol#gte`
+
+Creates functions that compare an object's attribute.
+
+```ruby
+class User
+  def initialize name
+    @name = name
+  end
+  attr_reader :name
+end
+
+users = [ User.new('Marianne'), User.new('Jeremy') ]
+
+users.find &(:name.eq 'Marianne')
+# <User:0x... name='Marianne'>
+```
+
+## Contributing
+
+Do you have a method you would like to see added to this library? Perhaps something you keep copying from project to project but always found too small to bother with a gem? Feel free to submit a ticket/pull request with your idea.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+end

data/augmented.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'augmented/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "augmented"
+  spec.version       = Augmented::VERSION
+  spec.authors       = ["bruno"]
+  spec.email         = ["bruno@brunze.com"]
+  spec.summary       = %q{Useful extra methods for some Ruby core types.}
+  spec.description   = %q{Adds a few useful extra methods to some of Ruby's core types, available as refinements.}
+  spec.homepage      = "https://github.com/brunze/augmented"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  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"
+end

data/lib/augmented/enumerators/indexing.rb

@@ -0,0 +1,13 @@
+module Augmented
+  module Enumerators
+    module Indexing
+      refine Enumerator do
+
+        def index_by &criterion
+          Hash[ self.map(&criterion).zip(self) ]
+        end
+
+      end
+    end
+  end
+end

data/lib/augmented/enumerators.rb

@@ -0,0 +1,7 @@
+require 'augmented/enumerators/indexing'
+
+module Augmented
+  module Enumerators
+    include Indexing
+  end
+end

data/lib/augmented/hashes/polymorphable.rb

@@ -0,0 +1,20 @@
+module Augmented
+  module Hashes
+    module Polymorphable
+      refine Hash do
+
+        def polymorph type_attribute_name = :type
+          type = (type_attribute_name if Class === type_attribute_name) ||
+                 self[type_attribute_name] ||
+                 self[type_attribute_name.to_s]
+
+          raise ArgumentError, 'missing the type required for polymorph' if type.to_s.empty?
+
+          klass = Class === type ? type : Object.const_get(type.to_s)
+          klass.new self
+        end
+
+      end
+    end
+  end
+end

data/lib/augmented/hashes/transformable.rb

@@ -0,0 +1,67 @@
+require 'augmented/procs/chainable'
+
+module Augmented
+  module Hashes
+    module Transformable
+      refine Hash do
+
+        def transform transforms
+          Helpers.validate! transforms
+
+          transforms.each_pair.with_object({}) do |(key, procable), new_hash|
+            value = self[key]
+
+            if procable.kind_of?(Hash) && value.kind_of?(Hash)
+              new_hash[key] = value.transform procable
+            elsif value.respond_to? :each
+              new_hash[key] = value.map{ |thing| thing.transform procable }
+            else
+              new_hash[key] = Helpers.make_one_proc(procable).call value
+            end
+          end
+        end
+
+        def transform! transforms
+          Helpers.validate! transforms
+
+          transforms.each_pair do |key, procable|
+            value = self[key]
+
+            if procable.kind_of?(Hash) && value.kind_of?(Hash)
+              self[key] = value.transform! procable
+            elsif value.respond_to? :each
+              self[key] = value.each{ |thing| thing.transform! procable }
+            else
+              self[key] = Helpers.make_one_proc(procable).call value
+            end
+          end
+
+          self
+        end
+
+      end
+
+
+      module Helpers
+        using ::Augmented::Procs::Chainable
+
+        def self.make_one_proc thing
+          if thing.kind_of?(Array)
+            thing.map(&:to_proc).reduce{ |chain, proc| chain | proc }
+          else
+            thing.to_proc
+          end
+        end
+
+        def self.validate! transforms
+          unless transforms.respond_to? :each_pair
+            raise ArgumentError, 'transformations must be specified in a map-like collection (must have `each_pair` enumerator)'
+          end
+        end
+
+      end
+
+      private_constant :Helpers
+    end
+  end
+end

data/lib/augmented/hashes.rb

@@ -0,0 +1,9 @@
+require 'augmented/hashes/polymorphable'
+require 'augmented/hashes/transformable'
+
+module Augmented
+  module Hashes
+    include Polymorphable
+    include Transformable
+  end
+end

data/lib/augmented/objects/pickable.rb

@@ -0,0 +1,33 @@
+module Augmented
+  module Objects
+    module Pickable
+      refine Object do
+
+        def pick *picks
+          ensure_array = -> thing { thing.kind_of?(Array) ? thing : Array[thing] }
+
+          if self.respond_to? :each
+            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]
+                end
+
+              else
+                attribute = pick
+
+                result[attribute] = self.__send__(attribute.to_sym)
+              end
+
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/augmented/objects/tackable.rb

@@ -0,0 +1,21 @@
+module Augmented
+  module Objects
+    module Tackable
+      refine Object do
+
+        def tack **functions
+          functions.each_pair do |name, thing|
+            function = case thing
+                        when Proc, Method, UnboundMethod then thing
+                        else proc{ thing } end
+
+            self.define_singleton_method name, function
+          end
+
+          self
+        end
+
+      end
+    end
+  end
+end

data/lib/augmented/objects/thru.rb

@@ -0,0 +1,14 @@
+module Augmented
+  module Objects
+    module Thru
+      refine Object do
+
+        # as seen on lodash: https://lodash.com/docs#thru
+        def thru &function
+          (function || :itself.to_proc).call self
+        end
+
+      end
+    end
+  end
+end

data/lib/augmented/objects.rb

@@ -0,0 +1,11 @@
+require 'augmented/objects/pickable'
+require 'augmented/objects/tackable'
+require 'augmented/objects/thru'
+
+module Augmented
+  module Objects
+    include Pickable
+    include Tackable
+    include Thru
+  end
+end

data/lib/augmented/procs/chainable.rb

@@ -0,0 +1,13 @@
+module Augmented
+  module Procs
+    module Chainable
+      refine Proc do
+
+        def | other
+          -> (*args) { other.to_proc.call self.call(*args) }
+        end
+
+      end
+    end
+  end
+end

data/lib/augmented/procs.rb

@@ -0,0 +1,7 @@
+require 'augmented/procs/chainable'
+
+module Augmented
+  module Procs
+    include Chainable
+  end
+end

data/lib/augmented/symbols/arguable.rb

@@ -0,0 +1,14 @@
+module Augmented
+  module Symbols
+    module Arguable
+      refine Symbol do
+
+        # credit to Uri Agassi: http://stackoverflow.com/a/23711606/2792897
+        def with *args, &block
+          -> caller, *rest { caller.__send__ self, *rest, *args, &block }
+        end
+
+      end
+    end
+  end
+end

data/lib/augmented/symbols/comparing.rb

@@ -0,0 +1,50 @@
+module Augmented
+  module Symbols
+    module Comparing
+      refine Symbol do
+
+        def eq value = NO_VALUE
+          Helpers.make_compare_function self, :==, value
+        end
+
+        def neq value = NO_VALUE
+          Helpers.make_compare_function self, :!=, value
+        end
+
+        def lt value = NO_VALUE
+          Helpers.make_compare_function self, :<, value
+        end
+
+        def lte value = NO_VALUE
+          Helpers.make_compare_function self, :<=, value
+        end
+
+        def gt value = NO_VALUE
+          Helpers.make_compare_function self, :>, value
+        end
+
+        def gte value = NO_VALUE
+          Helpers.make_compare_function self, :>=, value
+        end
+
+      end
+
+
+      module Helpers
+
+        def self.make_compare_function method_name, operator, value
+          if value.equal? NO_VALUE
+            -> thing, other { thing.__send__(method_name).__send__(operator, other.__send__(method_name)) }
+          else
+            -> thing        { thing.__send__(method_name).__send__(operator, value) }
+          end
+        end
+
+      end
+
+      NO_VALUE = BasicObject.new
+
+      private_constant :NO_VALUE, :Helpers
+    end
+  end
+end

data/lib/augmented/symbols.rb

@@ -0,0 +1,9 @@
+require 'augmented/symbols/arguable'
+require 'augmented/symbols/comparing'
+
+module Augmented
+  module Symbols
+    include Arguable
+    include Comparing
+  end
+end

data/lib/augmented/version.rb

@@ -0,0 +1,3 @@
+module Augmented
+  VERSION = "0.0.1"
+end

data/lib/augmented.rb

@@ -0,0 +1,15 @@
+require 'augmented/version'
+
+require 'augmented/enumerators'
+require 'augmented/hashes'
+require 'augmented/objects'
+require 'augmented/procs'
+require 'augmented/symbols'
+
+module Augmented
+  include Enumerators
+  include Hashes
+  include Objects
+  include Procs
+  include Symbols
+end

data/test/augmented/enumerators/indexing_test.rb

@@ -0,0 +1,15 @@
+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
+      ['a', 'bbb', 'c', 'dd'].to_enum.index_by(&:length).must_equal({ 1 => 'c', 2 => 'dd', 3 => 'bbb' })
+    end
+
+  end
+
+end

data/test/augmented/hashes/polymorphable_test.rb

@@ -0,0 +1,45 @@
+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
+
+      object.must_be_instance_of OpenStruct
+      object.speak.must_equal '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
+      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
+      end
+
+      it 'can be a class' do
+        { type: OpenStruct }.polymorph().must_be_instance_of OpenStruct
+      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
+      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
+    end
+
+  end
+
+end

data/test/augmented/hashes/transformable_test.rb

@@ -0,0 +1,87 @@
+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
+
+      new_hash[:thing1].must_equal 300
+      new_hash[:thing2].must_equal 900
+
+
+      # mutable version test:
+      hash = { thing1: 100, thing2: OpenStruct.new(random_method_name: 900) }
+
+      hash.transform! thing1: -> i { i * 3 }, thing2: :random_method_name
+
+      hash[:thing1].must_equal 300
+      hash[:thing2].must_equal 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 } } } })
+
+      new_hash[:a][:b][:c].must_equal 300
+
+
+      # mutable version test:
+      hash = { a: { b: { c: 100 } } }
+
+      hash.transform!({ a: { b: { c: -> i { i * 3 } } } })
+
+      hash[:a][:b][:c].must_equal 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 } })
+
+      new_hash[:a].must_equal [ { 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 } })
+
+      hash[:a].must_equal [ { 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 ]
+
+      new_hash[:a].must_equal 24
+
+
+      # mutable version test:
+      hash = { a: 2.5 }
+
+      hash.transform! a: [ :to_i, add_ten, double ]
+
+      hash[:a].must_equal 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
+    end
+
+  end
+end

data/test/augmented/objects/pickable_test.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+require 'augmented/objects/pickable'
+require 'ostruct'
+
+describe Augmented::Objects::Pickable do
+  using Augmented::Objects::Pickable
+
+  describe '#pick' do
+
+    it 'returns an 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

@@ -0,0 +1,25 @@
+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/thru_test.rb

@@ -0,0 +1,22 @@
+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
+
+end

data/test/augmented/procs/chainable_test.rb

@@ -0,0 +1,22 @@
+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/symbols/arguable_test.rb

@@ -0,0 +1,51 @@
+require 'minitest/autorun'
+require 'augmented/symbols/arguable'
+
+describe Augmented::Symbols::Arguable do
+  using Augmented::Symbols::Arguable
+
+  describe '#with' do
+
+    before do
+      @eleven = Class.new do
+        def add other_number
+          11 + other_number
+        end
+
+        def add_many one_number, another_number, *many_numbers
+          11 + one_number + another_number + many_numbers.reduce(0, :+)
+        end
+
+        def do_whatever
+          yield 11
+        end
+      end.new
+    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
+    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
+
+        :add_many.with(10, 20).call(@eleven, 4, 5).must_equal 50
+      end
+
+      it 'passes along the block supplied to `with`, if any' do
+        result = nil
+        set_result = -> i { result = i }
+
+        :do_whatever.with(&set_result).call(@eleven)
+
+        result.must_equal 11
+      end
+
+    end
+
+  end
+end

data/test/augmented/symbols/comparing_test.rb

@@ -0,0 +1,131 @@
+require 'minitest/autorun'
+require 'augmented/symbols/comparing'
+
+describe Augmented::Symbols::Comparing do
+  using Augmented::Symbols::Comparing
+
+  let(:dummy) { Struct.new :lorem_ipsum }
+
+  let(:thing_A) { dummy.new 123 }
+  let(:thing_B) { dummy.new 123 }
+  let(:thing_C) { dummy.new 987 }
+  let(:thing_D) { dummy.new 0 }
+
+  describe '#eq' 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
+    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
+    end
+
+  end
+
+  describe '#neq' 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
+    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
+    end
+
+  end
+
+  describe '#lt' 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
+    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
+    end
+
+  end
+
+  describe '#lte' 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
+    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
+    end
+
+  end
+
+  describe '#gt' 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
+    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
+    end
+
+  end
+
+  describe '#gte' 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
+    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
+    end
+
+  end
+
+
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: augmented
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- bruno
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Adds a few useful extra methods to some of Ruby's core types, available
+  as refinements.
+email:
+- bruno@brunze.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- augmented.gemspec
+- lib/augmented.rb
+- lib/augmented/enumerators.rb
+- lib/augmented/enumerators/indexing.rb
+- lib/augmented/hashes.rb
+- lib/augmented/hashes/polymorphable.rb
+- lib/augmented/hashes/transformable.rb
+- lib/augmented/objects.rb
+- lib/augmented/objects/pickable.rb
+- lib/augmented/objects/tackable.rb
+- lib/augmented/objects/thru.rb
+- lib/augmented/procs.rb
+- lib/augmented/procs/chainable.rb
+- lib/augmented/symbols.rb
+- lib/augmented/symbols/arguable.rb
+- lib/augmented/symbols/comparing.rb
+- lib/augmented/version.rb
+- test/augmented/enumerators/indexing_test.rb
+- test/augmented/hashes/polymorphable_test.rb
+- test/augmented/hashes/transformable_test.rb
+- test/augmented/objects/pickable_test.rb
+- test/augmented/objects/tackable_test.rb
+- test/augmented/objects/thru_test.rb
+- test/augmented/procs/chainable_test.rb
+- test/augmented/symbols/arguable_test.rb
+- test/augmented/symbols/comparing_test.rb
+homepage: https://github.com/brunze/augmented
+licenses:
+- MIT
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Useful extra methods for some Ruby core types.
+test_files:
+- test/augmented/enumerators/indexing_test.rb
+- test/augmented/hashes/polymorphable_test.rb
+- test/augmented/hashes/transformable_test.rb
+- test/augmented/objects/pickable_test.rb
+- test/augmented/objects/tackable_test.rb
+- test/augmented/objects/thru_test.rb
+- test/augmented/procs/chainable_test.rb
+- test/augmented/symbols/arguable_test.rb
+- test/augmented/symbols/comparing_test.rb