call_sheet 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3c20bf00a8dd774a7a7a9110001576dfae39667
+  data.tar.gz: acca5a6e3f2575b54b13c7d3744f466e471ff753
+SHA512:
+  metadata.gz: 5442457894d06089e52de190a7ccd62b504e71d7cd66ba4764ee01134c48c2e5cc923b534fbc3caff3d41f3f2368d5a89af373e44393a2f933a6504392ae271b
+  data.tar.gz: 05acf6f917f9fbc1102c12bfb54e1a60aa0089d8e810a2a70ddec22d44f31c43b7d4368997fb3180a47fa7312013395606191642ae06888fda808bbde3955583

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Gem dependencies are specified in call_sheet.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,60 @@
+PATH
+  remote: .
+  specs:
+    call_sheet (0.1.0)
+      deterministic (>= 0.15.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.1.0)
+    astrolabe (1.3.1)
+      parser (~> 2.2)
+    deterministic (0.15.3)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (1.8.3)
+    parser (2.2.3.0)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.1.1)
+    rainbow (2.0.0)
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    rubocop (0.34.2)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.2.5, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    ruby-progressbar (1.7.5)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  call_sheet!
+  rake (~> 10.4.2)
+  rspec (~> 3.3.0)
+  rubocop (~> 0.34.2)
+  simplecov (~> 0.10.0)
+
+BUNDLED WITH
+   1.10.6

