waterfall 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 129bb57a29df2394c12511053c406490b8a99674
-  data.tar.gz: e7260b30ce91910cdb8d1466a39898000bde0fa5
+  metadata.gz: 926586c0692a21fc3e8110a28818a907c8b10d2d
+  data.tar.gz: 438651277ce425c2a9667e003a9f4deb56bfd61a
 SHA512:
-  metadata.gz: 80c9da8ab97a26854f8fa5700e1a8669409f2212fe16660805dff074894df2ba89aea2bec52efd232b874646de286cc992f9ad8d3be679fd63beefffdaa132fd
-  data.tar.gz: c9253aa6ce5ce77577398006957eab695b8489db2b914adfb68e44b0319820d6e8fa92159ed6a77aed93726f803e476194e7227bb8a844f82adf7283de6ddd9a
+  metadata.gz: c4c1bb9dc927cd752e7b184274373d624ad625d5d316e0930238c96a75c3fa0b5ee9129f4ef3865271d490f5e1d86d0eadd60e553f6a06e3c9636a15cbba5fa6
+  data.tar.gz: f10b48892968cb75add57c80b13374413820902a12324c97f3b531a6c1f96c4d832762732c3b61d6e3116fa0e247f3830b3e93edf10f762330182a78a7de58eb

data/.travis.yml

@@ -2,6 +2,8 @@ language: ruby
 rvm:
   - 2.0.0
   - 2.1.0
+  - 2.2.0
+  - 2.3.0
 script: bundle exec rspec spec
 addons:
   code_climate:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    waterfall (1.0.2)
+    waterfall (1.0.3)
 
 GEM
   remote: https://rubygems.org/
@@ -51,3 +51,6 @@ DEPENDENCIES
   rake
   rspec (= 3.2)
   waterfall!
+
+BUNDLED WITH
+   1.13.4

data/README.md

@@ -6,95 +6,78 @@
 
 Be able to chain ruby commands, and treat them like a flow.
 
