waterfall 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2918f5c657d78ab72747847b48ca6024995b8cdc
-  data.tar.gz: 473b2b1b9cf9512fb13520523cbf4ae358a005b2
+  metadata.gz: 152fb9437b8752b16fd77478ec2e12c0d9b6401f
+  data.tar.gz: 5e6f25d4bd7c0e23c4a8cd16b921227ed5397a3a
 SHA512:
-  metadata.gz: 5ddce902522214cdb5e5cdf939d18a8a1dca0026dd79de3c29ac30c17f3bd7bc6c2abd06c21f8dc67398d3dbf617c3032a67136dd792ffe37b786138a2e1e57f
-  data.tar.gz: 1d17dee11a63dc85b223e3e70e94bd1b35e09df45ff926d2f3a2da8d6ea2eca07d7c56e4124124aa6b97af651e7ab7fdba0d043baa898ed4fcea365cee1ac0e1
+  metadata.gz: 597154dc366df15c6fe84f707c1206e82c624c77b57b818323e67347fd1d3e3f9f990b926d5c389060e2b75c1de71aa807ab7601b9735584cb8c138d40b26c6b
+  data.tar.gz: 8004a1da08994b9e668113e348d5312503394d071be2f366fda20dda1650d7648aa19ecb1555a46beab22d6866bd23f1a9bdb10b29184b39bcafc79aad537aa7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    waterfall (1.0.4)
+    waterfall (1.0.5)
 
 GEM
   remote: https://rubygems.org/

data/lib/waterfall.rb

@@ -8,21 +8,21 @@ require 'waterfall/predicates/chain'
 
 module Waterfall
 
-  attr_reader :error_pool, :outflow, :flowing, :_wf_rolled_back
+  attr_reader :error_pool, :outflow
 
   class IncorrectDamArgumentError      < StandardError; end
   class IncorrectChainingArgumentError < StandardError; end
 
   def when_falsy(&block)
-    handler = ::Waterfall::WhenFalsy.new(self)
-    _wf_run { handler.call(&block) }
-    handler
+    ::Waterfall::WhenFalsy.new(self).tap do |handler|
+      _wf_run { handler.call(&block) }
+    end
   end
 
   def when_truthy(&block)
-    handler = ::Waterfall::WhenTruthy.new(self)
-    _wf_run { handler.call(&block) }
-    handler
+    ::Waterfall::WhenTruthy.new(self).tap do |handler|
+      _wf_run { handler.call(&block) }
+    end
   end
 
   def chain(mapping_or_var_name = nil, &block)
@@ -47,8 +47,7 @@ module Waterfall
 
   def dam(obj)
     raise IncorrectDamArgumentError.new("You cant dam with a falsy object") unless obj
-    @error_pool = obj
-    self
+    _wf_run { @error_pool = obj }
   end
 
   def undam
@@ -64,8 +63,8 @@ module Waterfall
     true
   end
 
-  def flowing?
-    !! @flowing
+  def has_flown?
+    !! @has_flown
   end
 
   def update_outflow(key, value)
@@ -74,17 +73,16 @@ module Waterfall
   end
 
   def _wf_run
-    @flowing = true
+    @has_flown = true
     @outflow ||= OpenStruct.new({})
     yield unless dammed?
     self
   end
-
 end
 
 class Wf
   include Waterfall
   def initialize
-    @outflow = OpenStruct.new({})
+    _wf_run {}
   end
 end

data/lib/waterfall/predicates/chain.rb

@@ -16,9 +16,9 @@ module Waterfall
     end
 
     def map_waterfalls(child_waterfall, mapping)
-      child_waterfall.call unless child_waterfall.flowing?
+      child_waterfall.call unless child_waterfall.has_flown?
 
-      raise IncorrectChainingArgumentError.new(mapping_error_message) unless mapping.is_a?(Hash)
+      raise IncorrectChainingArgumentError.new(MAPPING_ERROR_MESSAGE) unless mapping.is_a?(Hash)
 
       mapping.each do |k, v|
         @root.update_outflow(k, child_waterfall.outflow[v])
@@ -31,8 +31,6 @@ module Waterfall
       self
     end
 
