call_sheet 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96d48219b6b93de88c46f9bdd0e146a1d7874fc7
-  data.tar.gz: d8f8982248cab8b53578356484b0a933aaab5a92
+  metadata.gz: bb1702c17a58664dd0fe67c3e785151da951b418
+  data.tar.gz: 9fe07911b83cd2b03f46e4067423322bb61a1cd4
 SHA512:
-  metadata.gz: 460c3efef5e4b95ab44bb4a6b105c022e60fd57b0830f8c6ecbbdbaca20b29698a51e2389104823381785dba3893af85f57f29b0621d622690cab0d3d694ca93
-  data.tar.gz: ab53c4c441ab6c0b58baaff91b8a8ba188bf190d5b12355922f51719d86ec9c565660df927f5b34f2011da3972dfd4c12a1bcb37ed43ee193e8d965415fdba52
+  metadata.gz: ed94e027073aec6f2ca2d7a3a7e5323463caab088536266fe55b1b41c0bc0b88db1b277cd60f7e5ebbd7799a06965aca1dc250276f3fd91fd57858f60f80b93e
+  data.tar.gz: 37253ade71ab026981f3064d9bc2a77ac5a64fe3cb870096fa01c6bba6c871796cd19a4e0f5d71d69f36695c02a884be027c9c7870dd3d8847c709d0e501c442

data/Gemfile

@@ -2,3 +2,5 @@ source "https://rubygems.org"
 
 # Gem dependencies are specified in call_sheet.gemspec
 gemspec
+
+gem "kleisli"

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    call_sheet (0.1.0)
+    call_sheet (0.2.0)
       deterministic (>= 0.15.3)
+      kleisli
       wisper (>= 1.6.0)
 
 GEM
@@ -15,6 +16,7 @@ GEM
     diff-lcs (1.2.5)
     docile (1.1.5)
     json (1.8.3)
+    kleisli (0.2.6)
     parser (2.2.3.0)
       ast (>= 1.1, < 3.0)
     powerpack (0.1.1)
@@ -54,6 +56,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.10)
   call_sheet!
+  kleisli
   rake (~> 10.4.2)
   rspec (~> 3.3.0)
   rubocop (~> 0.34.2)

data/README.md

