beethoven 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bdf26fc9c7904a96681b438f0ea47a2061eea493
-  data.tar.gz: 3f5d73b121875564e705d8685c0cbad45db42cd8
+  metadata.gz: 0b404645ae1a53a0ff6b39a80c7628d17e2cfc10
+  data.tar.gz: 0eae1de8f57ed18707aa2507422ec422ac3df331
 SHA512:
-  metadata.gz: f5b044385e4b14c01511ee53286ff51839c5a949e10b04e090dafd6dfc7702bf14f2b5b1ac5573ed8bcc58f0a1755aef5d27dcc1a4e5ee7f4f9b8a940570e770
-  data.tar.gz: 88b3693bf215390c9b9c74524e5d6b93eaa74a4b67fa9a0809b3dfd36bb45af746ebdd09e0b53cf995125043b3b936011a514583574e3452dbe9f89b152bd75d
+  metadata.gz: 12ba5bc073e97d842233c4087fd5aacab2aca0fdde2b0d588542c9383b66986c17f12d0a40cfe3019377d7c21490b28fd7975039a31dcc6ff8acd37a3e40bf84
+  data.tar.gz: 7bc74794bd6857daf9a1e04985ad35ae11979ff3988d2567f6fb1ff0df08ced87d163b479c80edc53f1bb8f4a9924d266b29226ec60485d30914dee29a8a9fab

data/Guardfile

@@ -24,8 +24,8 @@
 #  * zeus: 'zeus rspec' (requires the server to be started separately)
 #  * 'just' rspec: 'rspec'
 
-guard :rspec, cmd: "bundle exec rspec" do
-  require "guard/rspec/dsl"
+guard :rspec, cmd: 'bundle exec rspec' do
+  require 'guard/rspec/dsl'
   dsl = Guard::RSpec::Dsl.new(self)
 
   # Feel free to open issues for suggestions and improvements
@@ -47,9 +47,9 @@ guard :rspec, cmd: "bundle exec rspec" do
 
   watch(rails.controllers) do |m|
     [
-      rspec.spec.("routing/#{m[1]}_routing"),
-      rspec.spec.("controllers/#{m[1]}_controller"),
-      rspec.spec.("acceptance/#{m[1]}")
+      rspec.spec.call("routing/#{m[1]}_routing"),
+      rspec.spec.call("controllers/#{m[1]}_controller"),
+      rspec.spec.call("acceptance/#{m[1]}")
     ]
   end
 
@@ -59,12 +59,12 @@ guard :rspec, cmd: "bundle exec rspec" do
   watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
 
   # Capybara features specs
-  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
-  watch(rails.layouts)       { |m| rspec.spec.("features/#{m[1]}") }
+  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
 
   # Turnip features and steps
   watch(%r{^spec/acceptance/(.+)\.feature$})
   watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
-    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+    Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance'
   end
 end

data/Rakefile

@@ -1,2 +1 @@
-require "bundler/gem_tasks"
-
+require 'bundler/gem_tasks'

data/beethoven.gemspec

@@ -4,26 +4,26 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'beethoven/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "beethoven"
+  spec.name          = 'beethoven'
   spec.version       = Beethoven::VERSION
-  spec.authors       = ["Matt Parsons"]
-  spec.email         = ["parsonsmatt@gmail.com"]
-  spec.summary       = %q{Make it a bit easier to compose classes in Ruby}
+  spec.authors       = ['Matt Parsons']
+  spec.email         = ['parsonsmatt@gmail.com']
+  spec.summary       = 'Make it a bit easier to compose classes in Ruby'
   spec.description   = <<-EOF
 Functional programming is gaining more and more mindshare in software lately. One of the main benefits of programming in the functional style is function composition. Function composition allows you to break your program into small manageable chunks that can be put together in new and interesting ways.
 
 Object Oriented Programming is supposed to be composable, but the composition is lacking compared to FP. Perhaps Ruby's flexibility can get us part of the way there?
   EOF