-    def mapping_error_message
-      "When chaining waterfalls, you must pass a mapping hash to pass data from one to the other"
-    end
+    MAPPING_ERROR_MESSAGE = "When chaining waterfalls, you must pass a mapping hash to pass data from one to the other"
   end
 end

data/lib/waterfall/version.rb

@@ -1,3 +1,3 @@
 module Waterfall
-  VERSION = "1.0.4"
+  VERSION = "1.0.5"
 end

data/spec/chaining_services_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe 'Chaining services' do
+
+  let(:service_class) do
+    Class.new do
+      include Waterfall
+      def initialize(options = {})
+        @options = {
+          falsy_check:  true,
+          truthy_check: false
+        }.merge options
+      end
+
+      def call
+        when_falsy { @options[:falsy_check] }
+          .dam { 'errr1' }
+        chain(:foo) { 'foo_value' }
+        when_truthy { @options[:truthy_check] }
+          .dam { 'errr2' }
+        chain(:bar) { 'bar_value' }
+        self
+      end
+    end
+  end
+
+  let(:wf) { Wf.new }
+  let(:listener) { spy 'listener', is_waterfall?: false }
+
+  it 'you dont need to call child waterfalls, just pass the instance' do
+    service = service_class.new
+    expect(service.has_flown?).to be false
+    wf.chain { service }
+    expect(service.has_flown?).to be true
+  end
+
+  context 'child executed without damming' do
+    it 'passes data from one outflow to the other' do
+      wf
+        .chain(local_foo: :foo, local_bar: :bar) { service_class.new }
+        .chain  { listener.success }
+        .on_dam { listener.failure }
+
+      expect(wf.outflow.local_foo).to eq 'foo_value'
+      expect(wf.outflow.local_bar).to eq 'bar_value'
+      expect(wf.dammed?).to be false
+      expect(wf.error_pool).to eq nil
+      expect(listener).to have_received :success
+    end
+
+    it 'passes only required data from one outflow to the other' do
+      wf
+        .chain(local_foo: :foo) { service_class.new }
+        .chain  { listener.success }
+        .on_dam { listener.failure }
+
+      expect(wf.outflow.local_foo).to eq 'foo_value'
+      expect(wf.outflow.local_bar).to eq nil
+      expect(listener).to have_received :success
+    end
+  end
+
+  context 'child dams on when_falsy' do
+    it 'stops on dam yet passes existing data' do
+      wf
+        .chain(local_foo: :foo, local_bar: :bar) { service_class.new(falsy_check: false) }
+        .chain  { listener.success }
+        .on_dam { listener.failure }
+
+      expect(wf.outflow.local_foo).to eq nil
+      expect(wf.outflow.local_bar).to eq nil
+      expect(wf.dammed?).to be true
+      expect(wf.error_pool).to eq 'errr1'
+      expect(listener).to have_received :failure
+    end
+  end
+
+  context 'dammed on when_truthy statement' do
+    it 'stops on dam yet passes existing data' do
+      wf
+        .chain(local_foo: :foo, local_bar: :bar) { service_class.new(truthy_check: true) }
+        .chain  { listener.success }
+        .on_dam { listener.failure }
+
+      expect(wf.outflow.local_foo).to eq 'foo_value'
+      expect(wf.outflow.local_bar).to eq nil
+      expect(wf.dammed?).to be true
+      expect(wf.error_pool).to eq 'errr2'
+      expect(listener).to have_received :failure
+    end
+  end
+end