@@ -25,7 +25,7 @@ Call Sheet is based on the following ideas, drawn mostly from [Transflow](http:/
 
 Requiring a business transaction's steps to exist as independent operations directly addressable voa a container means that they can be tested in isolation and easily reused throughout your application. Following from this, keeping the business transaction to a series of high-level, declarative steps ensures that it's easy to understand at a glance.
 
-The output of each step is wrapped in a [Deterministic](https://github.com/pzol/deterministic) `Result` object (either `Success(s)` or `Failure(f)`). This allows the steps to be chained together and ensures that processing stops in the case of a failure. Returning a `Result` from the overall transaction also allows for error handling to remain a primary concern without it getting in the way of tidy, straightforward operation logic. Wrapping the step output also means that you can work with a wide variety of operations within your application – they don’t need to return a `Result` already.
+The output of each step is wrapped in a [Kleisli](https://github.com/txus/kleisli) `Either` object (`Right` for success or `Left` for failure). This allows the steps to be chained together and ensures that processing stops in the case of a failure. Returning an `Either` from the overall transaction also allows for error handling to remain a primary concern without it getting in the way of tidy, straightforward operation logic. Wrapping the step output also means that you can work with a wide variety of operations within your application – they don’t need to return an `Either` already.
 
 ## Usage
 
@@ -33,10 +33,10 @@ All you need to use Call Sheet is a container of operations that respond to `#ca
 
 Each operation is integrated into your business transaction through one of the following step adapters:
 
-* `map` – any output is considered successful and returned as `Success(output)`
-* `try` – the operation may raise an exception in an error case. This is caught and returned as `Failure(exception)`. The output is otherwise returned as `Success(output)`.
-* `tee` – the operation interacts with some external system and has no meaningful output. The original input is passed through and returned as `Success(input)`.
-* `raw` or `step` – the operation already returns its own `Result` object, and needs no special handling.
+* `map` – any output is considered successful and returned as `Right(output)`
+* `try` – the operation may raise an exception in an error case. This is caught and returned as `Left(exception)`. The output is otherwise returned as `Right(output)`.
+* `tee` – the operation interacts with some external system and has no meaningful output. The original input is passed through and returned as `Right(input)`.
+* `raw` or `step` – the operation already returns its own `Either` object, and needs no special handling.
 
 ```ruby
 DB = []
@@ -54,31 +54,33 @@ save_user = CallSheet(container: container) do
 end
 
 save_user.call("name" => "Jane", "email" => "jane@doe.com")
-# => Success({:name=>"Jane", :email=>"jane@doe.com"})
+# => Right({:name=>"Jane", :email=>"jane@doe.com"})
 
 DB
 # => [{:name=>"Jane", :email=>"jane@doe.com"}]
 ```
 
-Each transaction returns a `Success(s)` or `Failure(f)` result. You can handle these different results with Deterministic’s [pattern matching](https://github.com/pzol/deterministic#pattern-matching):
+Each transaction returns a result value wrapped in a `Left` or `Right` object. You can handle these different results (including errors arising from particular steps) with a match block:
 
 ```ruby
-save_user.call(name: "Jane", email: "jane@doe.com").match do
-  Success(s) do
+save_user.call(name: "Jane", email: "jane@doe.com") do |m|
+  m.success do
     puts "Succeeded!"
   end
-  Failure(f, where { f == :validate }) do |errors|
-    # In a more realistic example, you’d loop through a list of messages in `errors`.
-    puts "Couldn’t save this user. Please provide an email address."
-  end
-  Failure(f) do
-    puts "Couldn’t save this user."
+
+  m.failure do |f|
+    f.on :validate do |errors|
+      # In a more realistic example, you’d loop through a list of messages in `errors`.
+      puts "Couldn’t save this user. Please provide an email address."
+    end
+
+    f.otherwise do |error|
+      puts "Couldn’t save this user."
+    end
   end
 end
 ```
 
-You can use guard expressions like `where { f == :step_name }` in the failure matches to catch failures that arise from particular steps in your transaction.
-
 ### Passing additional step arguments
 
 Additional arguments for step operations can be passed at the time of calling your transaction. Provide these arguments as an array, and they’ll be [splatted](https://endofline.wordpress.com/2011/01/21/the-strange-ruby-splat/) into the front of the operation’s arguments. This means that transactions can effectively support operations with any sort of `#call(*args, input)` interface.
@@ -100,10 +102,10 @@ end
 
 input = {"name" => "Jane", "email" => "jane@doe.com"}
 save_user.call(input, validate: ["doe.com"])
-# => Success({:name=>"Jane", :email=>"jane@doe.com"})
+# => Right({:name=>"Jane", :email=>"jane@doe.com"})
 
 save_user.call(input, validate: ["smith.com"])
-# => Failure("not allowed")
+# => Left("not allowed")
 ```
 
 ### Subscribing to step notifications
@@ -149,7 +151,7 @@ save_user = CallSheet(container: large_whole_app_container) do
 end
 ```
 
-A `raw` step can also be used if the operation in your container already returns a `Result` and therefore doesn’t need any special handling.
+A `raw` step (also aliased as `step`) can be used if the operation in your container already returns an `Either` and therefore doesn’t need any special handling.
 
 ## Installation
 
@@ -169,7 +171,7 @@ Bug reports and pull requests are welcome on [GitHub](http://github.com/icelab/c
 
 Call Sheet is developed and maintained by [Icelab](http://icelab.com.au/).
 
-Call Sheet’s error handling is based on Scott Wlaschin’s [Railway Oriented Programming](http://fsharpforfunandprofit.com/rop/), found via Zohaib Rauf’s [Railway Oriented Programming in Elixir](http://zohaib.me/railway-programming-pattern-in-elixir/) blog post. Call Sheet’s behavior as a business transaction library draws heavy inspiration from Piotr Solnica’s [Transflow](http://github.com/solnic/transflow) and Gilbert B Garza’s [Solid Use Case](https://github.com/mindeavor/solid_use_case). Piotr Zolnierek’s [Deterministic](https://github.com/pzol/deterministic) gem makes working with functional programming patterns in Ruby fun and easy. Thank you all!
+Call Sheet’s error handling is based on Scott Wlaschin’s [Railway Oriented Programming](http://fsharpforfunandprofit.com/rop/), found via Zohaib Rauf’s [Railway Oriented Programming in Elixir](http://zohaib.me/railway-programming-pattern-in-elixir/) blog post. Call Sheet’s behavior as a business transaction library draws heavy inspiration from Piotr Solnica’s [Transflow](http://github.com/solnic/transflow) and Gilbert B Garza’s [Solid Use Case](https://github.com/mindeavor/solid_use_case). Josep M. Bach’s [Kleisli](https://github.com/txus/kleisli) gem makes functional programming patterns in Ruby accessible and fun. Thank you all!
 
 ## License
 

data/lib/call_sheet/dsl.rb

@@ -9,8 +9,6 @@ require "call_sheet/transaction"
 
 module CallSheet
   class DSL
-    include Deterministic::Prelude::Result
-
     # @api private
     attr_reader :options
 

data/lib/call_sheet/result_matcher.rb

@@ -0,0 +1,40 @@
+module CallSheet
+  class ResultMatcher
+    attr_reader :result
+    attr_reader :value
+
+    def initialize(result)
+      @result = result
+      @value = result.value
+    end
+
+    def success(&block)
+      block.call value if result.is_a?(Kleisli::Either::Right)
+    end
+
+    def failure(&block)
+      block.call FailureMatcher.new(result) if result.is_a?(Kleisli::Either::Left)
+    end
+
+    class FailureMatcher
+      attr_reader :result
+      attr_reader :value
+
+      def initialize(result)
+        @result = result
+        @value = result.value
+      end
+
+      def on(step_name, &block)
+        if value.__step_name == step_name
+          @matched = true
+          block.call value
+        end
+      end
+
+      def otherwise(&block)
+        block.call value unless @matched
+      end
+    end
+  end
+end

data/lib/call_sheet/step.rb

@@ -4,7 +4,6 @@ require "call_sheet/step_failure"
 module CallSheet
   # @api private
   class Step
-    include Deterministic::Prelude::Result
     include Wisper::Publisher
 
     attr_reader :step_name
@@ -22,15 +21,15 @@ module CallSheet
     end
 
     def call(input)
-      args = (call_args << input)
+      args = (call_args.dup << input)
       result = operation.call(*args)
 
-      result.map { |value|
+      result.fmap { |value|
         broadcast :"#{step_name}_success", value
-        Success(value)
-      }.map_err { |value|
+        value
+      }.or { |value|
         broadcast :"#{step_name}_failure", *args, value
-        Failure(StepFailure.new(step_name, value))
+        Left(StepFailure.new(step_name, value))
       }
     end
 

data/lib/call_sheet/step_adapters/base.rb

@@ -2,8 +2,6 @@ module CallSheet
   module StepAdapters
     # @api private
     class Base
-      include Deterministic::Prelude::Result
-
       attr_reader :operation
       attr_reader :options
 

data/lib/call_sheet/step_adapters/map.rb

@@ -3,7 +3,7 @@ module CallSheet
     # @api private
     class Map < Base
       def call(*args, input)
-        Success(operation.call(input, *args))
+        Right(operation.call(input, *args))
       end
     end
 

data/lib/call_sheet/step_adapters/tee.rb

@@ -4,7 +4,7 @@ module CallSheet
     class Tee < Base
       def call(*args, input)
         operation.call(*args, input)
-        Success(input)
+        Right(input)
       end
     end
 

data/lib/call_sheet/step_adapters/try.rb

@@ -8,9 +8,9 @@ module CallSheet
       end
 
       def call(*args, input)
-        Success(operation.call(*args, input))
+        Right(operation.call(*args, input))
       rescue *Array(options[:catch]) => e
-        Failure(e)
+        Left(e)
       end
     end
 

data/lib/call_sheet/step_failure.rb

@@ -1,5 +1,7 @@
 module CallSheet
   class StepFailure < BasicObject
+    attr_reader :__step_name
+
     def initialize(step_name, object)
       @__step_name = step_name
       @__object = object
@@ -10,7 +12,7 @@ module CallSheet
     end
 
     def ==(other)
-      @__step_name == other || @__object == other
+      @__object == other
     end
   end
 end

data/lib/call_sheet/transaction.rb

@@ -1,7 +1,7 @@
+require "call_sheet/result_matcher"
+
 module CallSheet
   class Transaction
-    include Deterministic::Prelude::Result
-
     # @api private
     attr_reader :steps
     private :steps
@@ -12,12 +12,15 @@ module CallSheet
     end
 
     # @api public
-    def call(input, options = {})
+    def call(input, options = {}, &block)
       assert_valid_options(options)
       assert_options_satisfy_step_arity(options)
 
       steps = steps_with_options_applied(options)
-      steps.inject(Success(input), :>>)
+      result = steps.inject(Right(input), :>>)
+
+      block.call ResultMatcher.new(result) if block
+      result
     end
     alias_method :[], :call
 

data/lib/call_sheet/version.rb

@@ -1,4 +1,4 @@
 # Business transaction DSL.
 module CallSheet
-  VERSION = "0.2.0".freeze
+  VERSION = "0.3.0".freeze
 end

data/lib/call_sheet.rb

@@ -1,4 +1,4 @@
-require "deterministic"
+require "kleisli"
 require "call_sheet/version"
 require "call_sheet/dsl"
 

data/spec/examples.txt

@@ -1,21 +1,23 @@
 example_id                                               | status | run_time        |
 -------------------------------------------------------- | ------ | --------------- |
-./spec/integration/call_sheet_spec.rb[1:1:1]             | passed | 0.00244 seconds |
-./spec/integration/call_sheet_spec.rb[1:1:2]             | passed | 0.00114 seconds |
-./spec/integration/call_sheet_spec.rb[1:1:3]             | passed | 0.00101 seconds |
-./spec/integration/call_sheet_spec.rb[1:1:4]             | passed | 0.00237 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:1]             | passed | 0.0008 seconds  |
-./spec/integration/call_sheet_spec.rb[1:2:2]             | passed | 0.00086 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:3]             | passed | 0.00154 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:4]             | passed | 0.00087 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:5]             | passed | 0.00085 seconds |
-./spec/integration/call_sheet_spec.rb[1:3:1]             | passed | 0.00068 seconds |
-./spec/integration/call_sheet_spec.rb[1:3:2]             | passed | 0.00072 seconds |
-./spec/integration/call_sheet_spec.rb[1:3:3]             | passed | 0.00065 seconds |
-./spec/integration/passing_step_arguments_spec.rb[1:1:1] | passed | 0.00312 seconds |
-./spec/integration/passing_step_arguments_spec.rb[1:2:1] | passed | 0.00023 seconds |
-./spec/integration/passing_step_arguments_spec.rb[1:3:1] | passed | 0.00202 seconds |
-./spec/integration/publishing_step_events_spec.rb[1:1:1] | passed | 0.00096 seconds |
-./spec/integration/publishing_step_events_spec.rb[1:1:2] | passed | 0.00077 seconds |
-./spec/integration/publishing_step_events_spec.rb[1:2:1] | passed | 0.00254 seconds |
-./spec/integration/publishing_step_events_spec.rb[1:2:2] | passed | 0.00083 seconds |
+./spec/integration/call_sheet_spec.rb[1:1:1]             | passed | 0.00147 seconds |
+./spec/integration/call_sheet_spec.rb[1:1:2]             | passed | 0.00103 seconds |
+./spec/integration/call_sheet_spec.rb[1:1:3]             | passed | 0.00032 seconds |
+./spec/integration/call_sheet_spec.rb[1:1:4]             | passed | 0.00108 seconds |
+./spec/integration/call_sheet_spec.rb[1:1:5]             | passed | 0.00043 seconds |
+./spec/integration/call_sheet_spec.rb[1:2:1]             | passed | 0.00224 seconds |
+./spec/integration/call_sheet_spec.rb[1:2:2]             | passed | 0.00028 seconds |
+./spec/integration/call_sheet_spec.rb[1:2:3]             | passed | 0.0007 seconds  |
+./spec/integration/call_sheet_spec.rb[1:2:4]             | passed | 0.00027 seconds |
+./spec/integration/call_sheet_spec.rb[1:2:5]             | passed | 0.00025 seconds |
+./spec/integration/call_sheet_spec.rb[1:2:6]             | passed | 0.00048 seconds |
+./spec/integration/call_sheet_spec.rb[1:3:1]             | passed | 0.00035 seconds |
+./spec/integration/call_sheet_spec.rb[1:3:2]             | passed | 0.00018 seconds |
+./spec/integration/call_sheet_spec.rb[1:3:3]             | passed | 0.0003 seconds  |
+./spec/integration/passing_step_arguments_spec.rb[1:1:1] | passed | 0.00023 seconds |
+./spec/integration/passing_step_arguments_spec.rb[1:2:1] | passed | 0.00039 seconds |
+./spec/integration/passing_step_arguments_spec.rb[1:3:1] | passed | 0.00137 seconds |
+./spec/integration/publishing_step_events_spec.rb[1:1:1] | passed | 0.00055 seconds |
+./spec/integration/publishing_step_events_spec.rb[1:1:2] | passed | 0.00052 seconds |
+./spec/integration/publishing_step_events_spec.rb[1:2:1] | passed | 0.0004 seconds  |
+./spec/integration/publishing_step_events_spec.rb[1:2:2] | passed | 0.0016 seconds  |

data/spec/integration/call_sheet_spec.rb

@@ -1,6 +1,4 @@
 RSpec.describe CallSheet do
-  include Deterministic::Prelude::Result
-
   let(:call_sheet) {
     CallSheet(container: container) do
       map :process
@@ -13,7 +11,7 @@ RSpec.describe CallSheet do
   let(:container) {
     {
       process:  -> input { {name: input["name"], email: input["email"]} },
-      verify:   -> input { Success(input) },
+      verify:   -> input { Right(input) },
       validate: -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input },
       persist:  -> input { Test::DB << input and true }
     }
@@ -26,87 +24,120 @@ RSpec.describe CallSheet do
 
   context "successful" do
     let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
-    let(:run_call_sheet) { call_sheet.call(input) }
 
     it "calls the operations" do
-      run_call_sheet
+      call_sheet.call(input)
       expect(Test::DB).to include(name: "Jane", email: "jane@doe.com")
     end
 
     it "returns a success" do
-      expect(run_call_sheet).to be_success
+      expect(call_sheet.call(input)).to be_a Kleisli::Either::Right
     end
 
     it "wraps the result of the final operation" do
-      expect(run_call_sheet.value).to eq(name: "Jane", email: "jane@doe.com")
+      expect(call_sheet.call(input).value).to eq(name: "Jane", email: "jane@doe.com")
+    end
+
+    it "can be called multiple times to the same effect" do
+      call_sheet.call(input)
+      call_sheet.call(input)
+
+      expect(Test::DB[0]).to eq(name: "Jane", email: "jane@doe.com")
+      expect(Test::DB[1]).to eq(name: "Jane", email: "jane@doe.com")
     end
 
-    it "supports pattern matching on success" do
-      match = run_call_sheet.match do
-        Success(s) { "Matched on success" }
-        Failure(_) {}
+    it "supports matching on success" do
+      results = []
+
+      call_sheet.call(input) do |m|
+        m.success do |value|
+          results << "success for #{value[:email]}"
+        end
       end
 
-      expect(match).to eq "Matched on success"
+      expect(results.first).to eq "success for jane@doe.com"
     end
   end
 
   context "failed in a try step" do
     let(:input) { {"name" => "Jane"} }
-    let(:run_call_sheet) { call_sheet.call(input) }
 
     it "does not run subsequent operations" do
-      run_call_sheet
+      call_sheet.call(input)
       expect(Test::DB).to be_empty
     end
 
     it "returns a failure" do
-      expect(run_call_sheet).to be_failure
+      expect(call_sheet.call(input)).to be_a Kleisli::Either::Left
     end
 
     it "wraps the result of the failing operation" do
-      expect(run_call_sheet.value).to be_a Test::NotValidError
+      expect(call_sheet.call(input).value).to be_a Test::NotValidError
     end
 
-    it "supports pattern matching on failure" do
-      match = run_call_sheet.match do
-        Success(_) {}
-        Failure(f) { "Matched on failure" }
+    it "supports matching on failure" do
+      results = []
+
+      call_sheet.call(input) do |m|
+        m.failure do |f|
+          results << "Failed: #{f.value}"
+        end
       end
 
-      expect(match).to eq "Matched on failure"
+      expect(results.first).to eq "Failed: email required"
     end
 
-    it "supports pattern matching on specific step failures" do
-      match = run_call_sheet.match do
-        Success(_) {}
-        Failure(f, where { f == :validate }) { "Matched validate failure" }
-        Failure(_) {}
+    it "supports matching on specific step failures" do
+      results = []
+
+      call_sheet.call(input) do |m|
+        m.failure do |f|
+          f.on :validate do |v|
+            results << "Validation failure: #{v}"
+          end
+        end
+      end
+
+      expect(results.first).to eq "Validation failure: email required"
+    end
+
+    it "supports matching on un-named step failures" do
+      results = []
+
+      call_sheet.call(input) do |m|
+        m.failure do |f|
+          f.on :some_other_step do |v|
+            results << "Some other step failure"
+          end
+
+          f.otherwise do |v|
+            results << "Catch-all failure: #{v}"
+          end
+        end
       end
 
-      expect(match).to eq "Matched validate failure"
+      expect(results.first).to eq "Catch-all failure: email required"
     end
   end
 
   context "failed in a raw step" do
     let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
-    let(:run_call_sheet) { call_sheet.call(input) }
 
     before do
-      container[:verify] = -> input { Failure("raw failure") }
+      container[:verify] = -> input { Left("raw failure") }
     end
 
     it "does not run subsequent operations" do
-      run_call_sheet
+      call_sheet.call(input)
       expect(Test::DB).to be_empty
     end
 
     it "returns a failure" do
-      expect(run_call_sheet).to be_failure
+      expect(call_sheet.call(input)).to be_a Kleisli::Either::Left
     end
 
     it "returns the failing value from the operation" do
-      expect(run_call_sheet.value).to eq "raw failure"
+      expect(call_sheet.call(input).value).to eq "raw failure"
     end
   end
 end

data/spec/integration/passing_step_arguments_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe "Passing additional arguments to step operations" do
     let(:step_options) { {validate: ["doe.com"]} }
 
     it "passes the arguments and calls the operations successfully" do
-      expect(run_call_sheet).to be_success
+      expect(run_call_sheet).to be_a Kleisli::Either::Right
     end
   end
 

data/spec/integration/publishing_step_events_spec.rb

@@ -1,6 +1,4 @@
 RSpec.describe "publishing step events" do
-  include Deterministic::Prelude::Result
-
   let(:call_sheet) {
     CallSheet(container: container) do
       map :process
@@ -12,7 +10,7 @@ RSpec.describe "publishing step events" do
   let(:container) {
     {
       process:  -> input { {name: input["name"]} },
-      verify:   -> input { input[:name].to_s != "" ? Success(input) : Failure("no name") },
+      verify:   -> input { input[:name].to_s != "" ? Right(input) : Left("no name") },
       persist:  -> input { Test::DB << input and true }
     }
   }

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require "simplecov"
-SimpleCov.start
 SimpleCov.minimum_coverage 100
+SimpleCov.start do
+  add_filter "/spec/"
+end
 
 require "call_sheet"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: call_sheet
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tim Riley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-02 00:00:00.000000000 Z
+date: 2015-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deterministic
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.15.3
+- !ruby/object:Gem::Dependency
+  name: kleisli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: wisper
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +150,7 @@ files:
 - Rakefile
 - lib/call_sheet.rb
 - lib/call_sheet/dsl.rb
+- lib/call_sheet/result_matcher.rb
 - lib/call_sheet/step.rb
 - lib/call_sheet/step_adapters.rb
 - lib/call_sheet/step_adapters/base.rb