-General presentation slides can [be found here](https://slides.com/apneadiving/code-ruby-like-you-build-legos).
+It provides a new approach to flow control.
 
-Check [the slides here](https://slides.com/apneadiving/handling-error-in-ruby-rails) for a refactoring example.
+When logic is complicated, waterfalls show their true power and let you write intention revealing code. Above all they excel at chaining services.
 
+General presentation slides can [be found here](https://slides.com/apneadiving/code-ruby-like-you-build-lego).
 
-#### Basic example
+#### Overview
 
-```ruby
-Wf.new
-  .when_falsy { @user.update(user_params) }
-    .dam { @user.errors }
-  .chain { render json: @user }
-  .on_dam { |errors| render json: { errors: errors.full_messages }, status: 422 }
-```
+A waterfall object has its own flow of commands, you can chain your commands and if something wrong happens, you dam the flow which bypasses the rest of the commands.
 
-When logic is complicated, waterfalls show their true power and let you write intention revealing code. Above all they excel at chaining services.
+Here is a basic representation:
+- green, the flow goes on, `chain` by `chain`
+- red its bypassed and only `on_dam` blocks are executed.
 
-#### Rationale
-Coding is all about writing a flow of commands.
+![Waterfall Logo](http://apneadiving.github.io/images/waterfall_principle.png)
 
-Generally you basically go on, unless something wrong happens. Whenever this happens you have to halt the flow and send feedback to the user.
+#### Example
 
-When conditions stack up, readability decreases.
-
-One way to solve it is to create abstractions to wrap your business logic (service objects or the like). There some questions arise:
-* what should a good service return?
-* how to handle errors?
-* how to call a service within a service?
-* how to chain services / commands
-
-Those topics are discussed in [the slides here](https://slides.com/apneadiving/service-objects-waterfall-rails).
+```ruby
+class FetchUser
+  include Waterfall
 
+  def initialize(user_id)
+    @user_id = user_id
+  end
 
-## Wf object
+  def call
+    chain { @response = HTTParty.get("https://jsonplaceholder.typicode.com/users/#{@user_id}") }
+    when_falsy { @response.success? }
+      .dam { "Error status #{@response.code}" }
+    chain(:user) { @response.body }
+  end
+end
+```
 
-The `Wf` class just includes the `Waterfall` module. It makes it easy to create standalone waterfalls mostly to chain actions or to chain services including `Waterfall` or returning a `Wf` object.
+and call / chain:
 
-Basically `chain` statements are executed in the order they appear. But if ever the waterfall is dammed, they are skipped.
+```ruby
+Wf.new
+  .chain(user1: :user) { FetchUser.new(1) }
+  .chain(user2: :user) { FetchUser.new(2) }
+  .chain  {|outflow| puts(outflow.user1, outflow.user2)  } # report success
+  .on_dam {|error|   puts(error)      }                    # report error
+```
 
-If a main waterfall chains another waterfall and the child waterfall is dammed, the main waterfall would be dammed.
+Which works like:
 
-The point is to be able to be able to chain an expected set of actions whenever everything works fine. And to be able to quickly stop and get the errors back whenever something wrong happens.
+![Waterfall Logo](http://apneadiving.github.io/images/waterfall_full_example.png)
 
 ## Installation
 
-There exists a gem on rubygem with the same name but its not mine :)
-
-For installation:
+For installation, in your gemfile:
 
-    gem 'waterfall', git: 'git://github.com/apneadiving/waterfall.git'
+    gem 'waterfall'
 
+then `bundle` as usual.
 
 ## Waterfall mixin
 
-### Overview
-
-The following are equivalent:
-```ruby
-# 1
-Wf.new.chain{ 1 + 1 }
-
-# 2
-class MyService
-  include Waterfall
-
-  def call
-    self.chain{ 1 + 1 }
-  end
-end
-
-MyService.new.call
-```
-
-This illustrates one convention classes including the mixin should obey: respond to `call`
-
 ### Outputs
 
 Each waterfall has its own `outflow` and `error_pool`.
 
 `outflow` is an Openstruct so you can get/set its property like a hash or like a standard object.
 
-For the `error_pool`, its up to you. But using Rails, I usually `include ActiveModel::Validations` in my services.
+### Wiki
+Wiki contains many details, please check appropriate pages:
 
-Thus you:
+- [Predicates](https://github.com/apneadiving/waterfall/wiki/Predicates)
+- [Wf Object](https://github.com/apneadiving/waterfall/wiki/Wf-object)
+- [Testing](https://github.com/apneadiving/waterfall/wiki/Testing)
 
-* have a standard way to deal with errors
-* can deal with multiple errors
-* support I18n out of the box
-* can use your model errors out of the box
 
 ## Illustration of chaining
 Doing
@@ -121,80 +104,6 @@ is the same as doing:
 
 Hopefully you better get the chaining power this way.
 
-## Predicates
-
-### chain(name_or_mapping = nil, &block) | block signature: (outflow, waterfall)
-
-Chain is the main predicate, what it does depends on what the block returns
-```ruby
- # main waterfall
- Wf.new
-   .chain(foo: :bar) do
-     # child waterfall
-     Wf.new.chain(:bar){ 1 }.chain(:baz){ 2 }.chain{ 3 }
-   end
-```
-##### when block doesn't return a waterfall
-
-The child waterfall would have the following outflow: `{ bar: 1, baz: 2 }`
-
-This illustrates that when the block returns a value which is not a waterfall, it stores the returned value of the block inside the `name_or_mapping` key of the `outflow` or doesn't store it if `name_or_mapping` is `nil`.
-
-Be aware those are equivalent:
-
-```ruby
-Wf.new.chain(:foo) { 1 }
-Wf.new.chain{|outflow| outflow[:foo] = 1 }
-Wf.new.chain{|outflow| outflow.foo = 1 }
-Wf.new.chain{|outflow, waterfall| waterfall.update_outflow(:foo, 1) }
-Wf.new.chain{|outflow, waterfall| waterfall.outflow.foo = 1 }
-```
-##### when block returns a waterfall
-
-The main waterfall would have the following outflow: `{ foo: 1 }`
-
-The main waterfall above receives the child waterfall as a return value of its `chain` block.
-All waterfalls have independent outflows.
-
-If `name_or_mapping` is `nil`, the main waterfall's `outflow` wouldnt be affected by its child (but if the child is dammed, the parent will be dammed).
-
-If `name_or_mapping` is a `hash`, the format must be read as `{ name_in_parent_waterfall: :name_from_child_waterfall}`. In the above example, the child returned an `outflow` with a `bar` key which has be renamed as `foo` in the main one.
-
-It may look useless, because most of the time you may not rename, but... It makes things clear. You know exactly what you expect and you know exactly that you dont expect the rest the child may provide.
-
-### when_falsy(&block) | block signature: (error_pool, waterfall)
-
-This predicate must ***always*** be used followed with `dam` like:
-
-```ruby
-Wf.new
-  .chain(:foo) { 1 }
-  .when_falsy { true }
-   .dam { "this wouldnt be executed"  }
-  .when_falsy { false }
-   .dam { "errrrr"  }
-  .chain(:bar) { 2 }
-  .on_dam {|error_pool| puts error_pool  }
-```
-
-If the block returns a falsy value, it executes the `dam` block, which will store the returned value in the `error_pool`.
-
-Once the waterfall is dammed, all following `chain` blocks are skipped (wont be executed). And all the following `on_dam` block would be executed.
-
-As a result the example above would return a waterfall object having its `outflow` equal to `{ foo: 1 }`. Remember: it has been dammed before `bar` would have been set.
-
-Its `error_pool` would be `"errrrr"` and it would be `puts` as a result of the `on_dam`
-
-Be aware those are equivalent:
-
-```ruby
-Wf.new.when_falsy{ false }.dam{ 'errrr' }
-Wf.new.chain{ |outflow, waterfall| waterfall.dam('errrr') unless false }
-```
-
-### when_truthy(&block) | block signature: (error_pool, waterfall)
-
-Behaves the same as `when_falsy` except it dams when its return value is truthy
 
 ## Syntactic sugar
 Given:
@@ -219,85 +128,7 @@ Wf.new
 ```
 Both are the same: if a block returns a waterfall which was not executed, it will execute it (hence the `call` convention)
 
-### on_dam(&block) | block signature: (error_pool, outflow, waterfall)
-
-Its block is executed whenever the waterfall is dammed, skipped otherwise.
-
-```ruby
-Wf.new
-  .when_falsy { false }
-  .on_dam {|error_pool, outflow, waterfall| puts error_pool  }
-```
-
-## Error propagation
 
-Whenever a a waterfall is dammed, all the following chains are skipped.
-
-* all the following chains are skipped
-* all `on_dam` blocks are executed
-
-## Testing a Waterfall service
-
-Say I have this service:
-```ruby
-class AuthenticateUser
-  include Waterfall
-  include ActiveModel::Validations
-
-  validates :user, presence: true
-  attr_reader :user
-
-  def initialize(email, password)
-    @email, @password = email, @password
-  end
-
-  def call
-    self
-      .chain { @user = User.authenticate(@email, @password) }
-      .when_falsy { valid? }
-         .dam { errors }
-      .chain(:user) { user }
-  end
-end
-```
-I could spec it this way:
-```ruby
-describe AuthenticateUser do
-  let(:email)    { 'email@email.com' }
-  let(:password) { 'password' }
-  subject(:service) { AuthenticateUser.new(email, password).call }
-
-  context "when given valid credentials" do
-    let(:user) { double(:user) }
-
-    before do
-      allow(User).to receive(:authenticate).with(email, password).and_return(user)
-    end
-
-    it "succeeds" do
-      expect(service.dammed?).to be false
-    end
-
-    it "provides the user" do
-      expect(service.outflow.user).to eq(user)
-    end
-  end
-
-  context "when given invalid credentials" do
-    before do
-      allow(User).to receive(:authenticate).with(email, password).and_return(nil)
-    end
-
-    it "fails" do
-      expect(service.dammed?).to be true
-    end
-
-    it "provides a failure message" do
-      expect(service.error_pool).to be_present
-    end
-  end
-end
-```
 Syntax advice
 =========
 ```ruby
@@ -323,6 +154,16 @@ self
 
 Tips
 =========
+### Error pool
+For the error_pool, its up to you. But using Rails, I usually include ActiveModel::Validations in my services.
+
+Thus you:
+
+- have a standard way to deal with errors
+- can deal with multiple errors
+- support I18n out of the box
+- can use your model errors out of the box
+
 ### Conditional Flow
 In a service, there is one and single flow, so if you need conditionals to branch off, you can do:
 ```ruby
@@ -335,11 +176,60 @@ else
 end
 ```
 
+### Rails and transactions
+I'm used to wrap every single object involving database interactions within transactions, so it can be rolled back on error.
+Here is my usual setup:
+```ruby
+module Waterfall
+  extend ActiveSupport::Concern
 
-Examples
-=========
-Check the [wiki for other examples](https://github.com/apneadiving/waterfall/wiki).
+  class Rollback < StandardError; end
+
+  def with_transaction(&block)
+    ActiveRecord::Base.transaction(requires_new: true) do
+      yield
+      on_dam do
+        raise Waterfall::Rollback
+      end
+    end
+  rescue Waterfall::Rollback
+    self
+  end
+end
+```
+
+And to use it:
+```ruby
+class AuthenticateUser
+  include Waterfall
+  include ActiveModel::Validations
+
+  validates :user, presence: true
+  attr_reader :user
+
+  def initialize(email, password)
+    @email, @password = email, @password
+  end
+
+  def call
+    with_transaction do
+      chain { @user = User.authenticate(@email, @password) }
+      when_falsy { valid? }
+        .dam { errors }
+      chain(:user) { user }
+    end
+  end
+end
+```
+The huge benefit is that if you call services from services, everything will be rolled back.
+
+Examples / Presentations
+========================
+- Check the [wiki for other examples](https://github.com/apneadiving/waterfall/wiki/Refactoring-examples).
+- [Structure and chain your POROs](http://slides.com/apneadiving/structure-and-chain-your-poros).
+- [Service objects implementations](https://slides.com/apneadiving/service-objects-waterfall-rails).
+- [Handling error in Rails](https://slides.com/apneadiving/handling-error-in-ruby-rails).
 
 Thanks
 =========
-Huge thanks to [laxrph10](https://github.com/laxrph10) for the help during infinite naming brainstorming.
+Huge thanks to [robhorrigan](https://github.com/robhorrigan) for the help during infinite naming brainstorming.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/changelog.md

@@ -0,0 +1,6 @@
+===1.0.3
+- Small refactors
+- if waterfall 1 calls waterfall 2 and waterfall2 is dammed, now waterfall1 is able to get values from waterfall2's outflow
+
+===1.0.2
+Initial release

data/lib/waterfall/predicates/base.rb

@@ -5,17 +5,6 @@ module Waterfall
       obj.respond_to?(:is_waterfall?) && obj.is_waterfall?
     end
 
-    def chained_waterfall(child_waterfall)
-      child_waterfall.call unless child_waterfall.flowing?
-
-      if child_waterfall.dammed?
-        @root.dam child_waterfall.error_pool
-      else
-        yield
-      end
-      self
-    end
-
     def yield_args
       [@root.outflow, @root]
     end

data/lib/waterfall/predicates/chain.rb

@@ -16,11 +16,17 @@ module Waterfall
     end
 
     def map_waterfalls(child_waterfall, mapping)
-      chained_waterfall(child_waterfall) do
-        mapping.each do |k, v|
-          @root.update_outflow(k, child_waterfall.outflow[v])
-        end
+      child_waterfall.call unless child_waterfall.flowing?
+
+      mapping.each do |k, v|
+        @root.update_outflow(k, child_waterfall.outflow[v])
+      end
+
+      if child_waterfall.dammed?
+        @root.dam child_waterfall.error_pool
       end
+
+      self
     end
   end
 end

data/lib/waterfall/predicates/when_falsy.rb

@@ -1,19 +1,10 @@
-module Waterfall
-  class WhenFalsy < Base
-
-    def initialize(root)
-      @root = root
-    end
+require_relative 'when_truthy'
 
-    def call
-      @output = yield(*yield_args)
-    end
+module Waterfall
+  class WhenFalsy < WhenTruthy
 
-    def dam
-      if !@root.dammed? && !@output
-        @root.dam yield(*yield_args)
-      end
-      @root
+    def condition?
+      ! super
     end
   end
 end

data/lib/waterfall/predicates/when_truthy.rb

@@ -10,10 +10,14 @@ module Waterfall
     end
 
     def dam
-      if !@root.dammed? && @output
+      if !@root.dammed? && condition?
         @root.dam yield(*yield_args)
       end
       @root
     end
+
+    def condition?
+      @output
+    end
   end
 end

data/lib/waterfall/version.rb

@@ -1,3 +1,3 @@
 module Waterfall
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/spec/integration_spec.rb

@@ -7,33 +7,48 @@ describe 'Wf' do
 
     it "yields wf outflow" do
       wf
-        .chain  {|outflow| outflow[:bar] = 'bar' }
-        .chain  {|outflow| @bar = outflow[:bar] }
-      expect(wf.outflow[:bar]).to eq 'bar'
+        .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'
+      expect(wf.outflow.bar).to eq 'bar'
     end
 
     context "wf internals" do
       it "dam from within" do
         wf
           .chain  {|outflow, waterfall| waterfall.dam('errrrr') }
-          .on_dam {|error_pool| @errors = error_pool }
 
         expect(wf.dammed?).to be true
-        expect(@errors).to eq 'errrrr'
+        expect(wf.error_pool).to eq 'errrrr'
+      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 }
+          .chain {|outflow, waterfall| waterfall.outflow.foo = 1 }
 
-        expect(wf.outflow[:foo]).to eq 1
+        expect(wf.outflow.foo).to eq 1
       end
     end
 
@@ -47,7 +62,7 @@ describe 'Wf' do
 
             expect(wf.outflow.foo).to be nil
             expect(wf.outflow.bar).to be nil
-            expect(wf.outflow[:baz]).to eq waterfall.outflow[:foo]
+            expect(wf.outflow.baz).to eq waterfall.outflow.foo
           end
         end
       end
@@ -103,7 +118,6 @@ describe 'Wf' do
         .when_falsy { my_proc.call(bool) }
           .dam  { 'err' }
         .chain  { @foo = 1 }
-        .on_dam { |error_pool| @error = error_pool }
     end
 
     context "main context not dammed" do
@@ -111,13 +125,13 @@ describe 'Wf' do
 
       it "when actually falsy" do
         action false
-        expect(@error).to eq 'err'
+        expect(wf.error_pool).to eq 'err'
         expect(@foo).to_not eq 1
       end
 
       it "when actually truthy" do
         action true
-        expect(@error).to_not eq 'err'
+        expect(wf.error_pool).to_not eq 'err'
         expect(@foo).to eq 1
       end
     end
@@ -128,7 +142,8 @@ describe 'Wf' do
       it "when actually falsy" do
         expect(my_proc).to_not receive(:call)
         action false
-      end
+        expect(wf.error_pool).to eq 'dammed'
+     end
     end
   end
 
@@ -141,7 +156,6 @@ describe 'Wf' do
         .when_truthy { my_proc.call(bool) }
           .dam  { 'err' }
         .chain  { @foo = 1 }
-        .on_dam { |error_pool| @error = error_pool }
     end
 
     context "main context not dammed" do
@@ -149,13 +163,13 @@ describe 'Wf' do
 
       it "when actually falsy" do
         action false
-        expect(@error).to_not eq 'err'
+        expect(wf.error_pool).to_not eq 'err'
         expect(@foo).to eq 1
       end
 
       it "when actually truthy" do
         action true
-        expect(@error).to eq 'err'
+        expect(wf.error_pool).to eq 'err'
         expect(@foo).to_not eq 1
       end
     end
@@ -166,6 +180,7 @@ describe 'Wf' do
       it "when actually truthy" do
         expect(my_proc).to_not receive(:call)
         action true
+        expect(wf.error_pool).to eq 'dammed'
       end
     end
   end
@@ -188,10 +203,21 @@ describe 'Wf' do
       wf
         .chain { FailingChain.new }
         .chain    { @foo = 1 }
-        .on_dam   { |error_pool| @error = error_pool }
 
       expect(@foo).to_not eq 1
-      expect(@error).to eq FailingChain.error
+      expect(wf.error_pool).to eq FailingChain.error
+    end
+  end
+
+  describe "undam" do
+    it "flow goes back to green path" do
+      wf
+        .chain  { wf.dam('err') }
+        .on_dam { wf.undam }
+        .chain  { @foo = 1 }
+        .on_dam { raise('shouldnt happen') }
+
+      expect(@foo).to eq 1
     end
   end
 end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: waterfall
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Benjamin Roth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-27 00:00:00.000000000 Z
+date: 2016-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>'
+    - - ">"
       - !ruby/object:Gem::Version
         version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>'
+    - - ">"
       - !ruby/object:Gem::Version
         version: '0.10'
 - !ruby/object:Gem::Dependency
   name: pry-nav
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -88,13 +88,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
+- Rakefile
+- changelog.md
 - lib/waterfall.rb
 - lib/waterfall/predicates/base.rb
 - lib/waterfall/predicates/chain.rb
@@ -115,17 +117,17 @@ 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.0.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A slice of functional programming to chain ruby services and blocks. Make