data/spec/service_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'Service' do
+
+  let(:service_class) do
+    Class.new do
+      include Waterfall
+      attr_reader :error
+
+      def initialize(options)
+        @options = {
+          falsy_check:  true,
+          truthy_check: false
+        }.merge options
+      end
+
+      def call
+        when_falsy { @options[:falsy_check] }
+          .dam { 'errr1' }
+        chain(:foo) { 'foo_value' }
+        when_truthy { @options[:truthy_check] }
+          .dam { 'errr2' }
+        chain(:bar) { 'bar_value' }
+      end
+    end
+  end
+
+  let(:service) { service_class.new(options).tap(&:call) }
+
+  it 'a waterfall doesnt flow until one chain is executed' do
+    expect(service_class.new({}).has_flown?).to be false
+  end
+
+  context 'default options' do
+    let(:options) {{}}
+
+    it 'has flown whenever one chain has been executed' do
+      expect(service.has_flown?).to be true
+    end
+
+    it 'executes without damming' do
+      expect(service.outflow.foo).to eq 'foo_value'
+      expect(service.outflow.bar).to eq 'bar_value'
+      expect(service.dammed?).to be false
+      expect(service.error_pool).to eq nil
+    end
+  end
+
+  context 'dammed on when_falsy statement' do
+    let(:options) {{ falsy_check: false }}
+    it 'stops on dam' do
+      expect(service.outflow.foo).to eq nil
+      expect(service.outflow.bar).to eq nil
+      expect(service.dammed?).to be true
+      expect(service.error_pool).to eq 'errr1'
+    end
+  end
+
+  context 'dammed on when_truthy statement' do
+    let(:options) {{ truthy_check: true }}
+    it 'stops on dam' do
+      expect(service.outflow.foo).to eq 'foo_value'
+      expect(service.outflow.bar).to eq nil
+      expect(service.dammed?).to be true
+      expect(service.error_pool).to eq 'errr2'
+    end
+  end
+
+  let(:service_class2) do
+    Class.new do
+      include Waterfall
+
+      def initialize(listener, options)
+        @to_dam, @listener = options[:to_dam], listener
+      end
+
+      def call
+        dam('error') if @to_dam
+        chain  { @listener.success }
+        on_dam { @listener.failure }
+      end
+    end
+  end
+
+  let(:listener) { spy 'listener', is_waterfall?: false }
+
+  it 'sends success message to listener' do
+    service_class2.new(listener, to_dam: false).call
+
+    expect(listener).to have_received(:success)
+  end
+
+  it 'sends failure message to listener' do
+    service_class2.new(listener, to_dam: true).call
+
+    expect(listener).to have_received(:failure)
+  end
+end

data/spec/wf_object_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Wf do
+  let(:wf) { Wf.new }
+
+  it 'is a waterfall' do
+    expect(wf.is_waterfall?).to be true
+  end
+
+  it 'and a waterfall flows when called' do
+    expect(wf.has_flown?).to be true
+  end
+
+  it 'executes code in chain block' do
+    listener = double 'listener'
+    expect(listener).to receive :success
+
+    wf.chain { listener.success }
+  end
+
+  it 'executes code in chain block and store it in outflow upon request' do
+    wf.chain(:foo) { 1 }
+    expect(wf.outflow.foo).to eq 1
+  end
+
+  it 'chain yields outflow and waterfall itself' do
+    wf.chain do |outflow, waterfall|
+      expect(outflow).to eq wf.outflow
+      expect(waterfall).to eq wf
+    end
+  end
+
+  it 'isnt dammed by default' do
+    expect(wf.dammed?).to be false
+    expect(wf.error_pool).to eq nil
+  end
+
+  it 'is dammed if you dam it!' do
+    wf.dam('error')
+    expect(wf.dammed?).to be true
+    expect(wf.error_pool).to eq 'error'
+  end
+
+  it 'dam raises if falsy argument sent' do
+    expect { wf.dam(nil) }.to raise_error(Waterfall::IncorrectDamArgumentError)
+  end
+
+  it 'can be undammed' do
+    wf.dam('error').undam
+    expect(wf.dammed?).to be false
+    expect(wf.error_pool).to eq nil
+  end
+
+  it 'can be dammed conditionnaly (falsy)' do
+    wf.when_falsy { false }.dam { 'error' }
+    expect(wf.dammed?).to be true
+    expect(wf.error_pool).to eq 'error'
+  end
+
+  it 'can be dammed conditionnaly (truthy)' do
+    wf.when_truthy { true }.dam { 'error' }
+    expect(wf.dammed?).to be true
+    expect(wf.error_pool).to eq 'error'
+  end
+
+  it 'doesnt execute chain blocks once dammed' do
+    expect do
+      wf.when_falsy { false }.dam { 'error' }.chain { raise 'I should not be executed because of damming before me' }
+    end.to_not raise_error
+  end
+
+  it 'doesnt execute on_dam blocks when not dammed' do
+    expect do
+      wf.on_dam { raise 'I should not be executed because of damming before me' }
+    end.to_not raise_error
+  end
+
+  it 'executes on_dam blocks once dammed' do
+    listener = spy 'listener'
+    wf.dam('errr').on_dam { listener.failure }
+
+    expect(listener).to have_received :failure
+  end
+
+  it 'on_dam blocks yield error pool, outflow and waterfall' do
+    wf.dam('errr').on_dam do |error_pool, outflow, waterfall|
+      expect(error_pool).to eq wf.error_pool
+      expect(outflow).to eq wf.outflow
+      expect(waterfall).to eq wf
+    end
+  end
+
+  it 'raises if chain waterfall without hash mapping' do
+    expect { wf.chain(:foo) { Wf.new } }.to raise_error(Waterfall::IncorrectChainingArgumentError, Waterfall::Chain::MAPPING_ERROR_MESSAGE)
+  end
+
+  it 'warns against chain_wf' do
+    expect(wf).to receive :warn
+    wf.chain_wf { Wf.new }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: waterfall
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Benjamin Roth
@@ -104,8 +104,10 @@ files:
 - lib/waterfall/predicates/when_falsy.rb
 - lib/waterfall/predicates/when_truthy.rb
 - lib/waterfall/version.rb