data/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2015 [Icelab](http://icelab.com.au/).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,150 @@
+# Call Sheet
+
+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):
+
+* A business transaction is a series of operations where each can fail and stop processing.
+* A business transaction resolves its dependencies using an external container object and it doesn’t know any details about the individual operation objects except their identifiers.
+* A business transaction can describe its steps on an abstract level without being coupled to any details about how individual operations work.
+* A business transaction doesn’t have any state.
+* Each operation shouldn’t accumulate state, instead it should receive an input and return an output without causing any side-effects.
+* The only interface of a an operation is `#call(input)`.
+* Each operation provides a meaningful functionality and can be reused.
+* Errors in any operation can be easily caught and handled as part of the normal application flow.
+
+## Why?
+
+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.
+
+## Usage
+
+All you need to use Call Sheet is a container of operations that respond to `#call(input)`. The operations will be resolved from the container via `#[]`. The examples below use a plain Hash for simplicity, but for a larger app you may like to consider something like [dry-container](https://github.com/dryrb/dry-container).
+
+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` – 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 },
+  persist:  -> input { DB << input and true }
+}
+
+save_user = CallSheet(container: container) do
+  map :process
+  try :validate
+  tee :persist
+end
+
+save_user.call("name" => "Jane", "email" => "jane@doe.com")
+# => Success({: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):
+
+```ruby
+save_user.call(name: "Jane", email: "jane@doe.com").match do
+  Success(s) 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."
+  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 effectively means that transactions can 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 },
+  persist:  -> input { DB << input and true }
+}
+
+save_user = CallSheet(container: container) do
+  map :process
+  try :validate
+  tee :persist
+end
+
+input = {name: "Jane", email: "jane@doe.com"}
+save_user.call(input, validate: ["doe.com"])
+# => Success({:name=>"Jane", :email=>"jane@doe.com"})
+
+save_user.call(input, validate: ["smith.com"])
+# => Failure("not allowed")
+```
+
+### Working with a larger container
+
+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
+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"
+end
+```
+
+### Using inline procs
+
+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.
+
+```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
+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.
+
+## Installation
+
+Add this line to your application’s `Gemfile`:
+
+```ruby
+gem "call_sheet"
+```
+
+Run `bundle` to install the gem.
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](http://github.com/icelab/call_sheet).
+
+## Credits
+
+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!
+
+## License
+
+Copyright © 2015 [Icelab](http://icelab.com.au/). Call Sheet is free software, and may be redistributed under the terms specified in the [license](LICENSE.md).

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+task default: :ci
+
+desc "Run the test suite"
+task ci: %w(rubocop spec)

data/lib/call_sheet/dsl.rb

@@ -0,0 +1,37 @@
+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/tee"
+require "call_sheet/step_adapters/try"
+require "call_sheet/transaction"
+
+module CallSheet
+  class DSL
+    include Deterministic::Prelude::Result
+
+    attr_reader :options # are we actually doing anything with this besides passing the container?
+    attr_reader :container
+    attr_reader :steps
+
+    def initialize(options, &block)
+      @options = options
+      @container = options.fetch(:container)
+      @steps = []
+
+      instance_exec(&block)
+    end
+
+    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)]
+        steps << Step.new(step_name, adapter_class.new(operation, options))
+      end
+    end
+
+    def call
+      Transaction.new(steps)
+    end
+  end
+end

data/lib/call_sheet/step.rb

@@ -0,0 +1,30 @@
+require "call_sheet/step_failure"
+
+module CallSheet
+  class Step
+    include Deterministic::Prelude::Result
+
+    attr_reader :step_name
+    attr_reader :operation
+    attr_reader :call_args
+
+    def initialize(step_name, operation, call_args = [])
+      @step_name = step_name
+      @operation = operation
+      @call_args = call_args
+    end
+
+    def with_call_args(*call_args)
+      self.class.new(step_name, operation, call_args)
+    end
+
+    def call(input)
+      result = operation.call(*(call_args << input))
+      result.map_err { |v| Failure(StepFailure.new(step_name, v)) }
+    end
+
+    def arity
+      operation.arity
+    end
+  end
+end

data/lib/call_sheet/step_adapters/base.rb

@@ -0,0 +1,19 @@
+module CallSheet
+  module StepAdapters
+    class Base
+      include Deterministic::Prelude::Result
+
+      attr_reader :operation
+      attr_reader :options
+
+      def initialize(operation, options)
+        @operation = operation
+        @options = options
+      end
+
+      def arity
+        operation.is_a?(Proc) ? operation.arity : operation.method(:call).arity
+      end
+    end
+  end
+end

data/lib/call_sheet/step_adapters/map.rb

@@ -0,0 +1,11 @@
+module CallSheet
+  module StepAdapters
+    class Map < Base
+      def call(*args, input)
+        Success(operation.call(input, *args))
+      end
+    end
+
+    register :map, Map
+  end
+end

data/lib/call_sheet/step_adapters/raw.rb

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

data/lib/call_sheet/step_adapters/tee.rb

@@ -0,0 +1,12 @@
+module CallSheet
+  module StepAdapters
+    class Tee < Base
+      def call(*args, input)
+        operation.call(*args, input)
+        Success(input)
+      end
+    end
+
+    register :tee, Tee
+  end
+end

data/lib/call_sheet/step_adapters/try.rb

@@ -0,0 +1,11 @@
+module CallSheet
+  module StepAdapters
+    class Try < Base
+      def call(*args, input)
+        try! { operation.call(*args, input) }
+      end
+    end
+
+    register :try, Try
+  end
+end

data/lib/call_sheet/step_adapters.rb

@@ -0,0 +1,19 @@
+require "forwardable"
+
+module CallSheet
+  module StepAdapters
+    @registry = {}
+
+    class << self
+      attr_reader :registry
+      private :registry
+
+      extend Forwardable
+      def_delegators :registry, :[], :each
+
+      def register(name, klass)
+        registry[name.to_sym] = klass
+      end
+    end
+  end
+end

data/lib/call_sheet/step_failure.rb

@@ -0,0 +1,16 @@
+module CallSheet
+  class StepFailure < BasicObject
+    def initialize(step_name, object)
+      @__step_name = step_name
+      @__object = object
+    end
+
+    def method_missing(name, *args, &block)
+      @__object.send(name, *args, &block)
+    end
+
+    def ==(other)
+      @__step_name == other || @__object == other
+    end
+  end
+end

data/lib/call_sheet/transaction.rb

@@ -0,0 +1,52 @@
+module CallSheet
+  class Transaction
+    include Deterministic::Prelude::Result
+
+    attr_reader :steps
+    private :steps
+
+    def initialize(steps)
+      @steps = steps
+    end
+
+    def call(input, options = {})
+      assert_valid_options(options)
+      assert_options_satisfy_step_arity(options)
+
+      steps = steps_with_options_applied(options)
+      steps.inject(Success(input), :>>)
+    end
+    alias_method :[], :call
+
+    private
+
+    def assert_valid_options(options)
+      options.each_key do |step_name|
+        unless steps.map(&:step_name).include?(step_name)
+          raise ArgumentError, "+#{step_name}+ is not a valid step name"
+        end
+      end
+    end
+
+    def assert_options_satisfy_step_arity(options)
+      steps.each do |step|
+        args_required = step.arity >= 0 ? step.arity : ~step.arity
+        args_supplied = options.fetch(step.step_name, []).length + 1 # add 1 for main `input`
+
+        if args_required > args_supplied
+          raise ArgumentError, "not enough options for step +#{step.step_name}+"
+        end
+      end
+    end
+
+    def steps_with_options_applied(options)
+      steps.map { |step|
+        if (args = options[step.step_name])
+          step.with_call_args(*args)
+        else
+          step
+        end
+      }
+    end
+  end
+end

data/lib/call_sheet/version.rb

@@ -0,0 +1,3 @@
+module CallSheet
+  VERSION = "0.1.0".freeze
+end

data/lib/call_sheet.rb

@@ -0,0 +1,8 @@
+require "deterministic"
+require "call_sheet/version"
+require "call_sheet/dsl"
+
+# rubocop:disable Style/MethodName
+def CallSheet(options = {}, &block)
+  CallSheet::DSL.new(options, &block).call
+end

data/spec/examples.txt

@@ -0,0 +1,17 @@
+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 |

data/spec/integration/call_sheet_spec.rb

@@ -0,0 +1,86 @@
+RSpec.describe CallSheet do
+  let(:call_sheet) {
+    CallSheet(container: container) do
+      map :process
+      try :validate
+      tee :persist
+    end
+  }
+
+  let(:container) {
+    {
+      process:  -> input { {name: input["name"], email: input["email"]} },
+      validate: -> input { input[:email].nil? ? raise(Test::NotValidError, "email required") : input },
+      persist:  -> input { Test::DB << input and true }
+    }
+  }
+
+  before do
+    Test::NotValidError = Class.new(StandardError)
+    Test::DB = []
+  end
+
+  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
+      expect(Test::DB).to include(name: "Jane", email: "jane@doe.com")
+    end
+
+    it "returns a success" do
+      expect(run_call_sheet).to be_success
+    end
+
+    it "wraps the result of the final operation" do
+      expect(run_call_sheet.value).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(_) {}
+      end
+
+      expect(match).to eq "Matched on success"
+    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
+      expect(Test::DB).to be_empty
+    end
+
+    it "returns a failure" do
+      expect(run_call_sheet).to be_failure
+    end
+
+    it "wraps the result of the failing operation" do
+      expect(run_call_sheet.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" }
+      end
+
+      expect(match).to eq "Matched on failure"
+    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(_) {}
+      end
+
+      expect(match).to eq "Matched validate failure"
+    end
+  end
+end

data/spec/integration/inline_procs_spec.rb

@@ -0,0 +1,40 @@
+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

data/spec/integration/passing_step_arguments_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe "Passing additional arguments to step operations" do
+  let(:run_call_sheet) { call_sheet.call(input, step_options) }
+
+  let(:call_sheet) {
+    CallSheet(container: container) do
+      map :process
+      try :validate
+      tee :persist
+    end
+  }
+
+  let(:container) {
+    {
+      process:  -> input { {name: input["name"], email: input["email"]} },
+      validate: -> allowed, input { !input[:email].include?(allowed) ? raise(Test::NotValidError, "email not allowed") : input },
+      persist:  -> input { Test::DB << input and true }
+    }
+  }
+
+  let(:input) { {"name" => "Jane", "email" => "jane@doe.com"} }
+
+  before do
+    Test::NotValidError = Class.new(StandardError)
+    Test::DB = []
+  end
+
+  context "required arguments provided" do
+    let(:step_options) { {validate: ["doe.com"]} }
+
+    it "passes the arguments and calls the operations successfully" do
+      expect(run_call_sheet).to be_success
+    end
+  end
+
+  context "required arguments not provided" do
+    let(:step_options) { {} }
+
+    it "raises an ArgumentError" do
+      expect { run_call_sheet }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "spurious arguments provided" do
+    let(:step_options) { {validate: ["doe.com"], bogus: ["not matching any step"]} }
+
+    it "raises an ArgumentError" do
+      expect { run_call_sheet }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+require "simplecov"
+SimpleCov.start
+SimpleCov.minimum_coverage 100
+
+require "call_sheet"
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each do |f| require f end
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended.
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/support/test_module_constants.rb

@@ -0,0 +1,11 @@
+module Test
+  def self.remove_constants
+    constants.each(&method(:remove_const))
+  end
+end
+
+RSpec.configure do |config|
+  config.after do
+    Test.remove_constants
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: call_sheet
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tim Riley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: deterministic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.34.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.34.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+description: 
+email:
+- tim@icelab.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/call_sheet.rb
+- lib/call_sheet/dsl.rb
+- lib/call_sheet/step.rb
+- lib/call_sheet/step_adapters.rb
+- lib/call_sheet/step_adapters/base.rb
+- lib/call_sheet/step_adapters/map.rb
+- lib/call_sheet/step_adapters/raw.rb
+- lib/call_sheet/step_adapters/tee.rb
+- lib/call_sheet/step_adapters/try.rb
+- lib/call_sheet/step_failure.rb
+- lib/call_sheet/transaction.rb
+- 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/spec_helper.rb
+- spec/support/test_module_constants.rb
+homepage: https://github.com/icelab/call_sheet
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Business Transaction Flow DSL
+test_files: []