comp 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c927bf75c65fbbeefc7e80590410d970d096b9c
+  data.tar.gz: ba154301fd04d8b571b896adbd54ea558426085d
+SHA512:
+  metadata.gz: 96523e9652f384276d8e25291f09c0fcbcaf8b25d7b5dc46f6502d3d5a00be4587c1f58eb3f173932ab4810461726f06efcf030c5da1e36207bd270889aea182
+  data.tar.gz: bce2078f4a9f14a3f14af05309b513100df143918dc40b28d19040546db4b60748d43a593f8c865882acdec83b9a5e58da4dbe6e013411ca91f3a8e4e50f26f9

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Paul Mucur
+
+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,99 @@
+# comp [![Build Status](https://travis-ci.org/mudge/comp.svg?branch=master)](https://travis-ci.org/mudge/comp)
+
+A Ruby library to add [function
+composition](https://en.wikipedia.org/wiki/Function_composition) to
+[`Proc`s](http://ruby-doc.org/core/Proc.html) (including `lambda`s) and
+[`Method`s](http://ruby-doc.org/core/Method.html).
+
+**Current version:** 1.0.0  
+**Supported Ruby versions:** 1.9.2, 1.9.3, 2.0, 2.1, 2.2
+
+## Installation
+
+```
+gem install comp -v '~> 1.0'
+```
+
+Or, in your `Gemfile`:
+
+```ruby
+gem 'comp', '~> 1.0'
+```
+
+## Usage
+
+```ruby
+require 'comp'
+
+# Basic usage
+add = proc { |x, y| x + y }
+double = proc { |x| x * 2 }
+double_after_add = double * add
+
+double_after_add.call(1, 2)
+#=> 6
+
+# Composing Procs and other callables
+class Parser
+  def call(json)
+    JSON.load(json)
+  end
+end
+
+extract_name = proc { |attributes| attributes.fetch('name') }
+(extract_name * Parser.new).call('{"name": "Alice"}')
+#=> "Alice"
+```
+
+Requiring `comp` will require two files:
+
+* `comp/proc`: add [`Proc#*`](#proc) if it hasn't already been defined;
+* `comp/method`: add [`Method#*`](#method) if it hasn't already been defined.
+
+## API Documentation
+
+### `Proc#*`
+
+```ruby
+increment_and_add = proc { |x| x * 2 } * proc { |x| x + 1 }
+increment_and_add.call(1)
+#=> 4
+```
+
+Composes a `Proc` (`f`) with any object that responds to `call` (`g`) returning
+a new `Proc` which will call `g` with any given arguments (including blocks)
+and then call `f` with the result.
+
+If `f` was created with `lambda`, the resulting `Proc` will also be a
+`lambda`.
+
+### `Method#*`
+
+```ruby
+class Number
+  def add(x, y)
+    x + y
+  end
+
+  def double(x)
+    x * 2
+  end
+end
+
+(number.new.method(:double) * number.new.method(:add)).call(2, 3)
+#=> 10
+```
+
+Composes a `Method` (`f`) with any object that responds to `call` (`g`)
+returning a new `Proc` which will call `g` with any given arguments (including
+blocks) and then call `f` with the result.
+
+## Why isn't this in Ruby itself?
+
+Good question: I'd like to [change](https://bugs.ruby-lang.org/issues/6284) [that](https://github.com/ruby/ruby/pull/935).
+
+## License
+
+Copyright © 2015 Paul Mucur.
+
+Distributed under the MIT License.

data/lib/comp.rb

@@ -0,0 +1,2 @@
+require 'comp/proc'
+require 'comp/method'

data/lib/comp/method.rb

@@ -0,0 +1,9 @@
+require 'comp/proc'
+
+class Method
+  unless method_defined?(:*)
+    def *(g)
+      to_proc * g
+    end
+  end
+end

data/lib/comp/proc.rb

@@ -0,0 +1,11 @@
+class Proc
+  unless method_defined?(:*)
+    def *(g)
+      if lambda?
+        lambda { |*args, &blk| call(g.call(*args, &blk)) }
+      else
+        proc { |*args, &blk| call(g.call(*args, &blk)) }
+      end
+    end
+  end
+end

data/spec/comp/method_spec.rb

@@ -0,0 +1,74 @@
+require 'comp/method'
+
+RSpec.describe Method do
+  describe '#*' do
+    it 'composes two Methods together' do
+      number = Class.new do
+        def increment(x)
+          x + 1
+        end
+
+        def double(x)
+          x * 2
+        end
+      end
+      increment = number.new.method(:increment)
+      double = number.new.method(:double)
+      increment_and_double = double * increment
+
+      expect(increment_and_double.call(1)).to eq(4)
+    end
+
+    it 'passes multiple arguments to g' do
+      number = Class.new do
+        def add(x, y)
+          x + y
+        end
+
+        def double(x)
+          x * 2
+        end
+      end
+      add = number.new.method(:add)
+      double = number.new.method(:double)
+      add_and_double = double * add
+
+      expect(add_and_double.call(1, 2)).to eq(6)
+    end
+
+    it 'passes blocks to g' do
+      number = Class.new do
+        def add(x, &blk)
+          x + blk.call
+        end
+
+        def double(x)
+          x * 2
+        end
+      end
+      add = number.new.method(:add)
+      double = number.new.method(:double)
+      add_and_double = double * add
+
+      expect(add_and_double.call(1) { 3 }).to eq(8)
+    end
+
+    it 'composes anything that responds to call' do
+      number = Class.new do
+        def triple(x)
+          x * 3
+        end
+      end
+      incrementer = Class.new do
+        def call(x)
+          x + 1
+        end
+      end
+
+      triple = number.new.method(:triple)
+      increment_and_triple = triple * incrementer.new
+
+      expect(increment_and_triple.call(1)).to eq(6)
+    end
+  end
+end

data/spec/comp/proc_spec.rb

@@ -0,0 +1,49 @@
+require 'comp/proc'
+
+RSpec.describe Proc do
+  describe '#*' do
+    it 'composes two Procs together' do
+      increment = proc { |x| x + 1 }
+      double = proc { |x| x * 2 }
+      increment_and_double = double * increment
+
+      expect(increment_and_double.call(1)).to eq(4)
+    end
+
+    it 'passes multiple arguments to g' do
+      add = proc { |x, y| x + y }
+      double = proc { |x| x * 2 }
+      add_and_double = double * add
+
+      expect(add_and_double.call(1, 2)).to eq(6)
+    end
+
+    it 'passes blocks to g' do
+      add = proc { |x, &blk| x + blk.call }
+      double = proc { |x| x * 2 }
+      add_and_double = double * add
+
+      expect(add_and_double.call(1) { 3 }).to eq(8)
+    end
+
+    it 'returns a lambda if f is a lambda' do
+      increment = proc { |x| x + 1 }
+      double = lambda { |x| x * 2 }
+
+      expect(double * increment).to be_lambda
+    end
+
+    it 'composes anything that responds to call' do
+      incrementer = Class.new do
+        def call(x)
+          x + 1
+        end
+      end
+
+      triple = lambda { |x| x * 3 }
+      increment_and_triple = triple * incrementer.new
+
+      expect(increment_and_triple.call(1)).to eq(6)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.disable_monkey_patching!
+  config.warnings = true
+  config.profile_examples = 10
+  config.order = :random
+  Kernel.srand config.seed
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: comp
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Paul Mucur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: |2
+      A library to add functional composition between Procs and Methods in Ruby.
+email: mudge@mudge.name
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/comp.rb
+- lib/comp/method.rb
+- lib/comp/proc.rb
+- spec/comp/method_spec.rb
+- spec/comp/proc_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mudge/comp
+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: Functional composition with Procs and Methods in Ruby
+test_files:
+- spec/comp/method_spec.rb
+- spec/comp/proc_spec.rb
+- spec/spec_helper.rb