-- spec/integration_spec.rb
+- spec/chaining_services_spec.rb
+- spec/service_spec.rb
 - spec/spec_helper.rb
+- spec/wf_object_spec.rb
 - waterfall.gemspec
 homepage: https://github.com/apneadiving/waterfall
 licenses:
@@ -133,5 +135,7 @@ specification_version: 4
 summary: A slice of functional programming to chain ruby services and blocks. Make
   them flow!
 test_files:
-- spec/integration_spec.rb
+- spec/chaining_services_spec.rb
+- spec/service_spec.rb
 - spec/spec_helper.rb
+- spec/wf_object_spec.rb

data/spec/integration_spec.rb

@@ -1,240 +0,0 @@
-require 'spec_helper'
-
-describe 'Wf' do
-  let(:wf) { Wf.new }
-  let(:error_string) { 'error' }
-
-  describe "chain" do
-
-    it "yields wf outflow" do
-      wf
-        .chain  {|outflow| outflow.bar = 'bar' }
-        .chain  {|outflow| @bar = outflow.bar }
-
-      expect(wf.outflow.bar).to eq 'bar'
-      expect(@bar).to eq 'bar'
-    end
-
-    it "assigns outflow's key the value of the block" do
-      wf
-        .chain(:bar) { 'bar' }
-      expect(wf.outflow.bar).to eq 'bar'
-    end
-
-    context "wf internals" do
-      it "dam from within" do
-        wf
-          .chain  {|outflow, waterfall| waterfall.dam(error_string) }
-
-        expect(wf.dammed?).to be true
-        expect(wf.error_pool).to eq error_string
-      end
-
-      it "expose child waterfall outflow even if dammed (or at least what was computed)" do
-        wf
-          .chain(bar: :bar, baz: :baz) do
-            Wf.new
-              .chain(:bar) { 'bar' }
-              .dam('boom')
-              .chain(:baz) { 'baz' }
-          end
-
-        expect(wf.dammed?).to be true
-        expect(wf.error_pool).to eq 'boom'
-        expect(wf.outflow.bar).to eq 'bar'
-        expect(wf.outflow.baz).to eq nil
-      end
-
-      it "outflow from within" do
-        wf
-          .chain {|outflow, waterfall| waterfall.outflow.foo = 1 }
-
-        expect(wf.outflow.foo).to eq 1
-      end
-    end
-
-    describe "chaining waterfalls" do
-
-      shared_examples "a waterfall chain" do
-        describe 'chain waterfall' do
-          it "takes expected vars only and rename them" do
-            wf
-              .chain(baz: :foo) { waterfall }
-
-            expect(wf.outflow.foo).to be nil
-            expect(wf.outflow.bar).to be nil
-            expect(wf.outflow.baz).to eq waterfall.outflow.foo
-          end
-
-          it 'raises if chain waterfall without hash mapping' do
-            expect { wf.chain(:foo) { waterfall } }.to raise_error(Waterfall::IncorrectChainingArgumentError)
-          end
-        end
-      end
-
-      context "from an instance of a custom waterfall class" do
-        class FakeService
-          include Waterfall
-
-          def call
-            self
-              .chain(:foo) { 1 }
-              .chain(:bar) { 2 }
-          end
-        end
-
-        let(:waterfall) { FakeService.new }
-
-        it_behaves_like "a waterfall chain"
-
-        context "only calls waterfall service if it was never called before" do
-          it "when passed as an instance responding to call" do
-            expect(waterfall).to receive(:call).once.and_call_original
-            wf
-              .chain { waterfall }
-          end
-
-          it "already called" do
-            expect(waterfall).to receive(:call).once.and_call_original
-            wf
-              .chain { waterfall.call }
-          end
-        end
-      end
-
-      context "from a mere wf" do
-        let(:waterfall) do
-          Wf.new
-            .chain(:foo) { 1 }
-            .chain(:bar) { 2 }
-        end
-
-        it_behaves_like "a waterfall chain"
-      end
-    end
-  end
-
-  describe "when falsy" do
-    let(:my_proc) { ->(val){ val } }
-
-    def action(bool)
-      wf
-        .chain { wf.dam('dammed') if dam? }
-        .when_falsy { my_proc.call(bool) }
-          .dam  { error_string }
-        .chain  { @foo = 1 }
-    end
-
-    context "main context not dammed" do
-      let(:dam?) { false }
-
-      it "when actually falsy" do
-        action false
-        expect(wf.error_pool).to eq error_string
-        expect(@foo).to_not eq 1
-      end
-
-      it "when actually truthy" do
-        action true
-        expect(wf.error_pool).to_not eq error_string
-        expect(@foo).to eq 1
-      end
-    end
-
-    context "main context dammed" do
-      let(:dam?) { true }
-
-      it "when actually falsy" do
-        expect(my_proc).to_not receive(:call)
-        action false
-        expect(wf.error_pool).to eq 'dammed'
-     end
-    end
-  end
-
-  describe "when truthy" do
-    let(:my_proc) { ->(val){ val } }
-
-    def action(bool)
-      wf
-        .chain { wf.dam('dammed') if dam? }
-        .when_truthy { my_proc.call(bool) }
-          .dam  { error_string }
-        .chain  { @foo = 1 }
-    end
-
-    context "main context not dammed" do
-      let(:dam?) { false }
-
-      it "when actually falsy" do
-        action false
-        expect(wf.error_pool).to_not eq error_string
-        expect(@foo).to eq 1
-      end
-
-      it "when actually truthy" do
-        action true
-        expect(wf.error_pool).to eq error_string
-        expect(@foo).to_not eq 1
-      end
-    end
-
-    context "main context dammed" do
-      let(:dam?) { true }
-
-      it "when actually truthy" do
-        expect(my_proc).to_not receive(:call)
-        action true
-        expect(wf.error_pool).to eq 'dammed'
-      end
-    end
-  end
-
-  describe "error propagation" do
-    class FailingChain
-      include Waterfall
-
-      def call
-        self
-          .chain {|error_pool, waterfall| waterfall.dam(self.class.error) }
-      end
-
-      def self.error
-        'error'
-      end
-    end
-
-    it "error propagates" do
-      wf
-        .chain { FailingChain.new }
-        .chain { @foo = 1 }
-
-      expect(@foo).to_not eq 1
-      expect(wf.error_pool).to eq FailingChain.error
-    end
-  end
-
-  describe "dam" do
-    it "raises if falsy argument sent" do
-      expect { wf.dam(nil) }.to raise_error(Waterfall::IncorrectDamArgumentError)
-    end
-
-    it "dams with truthy argument" do
-      wf.dam(error_string)
-      expect(wf.error_pool).to eq error_string
-      expect(wf.dammed?).to be true
-    end
-  end
-
-  describe "undam" do
-    it "flow goes back to green path" do
-      wf
-        .chain  { wf.dam(error_string) }
-        .on_dam { wf.undam }
-        .chain  { @foo = 1 }
-        .on_dam { raise('shouldnt happen') }
-
-      expect(@foo).to eq 1
-    end
-  end
-end