-  spec.homepage      = "https://www.github.com/parsonsmatt/beethoven"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://www.github.com/parsonsmatt/beethoven'
+  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.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'guard', '~> 2.12'
   spec.add_development_dependency 'rspec', '~> 3.3'
   spec.add_development_dependency 'guard-rspec', '~> 4.5'

data/lib/beethoven.rb

@@ -1,6 +1,26 @@
-require "beethoven/version"
-require "beethoven/composer"
-require "beethoven/class"
+require 'beethoven/version'
+require 'beethoven/composer'
 
+# The Beethoven module can be used in order to provide convenience operators for
+# the Beethoven::Composer class.
 module Beethoven
+  refine Object do
+    def *(other)
+      Beethoven::Composer.new(other, self)
+    end
+
+    def |(other)
+      Beethoven::Composer.new(self, other)
+    end
+  end
+
+  refine Proc do
+    def *(other)
+      -> x { call(other.call(x)) }
+    end
+
+    def |(other)
+      -> x { other.call(call(x)) }
+    end
+  end
 end

data/lib/beethoven/composer.rb

@@ -1,19 +1,20 @@
 module Beethoven
+  # Composer composes class instantiation. The first call to new refers to the
+  # `initialize` method, and creates an object which duck-types Class.new. When
+  # `Composer#new` is called, the classes are instantiated in order, where the
+  # argument passed to the first class is the argument passed to Composer#new,
+  # and each subsequent class receives the instantiated object as its argument.
   class Composer
     def initialize(*fs)
-      @fs = fs
+      @fs = if fs.size == 1 && fs[0].is_a?(Array)
+              fs[0]
+            else
+              fs
+            end
     end
 
     def new(x)
       @fs.reduce(x) { |a, e| e.new(a) }
     end
-
-    def *(other)
-      self.class.new(other, self)
-    end
-
-    def |(other)
-      self.class.new(self, other)
-    end
   end
 end

data/lib/beethoven/{class.rb → object.rb}

@@ -1,4 +1,6 @@
-class Class
+# Require `beethoven/object` to monkey patch Object with the class composition
+# operators.
+class Object
   def *(other)
     Beethoven::Composer.new(other, self)
   end

data/lib/beethoven/proc.rb

@@ -0,0 +1,10 @@
+# Require `beethoven/proc` to monkey patch Proc with these composition helpers.
+class Proc
+  def *(other)
+    -> x { call(other.call(x)) }
+  end
+
+  def |(other)
+    -> x { other.call(call(x)) }
+  end
+end

data/lib/beethoven/version.rb

@@ -1,3 +1,4 @@
+# Version
 module Beethoven
-  VERSION = "0.0.2"
+  VERSION = '0.1.0'
 end

data/spec/beethoven/composer_spec.rb

@@ -1,4 +1,42 @@
 require 'beethoven/composer'
 
 RSpec.describe Beethoven::Composer do
+  # F :: () -> a
+  class F
+    attr_reader :a
+
+    def initialize(o)
+      @a = o
+    end
+  end
+
+  # G :: a -> b
+  class G
+    attr_reader :b
+
+    def initialize(o)
+      @b = o.a
+    end
+  end
+
+  # H :: b -> c
+  class H
+    attr_reader :c
+
+    def initialize(o)
+      @c = o.b
+    end
+  end
+
+  subject { Beethoven::Composer }
+
+  describe 'composes classes' do
+    it 'transfers the value' do
+      expect(subject.new(F, G, H).new(5).c).to eq(5)
+    end
+
+    it 'can take array of classes' do
+      expect(subject.new([F, G, H]).new(5).c).to eq(5)
+    end
+  end
 end

data/spec/beethoven_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'beethoven'
 
 RSpec.describe Beethoven do
+  using Beethoven
+
   describe 'class composition' do
     # F's initialize takes an object with interface a and returns an object with
     # interface b. Can be thought of as:
@@ -15,7 +17,7 @@ RSpec.describe Beethoven do
 
     # G's initialize takes an object and gives it the interface a. Can be
     # expressed like:
-    # G :: _ -> a
+    # G :: () -> a
     class G
       attr_reader :a
 
