call_sheet 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3c20bf00a8dd774a7a7a9110001576dfae39667
-  data.tar.gz: acca5a6e3f2575b54b13c7d3744f466e471ff753
+  metadata.gz: 96d48219b6b93de88c46f9bdd0e146a1d7874fc7
+  data.tar.gz: d8f8982248cab8b53578356484b0a933aaab5a92
 SHA512:
-  metadata.gz: 5442457894d06089e52de190a7ccd62b504e71d7cd66ba4764ee01134c48c2e5cc923b534fbc3caff3d41f3f2368d5a89af373e44393a2f933a6504392ae271b
-  data.tar.gz: 05acf6f917f9fbc1102c12bfb54e1a60aa0089d8e810a2a70ddec22d44f31c43b7d4368997fb3180a47fa7312013395606191642ae06888fda808bbde3955583
+  metadata.gz: 460c3efef5e4b95ab44bb4a6b105c022e60fd57b0830f8c6ecbbdbaca20b29698a51e2389104823381785dba3893af85f57f29b0621d622690cab0d3d694ca93
+  data.tar.gz: ab53c4c441ab6c0b58baaff91b8a8ba188bf190d5b12355922f51719d86ec9c565660df927f5b34f2011da3972dfd4c12a1bcb37ed43ee193e8d965415fdba52

data/Gemfile.lock

@@ -3,6 +3,7 @@ PATH
   specs:
     call_sheet (0.1.0)
       deterministic (>= 0.15.3)
+      wisper (>= 1.6.0)
 
 GEM
   remote: https://rubygems.org/
@@ -44,6 +45,8 @@ GEM
       json (~> 1.8)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
+    wisper (1.6.1)
+    yard (0.8.7.6)
 
 PLATFORMS
   ruby
@@ -55,6 +58,7 @@ DEPENDENCIES
   rspec (~> 3.3.0)
   rubocop (~> 0.34.2)
   simplecov (~> 0.10.0)
+  yard
 
 BUNDLED WITH
    1.10.6

data/README.md

@@ -1,5 +1,13 @@
+[gem]: https://rubygems.org/gems/call_sheet
+[code_climate]: https://codeclimate.com/github/icelab/call_sheet
+[inch]: http://inch-ci.org/github/icelab/call_sheet
+
 # Call Sheet
 
