deterministic 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ef26aa56b5cda71158ead5307f6073ea135da19
-  data.tar.gz: 6c636a3b653ab6ca860bfebfd647c4c033e39747
+  metadata.gz: 02fd1f0c22527cf4af1af78fdb8e868d4947fb3b
+  data.tar.gz: 0efb14c1c44f3d487e551765a1fb671b8e9b55c7
 SHA512:
-  metadata.gz: 52f36a2df48c9e9deb4a1ab593eed996a17a8e8a59e3d4eef65a43de59346e6587655c1cf8a1219c23fc7a7de7498af76b2becfb511bf696f724b7f0debbbb17
-  data.tar.gz: 267ef98b4a0f22ead89a91438a777d74c27aa188495245e2e5a143790948c265f2de7caaed5e3c901e64281a42d20d4a1aa792c4cdc65ba17390b35f331b0d8b
+  metadata.gz: cb9ab93ae058be25b8f724d4c246138ce6f576cf59f6bcf8e6927a97fbbd67f42fff1a527f7bcf791d858fd03d1108a8f756457a3bb0b345c82b5aa83c5ef7d2
+  data.tar.gz: a40bc7baf45c6785b0204faca45f9e5c3a4eb4f33e0baae1c647da5591bc464051bb58f8b109c09518c6aad80ae1f112d5a7659ea0df1d721db3d3ae38d55e86

data/Guardfile

@@ -1,9 +1,13 @@
+guard :bundler do
+  watch('Gemfile')
+end
+
 guard :bundler do
   watch('Gemfile')
   watch(/^.+\.gemspec/)
 end
 
-guard :rspec do
+guard :rspec, cmd: 'bundle exec rspec' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
@@ -12,4 +16,3 @@ guard :rspec do
   watch(%r{^spec/acceptance/(.+)\.feature$})
   watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
 end
-

data/README.md

@@ -47,10 +47,70 @@ Failure(1).or_else { |v| Success(v)} # => Success(1)
 
 The value or block result must always be a `Success` or `Failure`
 
+### Either.chain
+You can easily chain the execution of several operations. Here we got some nice function composition.  
+The method must be a unary function, i.e. it always takes one parameter - the context, which is passed from call to call.
 
+```ruby
+class Foo
+  include Deterministic
+  alias :m :method
+
+  def call
+    setup >> m(:validate) >> m(:send)
+  end
+
+  def setup
+    Success(1)
+  end
+
+  def validate(ctx)
+    # do stuff
+    Success(ctx + 1)
+  end
+
+  def send(ctx)
+    # do stuff
+    Success(ctx + 1)
+  end
+end
+
+Foo.new.call # Success(3)
+```
+
+Chaining works with blocks (`#chain` is an alias for `#>>`)
+
+```ruby
+Success(1).chain {|ctx| Success(ctx + 1)}
+```
+
+it also works with lambdas
+```ruby
+Success(1) >> ->(ctx) { Success(ctx + 1) } >> ->(ctx) { Success(ctx + 1) }
+```
+
+and it will break the chain of execution, when it encounters a `Failure` on its way
+
+```ruby
+def works(ctx)
+  Success(1)
+end
+
+def breaks(ctx)
+  Failure(2)
+end
+
+def never_executed(ctx)
+  Success(99)
+end
+
+Success(0) >> method(:works) >> method(:breaks) >> method(:never_executed) # Failure(2)
+```
 
 ### Either.attempt_all
 The basic idea is to execute a chain of units of work and make sure all return either `Success` or `Failure`.