@@ -36,22 +38,35 @@ RSpec.describe Beethoven do
 
     describe 'with *' do
       it 'composes classes like math functions' do
-        expect( (F * G).new(5).b ).to eq( F.new(G.new(5)).b )
+        expect((F * G).new(5).b).to eq(F.new(G.new(5)).b)
       end
 
       it 'can be chained' do
-        expect( (F * H * G).new(5).b ).to eq( F.new(H.new(G.new(5))).b )
+        expect((F * H * G).new(5).b).to eq(F.new(H.new(G.new(5))).b)
       end
     end
 
     describe 'with |' do
       it 'composes classes like pipes' do
-        expect( (G | F).new(5).b ).to eq( F.new(G.new(5)).b )
+        expect((G | F).new(5).b).to eq(F.new(G.new(5)).b)
       end
 
       it 'can be chained' do
-        expect( (G | H | F).new(5).b ).to eq( F.new(H.new(G.new(5))).b )
+        expect((G | H | F).new(5).b).to eq(F.new(H.new(G.new(5))).b)
       end
     end
   end
+
+  describe 'proc composition' do
+    let(:f) { -> x { x + 1 } }
+    let(:g) { -> x { x * 2 } }
+
+    it 'allows lambdas to be composed' do
+      expect((f * g)[3]).to eq(7)
+    end
+
+    it 'supports pipeline' do
+      expect((f | g)[3]).to eq(8)
+    end
+  end
 end

data/spec/examples.txt

@@ -1,6 +1,10 @@
-example_id                        | status | run_time        |
---------------------------------- | ------ | --------------- |
-./spec/beethoven_spec.rb[1:1:1:1] | passed | 0.00009 seconds |
-./spec/beethoven_spec.rb[1:1:1:2] | passed | 0.00006 seconds |
-./spec/beethoven_spec.rb[1:1:2:1] | passed | 0.00006 seconds |
-./spec/beethoven_spec.rb[1:1:2:2] | passed | 0.00029 seconds |
+example_id                               | status | run_time        |
+---------------------------------------- | ------ | --------------- |
+./spec/beethoven/composer_spec.rb[1:1:1] | passed | 0.0001 seconds  |
+./spec/beethoven/composer_spec.rb[1:1:2] | passed | 0.00055 seconds |
+./spec/beethoven_spec.rb[1:1:1:1]        | passed | 0.00008 seconds |
+./spec/beethoven_spec.rb[1:1:1:2]        | passed | 0.00009 seconds |
+./spec/beethoven_spec.rb[1:1:2:1]        | passed | 0.00007 seconds |
+./spec/beethoven_spec.rb[1:1:2:2]        | passed | 0.0001 seconds  |
+./spec/beethoven_spec.rb[1:2:1]          | passed | 0.00039 seconds |
+./spec/beethoven_spec.rb[1:2:2]          | passed | 0.00014 seconds |

data/spec/spec_helper.rb

@@ -50,7 +50,7 @@ RSpec.configure do |config|
   # Allows RSpec to persist some state between runs in order to support
   # the `--only-failures` and `--next-failure` CLI options. We recommend
   # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = "spec/examples.txt"
+  config.example_status_persistence_file_path = 'spec/examples.txt'
 
   # Limits the available syntax to the non-monkey patched syntax that is
   # recommended. For more details, see:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beethoven
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Matt Parsons
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-30 00:00:00.000000000 Z
+date: 2015-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -115,9 +115,9 @@ files:
 - Rakefile
 - beethoven.gemspec
 - lib/beethoven.rb
-- lib/beethoven/class.rb
-- lib/beethoven/composable.rb
 - lib/beethoven/composer.rb
+- lib/beethoven/object.rb
+- lib/beethoven/proc.rb
 - lib/beethoven/version.rb
 - spec/beethoven/composer_spec.rb
 - spec/beethoven_spec.rb

data/lib/beethoven/composable.rb

@@ -1,11 +0,0 @@
-module Beethoven
-  module Composable
-    def *(other)
-      new(other, self)
-    end
-
-    def |(other)
-      new(self, other)
-    end
-  end
-end