+[![Gem Version](https://img.shields.io/gem/v/call_sheet.svg)][gem]
+[![Code Climate](https://img.shields.io/codeclimate/github/icelab/call_sheet.svg)][code_climate]
+[![API Documentation Coverage](http://inch-ci.org/github/icelab/call_sheet.svg)][inch]
+
 Call Sheet is a business transaction DSL. It provides a simple way to define a complex business transaction that includes processing by many different objects. It makes error handling a primary concern by using a “[Railway Oriented Programming](http://fsharpforfunandprofit.com/rop/)” approach for capturing and returning errors from any step in the transaction.
 
 Call Sheet is based on the following ideas, drawn mostly from [Transflow](http://github.com/solnic/transflow):
@@ -28,20 +36,20 @@ Each operation is integrated into your business transaction through one of the f
 * `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` – the operation already returns its own `Result` object, and needs no special handling.
+* `raw` or `step` – the operation already returns its own `Result` object, and needs no special handling.
 
 ```ruby
 DB = []
 
 container = {
   process:  -> input { {name: input["name"], email: input["email"]} },
-  validate: -> input { input[:email].nil? ? raise("not valid") : input },
+  validate: -> input { input[:email].nil? ? raise(ValidationFailure, "not valid") : input },
   persist:  -> input { DB << input and true }
 }
 
 save_user = CallSheet(container: container) do
   map :process
-  try :validate
+  try :validate, catch: ValidationFailure
   tee :persist
 end
 
@@ -73,24 +81,24 @@ You can use guard expressions like `where { f == :step_name }` in the failure ma
 
 ### 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 effectively means that transactions can support operations with any sort of `#call(*args, input)` interface.
+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.
 
 ```ruby
 DB = []
 
 container = {
   process:  -> input { {name: input["name"], email: input["email"]} },
-  validate: -> allowed, input { input[:email].include?(allowed) ? raise("not allowed") : input },
+  validate: -> allowed, input { input[:email].include?(allowed) ? raise(ValidationFailure, "not allowed") : input },
   persist:  -> input { DB << input and true }
 }
 
 save_user = CallSheet(container: container) do
   map :process
-  try :validate
+  try :validate, catch: ValidationFailure
   tee :persist
 end
 
-input = {name: "Jane", email: "jane@doe.com"}
+input = {"name" => "Jane", "email" => "jane@doe.com"}
 save_user.call(input, validate: ["doe.com"])
 # => Success({:name=>"Jane", :email=>"jane@doe.com"})
 
@@ -98,28 +106,46 @@ save_user.call(input, validate: ["smith.com"])
 # => Failure("not allowed")
 ```
 
-### Working with a larger container
+### Subscribing to step notifications
 
-In practice, your container won’t be a trivial collection of generically named operations. You can keep your transaction step names simple by using the `with:` option to provide the identifiers for the operations within your container:
+As well as pattern matching on the final transaction result, you can subscribe to individual steps and trigger specific behaviour based on their success or failure:
 
 ```ruby
-save_user = CallSheet(container: large_whole_app_container) do
-  map :process, with: "attributes.user"
-  try :validate, with: "validations.user"
-  tee :persist, with: "persistance.commands.update_user"
+NOTIFICATIONS = []
+
+module UserPersistListener
+  extend self
+
+  def persist_success(user)
+    NOTIFICATIONS << "#{user[:email]} persisted"
+  end
+
+  def persist_failure(user)
+    NOTIFICATIONS << "#{user[:email]} failed to persist"
+  end
 end
+
+
+input = {"name" => "Jane", "email" => "jane@doe.com"}
+
+save_user.subscribe(persist: UserPersistListener)
+save_user.call(input, validate: ["doe.com"])
+
+NOTIFICATIONS
+# => ["jane@doe.com persisted"]
 ```
 
-### Using inline procs
+This pub/sub mechanism is provided by the [Wisper](https://github.com/krisleech/wisper) gem. You can subscribe to specific steps using the `#subscribe(step_name: listener)` API, or subscribe to all steps via `#subscribe(listener)`.
+
+### Working with a larger container
 
-You can inject small pieces of custom behavior into your transaction using inline procs and a `raw` step. This can be helpful if you want to provide a special failure case based on the output of a previous step.
+In practice, your container won’t be a trivial collection of generically named operations. You can keep your transaction step names simple by using the `with:` option to provide the identifiers for the operations within your container:
 
 ```ruby
-update_user = CallSheet(container: container) do
-  map :find_user
-  raw :check_locked, with: -> input { input.locked? ? Failure("Cannot update locked user") : Success(input) }
-  try :validate
-  tee :persist
+save_user = CallSheet(container: large_whole_app_container) do
+  map :process, with: "attributes.user"
+  try :validate, with: "validations.user", catch: ValidationFailure
+  tee :persist, with: "persistance.commands.update_user"
 end
 ```
 

data/lib/call_sheet.rb

@@ -2,7 +2,52 @@ require "deterministic"
 require "call_sheet/version"
 require "call_sheet/dsl"
 
-# rubocop:disable Style/MethodName
+# Define a business transaction.
+#
+# A business transaction is a series of callable operation objects that
+# receive input and produce an output.
+#
+# The operations should be addressable via `#[]` in a container object that
+# you pass when creating the transaction. The operations must respond to
+# `#call(*args, input)`.
+#
+# Each operation will be called in the order it was specified in your
+# transaction, with its output is passed as the intput to the next operation.
+# Operations will only be called if the previous step was a success.
+#
+# A step is successful when it returns a `Success` object (from the
+# [Deterministic](deterministic) gem) wrapping its output value. A step is a
+# failure when it returns a `Failure` object.  If your operations already
+# return a `Success` or `Failure`, they can be added to your operation as
+# plain `step` or `raw` steps.
+#
+# If your operations don't already return `Success` or `Failure`, then they
+# can be added to the transaction with the following steps:
+#
+# * `map` --- wrap the output of the operation in a `Success`
+# * `try` --- wrap the output of the operation in a `Success`, unless a certain
+#   exception is raised, which will be caught and returned as a `Failure`.
+# * `tee` --- ignore the output of the operation and pass through its original
+#   input as a `Sucess`.
+#
+# [deterministic]: https://github.com/pzol/deterministic
+#
+# @example
+#   container = {do_first: some_obj, do_second: some_obj}
+#
+#   my_transaction = CallSheet(container: container) do
+#     step :do_first
+#     step :do_second
+#   end
+#
+#   my_transaction.call(some_input)
+#
+# @param [Hash] options the options hash
+# @option options [#[]] :container the operations container
+#
+# @return [CallSheet::Transaction] the transaction object
+#
+# @api public
 def CallSheet(options = {}, &block)
   CallSheet::DSL.new(options, &block).call
 end

data/lib/call_sheet/dsl.rb

@@ -1,8 +1,8 @@
 require "call_sheet/step"
 require "call_sheet/step_adapters"
 require "call_sheet/step_adapters/base"
-require "call_sheet/step_adapters/raw"
 require "call_sheet/step_adapters/map"
+require "call_sheet/step_adapters/raw"
 require "call_sheet/step_adapters/tee"
 require "call_sheet/step_adapters/try"
 require "call_sheet/transaction"
@@ -11,10 +11,16 @@ module CallSheet
   class DSL
     include Deterministic::Prelude::Result
 
-    attr_reader :options # are we actually doing anything with this besides passing the container?
+    # @api private
+    attr_reader :options
+
+    # @api private
     attr_reader :container
+
+    # @api private
     attr_reader :steps
 
+    # @api private
     def initialize(options, &block)
       @options = options
       @container = options.fetch(:container)
@@ -25,11 +31,12 @@ module CallSheet
 
     StepAdapters.each do |adapter_name, adapter_class|
       define_method adapter_name do |step_name, options = {}|
-        operation = options[:with].is_a?(Proc) ? options[:with] : container[options.fetch(:with, step_name)]
+        operation = container[options.fetch(:with, step_name)]
         steps << Step.new(step_name, adapter_class.new(operation, options))
       end
     end
 
+    # @api private
     def call
       Transaction.new(steps)
     end

data/lib/call_sheet/step.rb

@@ -1,8 +1,11 @@
+require "wisper"
 require "call_sheet/step_failure"
 
 module CallSheet
+  # @api private
   class Step
     include Deterministic::Prelude::Result
+    include Wisper::Publisher
 
     attr_reader :step_name
     attr_reader :operation
@@ -19,8 +22,16 @@ module CallSheet
     end
 
     def call(input)
-      result = operation.call(*(call_args << input))
-      result.map_err { |v| Failure(StepFailure.new(step_name, v)) }
+      args = (call_args << input)
+      result = operation.call(*args)
+
+      result.map { |value|
+        broadcast :"#{step_name}_success", value
+        Success(value)
+      }.map_err { |value|
+        broadcast :"#{step_name}_failure", *args, value
+        Failure(StepFailure.new(step_name, value))
+      }
     end
 
     def arity

data/lib/call_sheet/step_adapters.rb

@@ -11,6 +11,12 @@ module CallSheet
       extend Forwardable
       def_delegators :registry, :[], :each
 
+      # Register a step adapter.
+      #
+      # @param [Symbol] name the name to expose for adding steps to a transaction
+      # @param klass the step adapter class
+      #
+      # @api public
       def register(name, klass)
         registry[name.to_sym] = klass
       end

data/lib/call_sheet/step_adapters/base.rb

@@ -1,5 +1,6 @@
 module CallSheet
   module StepAdapters
+    # @api private
     class Base
       include Deterministic::Prelude::Result
 

data/lib/call_sheet/step_adapters/map.rb

@@ -1,5 +1,6 @@
 module CallSheet
   module StepAdapters
+    # @api private
     class Map < Base
       def call(*args, input)
         Success(operation.call(input, *args))

data/lib/call_sheet/step_adapters/raw.rb

@@ -1,11 +1,13 @@
 module CallSheet
   module StepAdapters
+    # @api private
     class Raw < Base
       def call(*args, input)
         operation.call(input, *args)
       end
     end
 
+    register :step, Raw
     register :raw, Raw
   end
 end

data/lib/call_sheet/step_adapters/tee.rb

@@ -1,5 +1,6 @@
 module CallSheet
   module StepAdapters
+    # @api private
     class Tee < Base
       def call(*args, input)
         operation.call(*args, input)

data/lib/call_sheet/step_adapters/try.rb

@@ -1,8 +1,16 @@
 module CallSheet
   module StepAdapters
+    # @api private
     class Try < Base
+      def initialize(*)
+        super
+        raise ArgumentError, "+try+ steps require one or more exception classes provided via +catch:+" unless options[:catch]
+      end
+
       def call(*args, input)
-        try! { operation.call(*args, input) }
+        Success(operation.call(*args, input))
+      rescue *Array(options[:catch]) => e
+        Failure(e)
       end
     end
 

data/lib/call_sheet/transaction.rb

@@ -2,13 +2,16 @@ module CallSheet
   class Transaction
     include Deterministic::Prelude::Result
 
+    # @api private
     attr_reader :steps
     private :steps
 
+    # @api private
     def initialize(steps)
       @steps = steps
     end
 
+    # @api public
     def call(input, options = {})
       assert_valid_options(options)
       assert_options_satisfy_step_arity(options)
@@ -18,6 +21,21 @@ module CallSheet
     end
     alias_method :[], :call
 
+    # @api public
+    def subscribe(listeners)
+      if listeners.is_a?(Hash)
+        listeners.each do |step_name, listener|
+          steps.detect { |step| step.step_name == step_name }.subscribe(listener)
+        end
+      else
+        steps.each do |step|
+          step.subscribe(listeners)
+        end
+      end
+
+      self
+    end
+
     private
 
     def assert_valid_options(options)

data/lib/call_sheet/version.rb

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

data/spec/examples.txt

@@ -1,17 +1,21 @@
 example_id                                               | status | run_time        |
 -------------------------------------------------------- | ------ | --------------- |
-./spec/integration/call_sheet_spec.rb[1:1:1]             | passed | 0.00285 seconds |
-./spec/integration/call_sheet_spec.rb[1:1:2]             | passed | 0.0025 seconds  |
-./spec/integration/call_sheet_spec.rb[1:1:3]             | passed | 0.00373 seconds |
-./spec/integration/call_sheet_spec.rb[1:1:4]             | passed | 0.00084 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:1]             | passed | 0.00061 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:2]             | passed | 0.00084 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:3]             | passed | 0.00176 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:4]             | passed | 0.00068 seconds |
-./spec/integration/call_sheet_spec.rb[1:2:5]             | passed | 0.00063 seconds |
-./spec/integration/inline_procs_spec.rb[1:1:1]           | passed | 0.0004 seconds  |
-./spec/integration/inline_procs_spec.rb[1:2:1]           | passed | 0.00042 seconds |
-./spec/integration/inline_procs_spec.rb[1:2:2]           | passed | 0.00045 seconds |
-./spec/integration/passing_step_arguments_spec.rb[1:1:1] | passed | 0.00065 seconds |
-./spec/integration/passing_step_arguments_spec.rb[1:2:1] | passed | 0.00216 seconds |
-./spec/integration/passing_step_arguments_spec.rb[1:3:1] | passed | 0.00023 seconds |
+./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 |

data/spec/integration/call_sheet_spec.rb

@@ -1,8 +1,11 @@
 RSpec.describe CallSheet do
+  include Deterministic::Prelude::Result
+
   let(:call_sheet) {
     CallSheet(container: container) do
       map :process
-      try :validate
+      raw :verify
+      try :validate, catch: Test::NotValidError
       tee :persist
     end
   }
@@ -10,6 +13,7 @@ RSpec.describe CallSheet do
   let(:container) {
     {
       process:  -> input { {name: input["name"], email: input["email"]} },
+      verify:   -> input { Success(input) },
       validate: -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input },
       persist:  -> input { Test::DB << input and true }
     }
@@ -83,4 +87,26 @@ RSpec.describe CallSheet do
       expect(match).to eq "Matched validate failure"
     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") }
+    end
+
+    it "does not run subsequent operations" do
+      run_call_sheet
+      expect(Test::DB).to be_empty
+    end
+
+    it "returns a failure" do
+      expect(run_call_sheet).to be_failure
+    end
+
+    it "returns the failing value from the operation" do
+      expect(run_call_sheet.value).to eq "raw failure"
+    end
+  end
 end

data/spec/integration/passing_step_arguments_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe "Passing additional arguments to step operations" do
   let(:call_sheet) {
     CallSheet(container: container) do
       map :process
-      try :validate
+      try :validate, catch: Test::NotValidError
       tee :persist
     end
   }

data/spec/integration/publishing_step_events_spec.rb

@@ -0,0 +1,67 @@
+RSpec.describe "publishing step events" do
+  include Deterministic::Prelude::Result
+
+  let(:call_sheet) {
+    CallSheet(container: container) do
+      map :process
+      raw :verify
+      tee :persist
+    end
+  }
+
+  let(:container) {
+    {
+      process:  -> input { {name: input["name"]} },
+      verify:   -> input { input[:name].to_s != "" ? Success(input) : Failure("no name") },
+      persist:  -> input { Test::DB << input and true }
+    }
+  }
+
+  let(:subscriber) { spy(:subscriber) }
+
+  before do
+    Test::DB = []
+  end
+
+  context "subscribing to all step events" do
+    before do
+      call_sheet.subscribe(subscriber)
+    end
+
+    specify "subscriber receives success events" do
+      call_sheet.call("name" => "Jane")
+
+      expect(subscriber).to have_received(:process_success).with(name: "Jane")
+      expect(subscriber).to have_received(:verify_success).with(name: "Jane")
+      expect(subscriber).to have_received(:persist_success).with(name: "Jane")
+    end
+
+    specify "subsriber receives success events for passing steps, a failure event for the failing step, and no subsequent events" do
+      call_sheet.call("name" => "")
+
+      expect(subscriber).to have_received(:process_success).with(name: "")
+      expect(subscriber).to have_received(:verify_failure).with({name: ""}, "no name")
+      expect(subscriber).not_to have_received(:persist_success)
+    end
+  end
+
+  context "subscribing to particular step events" do
+    before do
+      call_sheet.subscribe(verify: subscriber)
+    end
+
+    specify "subscriber receives success event for the specified step" do
+      call_sheet.call("name" => "Jane")
+
+      expect(subscriber).to have_received(:verify_success).with(name: "Jane")
+      expect(subscriber).not_to have_received(:process_success)
+      expect(subscriber).not_to have_received(:persist_success)
+    end
+
+    specify "subscriber receives failure event for the specified step" do
+      call_sheet.call("name" => "")
+
+      expect(subscriber).to have_received(:verify_failure).with({name: ""}, "no name")
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: call_sheet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tim Riley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2015-11-02 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: wisper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  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'
 description: 
 email:
 - tim@icelab.com.au
@@ -120,8 +148,8 @@ files:
 - lib/call_sheet/version.rb
 - spec/examples.txt
 - spec/integration/call_sheet_spec.rb
-- spec/integration/inline_procs_spec.rb
 - spec/integration/passing_step_arguments_spec.rb
+- spec/integration/publishing_step_events_spec.rb
 - spec/spec_helper.rb
 - spec/support/test_module_constants.rb
 homepage: https://github.com/icelab/call_sheet
@@ -149,3 +177,4 @@ signing_key:
 specification_version: 4
 summary: Business Transaction Flow DSL
 test_files: []
+has_rdoc: 

data/spec/integration/inline_procs_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe "using inline procs with raw steps" do
-  let(:call_sheet) {
-    CallSheet(container: container) do
-      map :process
-      raw :validate, with: -> input { input[:email].nil? ? Failure("email required") : Success(input) }
-    end
-  }
-
-  let(:container) { {process:  -> input { {name: input["name"], email: input["email"]} }} }
-
-  before do
-    Test::NotValidError = Class.new(StandardError)
-    Test::DB = []
-  end
-
-  context "inline step returns Success" do
-    it "calls all the operations" do
-      input = {"name" => "Jane", "email" => "jane@doe.com"}
-      expect(call_sheet.call(input)).to be_success
-    end
-  end
-
-  context "inline step returns Failure" do
-    let(:input) { {"name" => "Jane"} }
-
-    it "stops running the step operations and returns the failure" do
-      expect(call_sheet.call(input)).to be_failure
-    end
-
-    it "supports pattern matching on the failed step name" do
-      match = call_sheet.call(input).match do
-        Success(_) {}
-        Failure(f, where { f == :validate }) { "Matched validate failure" }
-        Failure(_) {}
-      end
-
-      expect(match).to eq "Matched validate failure"
-    end
-  end
-end