+This remains for compatibility reasons, personally I would use the `>>` chaining.
+
 
 ```ruby
 Either.attempt_all do

data/lib/deterministic/either/chain.rb

@@ -0,0 +1,13 @@
+module Deterministic
+  class Either
+    module Chain
+      def chain(proc=nil, &block)
+        return self if failure?
+        bind { (proc || block).call(@value) }
+      end
+
+      alias :>> :chain
+      end
+  end
+end
+

data/lib/deterministic/either.rb

@@ -3,6 +3,7 @@ module Deterministic
   class Either
     include Monad
     include Deterministic::PatternMatching
+    include Chain
 
     def bind(proc=nil, &block)
       (proc || block).call(value, self.class).tap do |result|
@@ -28,11 +29,6 @@ module Deterministic
       protected :new
     end
 
-    def to_json(*args)
-      name = self.class.name.split('::')[-1]
-      "{\"#{name}\":#{value.to_json(*args)}}"
-    end
-
     def to_s
       value.to_s
     end

data/lib/deterministic/version.rb

@@ -1,3 +1,3 @@
 module Deterministic
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/lib/deterministic.rb

@@ -6,6 +6,7 @@ module Deterministic; end
 
 require 'deterministic/monad'
 require 'deterministic/either/match'
+require 'deterministic/either/chain'
 require 'deterministic/either'
 require 'deterministic/either/attempt_all'
 require 'deterministic/either/success'

data/spec/lib/deterministic/either/chain_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+include Deterministic
+
+describe Deterministic::Either do
+  context ">>" do
+    it "Failure stops execution" do
+      class ChainUnderTest
+        alias :m :method
+
+        def call
+          init >> m(:validate) >> m(:send) >> m(:parse)
+        end
+
+        def init
+          Success({step: 1})
+        end
+
+        def validate(i)
+          i[:step] = i[:step] + 1
+          Success(i)
+        end
+
+        def send(i)
+          i[:step] = i[:step] + 1
+          Failure("Error @ #{i.fetch(:step)}")
+        end
+
+        def parse(i)
+          i[:step] = i[:step] + 1
+          Success(i)
+        end
+      end
+
+      test = ChainUnderTest.new
+
+      expect(test.call).to eq Failure("Error @ 3")
+    end
+
+    it "expects an Either" do
+      def returns_non_either(i)
+        2
+      end
+
+      expect { Success(1) >> method(:returns_non_either) }.to raise_error(Deterministic::Monad::NotMonadError)
+    end
+
+    it "works with a block" do
+      expect(
+        Success(1).chain { |i| Success(i + 1) }
+      ).to eq Success(2)
+    end
+
+    it "works with a lambda" do
+      expect(
+        Success(1) >> ->(i) { Success(i + 1) }
+      ).to eq Success(2)
+    end
+  end
+end

data/spec/lib/deterministic/either/either_shared.rb

@@ -11,10 +11,6 @@ shared_examples 'Either' do
     expect(either.new(1).bind { |v| either.new(v + 1)}).to eq either.new(2)
   end
 
-  it "#to_json" do
-    expect(either.new({a: 1}).to_json).to eq "{\"#{either_name}\":{\"a\":1}}"
-  end
-
   it "#to_s" do
     expect(either.new(1).to_s).to eq "1"
     expect(either.new({a: 1}).to_s).to eq "{:a=>1}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deterministic
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Piotr Zolnierek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-14 00:00:00.000000000 Z
+date: 2014-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -129,6 +129,7 @@ files:
 - lib/deterministic/core_ext/object/either.rb
 - lib/deterministic/either.rb
 - lib/deterministic/either/attempt_all.rb
+- lib/deterministic/either/chain.rb
 - lib/deterministic/either/failure.rb
 - lib/deterministic/either/match.rb
 - lib/deterministic/either/success.rb
@@ -141,6 +142,7 @@ files:
 - spec/lib/deterministic/attempt_all_spec.rb
 - spec/lib/deterministic/core_ext/either_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
+- spec/lib/deterministic/either/chain_spec.rb
 - spec/lib/deterministic/either/either_shared.rb
 - spec/lib/deterministic/either/failure_spec.rb
 - spec/lib/deterministic/either/match_spec.rb
@@ -181,6 +183,7 @@ test_files:
 - spec/lib/deterministic/attempt_all_spec.rb
 - spec/lib/deterministic/core_ext/either_spec.rb
 - spec/lib/deterministic/core_ext/object/either_spec.rb
+- spec/lib/deterministic/either/chain_spec.rb
 - spec/lib/deterministic/either/either_shared.rb
 - spec/lib/deterministic/either/failure_spec.rb
 - spec/lib/deterministic/either/match_spec.rb