all_systems 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 275aae9e309c5a4d6f18fe23d05d4bb7866da786
+  data.tar.gz: ef9a2045793ed0faeeab07c3cf17c9ce7696cf66
+SHA512:
+  metadata.gz: 974da988fad1bb04fb61d9a6a014504aa6f2826472b54ee6bbbbfe022e63b44edb03b4627a16bea5e61a2c4f6901a0052615a1b8b0955f056cef0ce56813fccf
+  data.tar.gz: 4bebef0a58c8863eff9908e638aa7257aafe9b6041afe0f91d835337fff681aa3ff5f3a0b95c65affb3a83e2893f331fc990be02469f6beeb7be23994b91ba7e

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in usecase.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Peter Saxton
+
+MIT License
+
+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,240 @@
+# AllSystems
+
+**Simple Ruby usecases/interactors/service-object to encapsulate business logic**
+
+### Well what is it?
+The three terms above are all used at various times to describe the use of a dedicated object separate to the delivery mechanism (read ApplicationController) to coordinate the calls on several domain objects (such as user models). Service object is sometimes used to describe the encapsulation of an external service that you system uses. E.g. you might have a Stripe service object, so I do not use that term. Also usecase seams to make more sense on a non technical level, so the Login usecase is what the customer does. It is achieved using the Login interactor, the Ruby object. A good starting point is this [article](https://netguru.co/blog/service-objects-in-rails-will-help) as well as the further reading listed. This [article](http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/) helps explain there place in the landscape of objeccts beyond MVC  
+
+### Overview
+An interactor encapsulates a specific business interaction, often a user interaction, such as `LogIn` or `CreatePost`. The business logic is declared by defining a `go!` method. All possible outcomes are stated by defining a outcomes method. Each instance of the interactor executes the `go!` method once only to produce a single result. The result consists of an outcome and optional output. The outcome is a single :symbol to name the result. The output an array of zero or more values.
+
+Results are reported within the `go!` method of the interactor.
+
+```rb
+Class WelcomeJohn < AllSystems::Interactor
+  def options
+    # Will always succeed
+    [:success]
+  end
+
+  def go!
+    new_user = {:name => 'John Smith'}
+    report :success, new_user
+  end
+end
+
+welcome = WelcomeJohn.new
+welcome.result == [:success, new_user]
+welcome.outcome == :success
+welcome.output = [new_user]
+```
+
+The interactor outcome can then be used to decide response
+
+```rb
+welcome.on :success do |user|
+  puts "Hello #{user[:name]}"
+end
+```
+
+### why?
+
+Such a simple class that a library is almost not needed. I have found its value not in reduced work when making my specific interactors but in reduced testing for those interactor. Don't need to test things like single execution and predicate methods on specific interactors
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'usecase'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install usecase
+
+## Usage
+
+### Example 1 *Flipping a coin*
+
+```rb
+Class FlipCoin < AllSystems::Interactor
+  def outcomes
+    [:heads, :tails]
+  end
+
+  def go!
+    report_tails if [true, false].sample
+    report_heads
+  end
+end
+
+filp = FlipCoin.new
+
+flip.result
+# => [:heads]
+
+filp.outcome
+# => :heads
+
+flip.output?
+# => []
+
+flip.heads?
+# => true
+
+flip.tails?
+# => false
+
+flip.other?
+# raise UnknownMethodError
+
+flip.heads do
+  puts "Hooray"
+end
+```
+
+Example 2
+
+```rb
+class Customer
+  # One of several customer actions
+  class PasswordReset < AllSystems::Interactor
+    def initialize(context, id, params)
+      @context = context
+      @id = id
+      @params = params
+    end
+
+    attr_reader :context, :id, :params
+
+    def outcomes
+      [:succeded, :account_unknown, :user_unknown, :not_permitted, :invalid_details]
+    end
+
+    def go!
+      report_account_unknown id, unless account
+      report_user_unknown if authority.guest?
+      report_not_permitted unless authority == account || authority.admin?
+      report_invalid_details form unless form.valid?
+      account.password = form.password
+      account.save
+      send_email
+      report_succeeded account
+    end
+
+    def send_email
+      context.customer_mailer.password_reset
+    end
+
+    def form
+      @form ||= Form.new params
+    end
+
+    def account
+      @account ||= Customers[id]
+    end
+
+    def authority
+      @authority ||= context.current_user
+    end
+
+  end
+end
+
+# use in controller
+class CustomerController
+  def password_reset(id)
+    reset = Customer::Password.new(self, id, request.POST['customer'])
+
+    reset.succeeded do |customer| # 204: No Content
+      flash['success'] = 'Password update successful'
+      redirect customer_page(customer), 204
+    end
+
+    reset.unknown_account do |id| # 404: Not found
+      flash['error'] = "account: #{id} not found"
+      redirect customers_page, 404
+    end
+
+    reset.unknow_user do # 401: Unauthenticated
+      flash['error'] = 'Login required'
+      redirect login_page, 401
+    end
+
+    reset.not_permitted do # 403: Forbidden
+      flash['error'] = 'Not authorized'
+      redirect customer_page, 403
+    end
+
+    reset.invalid_details do |form| # 400: bad request
+      status = 400
+      render :new, :locals => {:form => form}
+    end
+  end
+end
+```
+establish, deduce, ascertain, settle, evaluate
+
+## Docs
+
+**#go!** `interactor.go! => raise AbstractMethodError`
+
+Abstract method that will always raise an error. Should be over written in for specific interactors
+
+**#outcomes** `interactor.outcomes => []`
+
+Should be over written in for specific interactors to return list of possible outcomes
+
+**#name** `interactor.name => class_name`
+
+Returns the name of the class or Anonymous if class not set to constant
+
+**(private)#report** `interactor.report(outcome, *output) => terminate with result`
+
+Use within the interactor to report that an outcome state has been reached with optional output. Terminates execution of go!
+
+**#outcome** `interactor.outcome => symbol`
+
+Returns the outcome of goning the interactor
+
+**#outcome?(outcome)** `interactor.outcome?(outcome) => boolean`
+
+Does the outcome match the predicate outcome.
+
+**#output** `interactor.output => [*output]`
+
+Returns an array of output from goning the interactor
+
+**#on(:outcome)** `interactor.on(:outcome, &block) => block return value`
+
+If the interactors out come was the same as given here then the output is yielded to the block, else no action.
+
+
+**#&lt;outcome&gt;?** `interactor.<outcome>? => boolean`
+
+Was the outcome equal to the method name, raises error if method name not one of possible outcomes
+
+**#&lt;outcome&gt;** `interactor.<outcome> &block => block_return_value`
+
+Yields output to block if outcome equal to method name, raises error if method name not one of possible outcomes
+
+**#report_&lt;outcome&gt;** `interactor.report_<outcome>(*output) => terminate with result`
+
+Use within the interactor to report that an outcome state has been reached with optional output. Terminates execution of go!
+
+
+## Upcoming
+8. actions on class passed to instance *possible to declare action before use*
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/usecase/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+test_tasks = Dir['test/*/'].map { |d| File.basename(d) }
+
+test_tasks.each do |folder|
+  Rake::TestTask.new("test:#{folder}") do |test|
+    test.pattern = "test/#{folder}/**/*_test.rb"
+    test.verbose = true
+  end
+end
+
+desc "Run application test suite"
+Rake::TestTask.new("test") do |test|
+  test.pattern = "test/**/*_test.rb"
+  test.verbose = true
+end

data/lib/all_systems.rb

@@ -0,0 +1,7 @@
+require "all_systems/version"
+require "all_systems/errors"
+require "all_systems/interactor"
+
+module AllSystems
+  # Your code goes here...
+end

data/lib/all_systems/errors.rb

@@ -0,0 +1,6 @@
+module AllSystems
+  AbstractMethodError = Class.new(StandardError)
+  NoOutcomeError = Class.new(StandardError)
+  UnknownOutcomeReportError = Class.new(StandardError)
+  UnknownOutcomeError = Class.new(StandardError)
+end

data/lib/all_systems/interactor.rb

@@ -0,0 +1,65 @@
+module AllSystems
+  class Interactor
+    def go!
+      raise AbstractMethodError, "please define #{__method__} for #{name} interactor"
+    end
+
+    def outcomes
+      # TODO throw error on abstract
+      []
+    end
+
+    def name
+      self.class.name || 'Anonymous'
+    end
+
+    def outcome
+      result.first
+    end
+
+    def outcome?(predicate)
+      raise UnknownOutcomeError unless outcomes.include? predicate
+      predicate == outcome
+    end
+
+    def output
+      result.drop 1
+    end
+
+    def on(conditional_outcome)
+      yield *output if outcome? conditional_outcome
+    end
+
+    private
+
+    def go
+      catch(:report) do
+        go!
+        raise NoOutcomeError, "#{name} concluded without reporting an outcome"
+      end
+    end
+
+    def result
+      @result ||= go
+    end
+
+    def report(*result)
+      raise UnknownOutcomeReportError unless outcomes.include? result.first
+      throw :report, result
+    end
+
+    def method_missing(method_symbol, *args, &block)
+      case method_symbol
+      when *outcomes
+        return on method_symbol, &block
+      when /report_([^?]+)/
+        report $1.to_sym, *args
+      when /([^?]+)\?/
+        super unless outcomes.include? $1.to_sym
+        outcome? $1.to_sym
+      else
+        super
+      end
+    end
+  end
+end

data/lib/all_systems/version.rb

@@ -0,0 +1,3 @@
+module AllSystems
+  VERSION = "0.2.0"
+end

data/test/interactor/error_test.rb

@@ -0,0 +1,35 @@
+require_relative '../test_config'
+
+module AllSystems
+  class InteractorErrorTest < MiniTest::Test
+    NoGoInteractor = Class.new(AllSystems::Interactor)
+
+    def test_raises_error_for_no_go_bang_method
+      interactor = NoGoInteractor.new
+      err = assert_raises AbstractMethodError do
+        interactor.outcome
+      end
+      assert_includes err.message, 'go!'
+    end
+
+    NoOutcomeInteractor = Class.new(AllSystems::Interactor) do
+      def go! ; end
+    end
+
+    def test_raises_error_if_go_does_not_report_outcome
+      interactor = NoOutcomeInteractor.new
+      err = assert_raises NoOutcomeError do
+        interactor.outcome
+      end
+      assert_includes err.message, 'NoOutcomeInteractor'
+    end
+
+    def test_raises_correct_error_for_unnamed_interactor
+      interactor = Class.new(AllSystems::Interactor).new
+      err = assert_raises AbstractMethodError do
+        interactor.outcome
+      end
+      assert_includes err.message, 'Anonymous interactor'
+    end
+  end
+end

data/test/interactor/invalid_outcomes_test.rb

@@ -0,0 +1,63 @@
+require_relative '../test_config'
+
+module AllSystems
+  class InteractorInvalidOutcomeTest < MiniTest::Test
+    def interactor_klass
+      @interactor_klass ||= Class.new(AllSystems::Interactor) do
+        def initialize(pass)
+          @pass = pass
+        end
+
+        def outcomes
+          [:success]
+        end
+
+        def go!
+          report :success if @pass
+          report :random
+        end
+      end
+    end
+
+    def test_cant_report_unknown_outcome
+      interactor = interactor_klass.new false
+      assert_raises AllSystems::UnknownOutcomeReportError do
+        interactor.outcome
+      end
+    end
+
+    def test_cant_check_unknown_outcome
+      interactor = interactor_klass.new true
+      assert_raises AllSystems::UnknownOutcomeError do
+        interactor.outcome? :random
+      end
+    end
+
+    def test_cant_define_callback_for_unknown_outcome
+      interactor = interactor_klass.new true
+      assert_raises AllSystems::UnknownOutcomeError do
+        interactor.on :random do
+          flunk
+        end
+      end
+    end
+
+    def test_no_method_error_for_invalid_outcomes
+      interactor = interactor_klass.new true
+      assert_raises NoMethodError do
+        interactor.random do
+          flunk
+        end
+      end
+    end
+
+    def test_no_method_error_for_invalid_outcome_queries
+      interactor = interactor_klass.new true
+      assert_raises NoMethodError do
+        interactor.random? do
+          flunk
+        end
+      end
+    end
+  end
+end

data/test/interactor/outcome_test.rb

@@ -0,0 +1,135 @@
+require_relative '../test_config'
+
+module AllSystems
+  class InteractorOutcomeTest < MiniTest::Test
+    def interactor_klass
+      @interactor_klass ||= Class.new(AllSystems::Interactor) do
+        def initialize(pass)
+          @pass = pass
+        end
+
+        def outcomes
+          [:success, :failure]
+        end
+
+        def go!
+          report :success if @pass
+          report :failure
+        end
+      end
+    end
+
+    def test_reports_outcome_as_success_for_pass
+      interactor = interactor_klass.new true
+      assert_equal :success, interactor.outcome
+    end
+
+    def test_reports_outcome_as_failure_for_no_pass
+      interactor = interactor_klass.new false
+      assert_equal :failure, interactor.outcome
+    end
+
+    def test_confirms_outcome_success_for_pass
+      interactor = interactor_klass.new true
+      assert_equal true, interactor.outcome?(:success)
+    end
+
+    def test_denys_outcome_success_for_no_pass
+      interactor = interactor_klass.new false
+      assert_equal false, interactor.outcome?(:success)
+    end
+
+    def test_success_query_is_true_for_pass
+      interactor = interactor_klass.new true
+      assert_equal true, interactor.success?
+    end
+
+    def test_success_query_is_false_for_no_pass
+      interactor = interactor_klass.new false
+      assert_equal false, interactor.success?
+    end
+
+    def test_failure_query_is_true_for_no_pass
+      interactor = interactor_klass.new false
+      assert_equal true, interactor.failure?
+    end
+
+    def test_failure_query_is_false_for_pass
+      interactor = interactor_klass.new true
+      assert_equal false, interactor.failure?
+    end
+
+    def test_calls_on_success_action_for_pass
+      interactor = interactor_klass.new true
+      mock = MiniTest::Mock.new
+      mock.expect :report, true
+      interactor.on :success do
+        mock.report
+      end
+      mock.verify
+    end
+
+    # TODO decide
+    # def test_calls_on_either_action_for_pass
+    #   interactor = interactor_klass.new true
+    #   mock = MiniTest::Mock.new
+    #   mock.expect :report, true
+    #   interactor.on :success, :failue do
+    #     mock.report
+    #   end
+    #   mock.verify
+    # end
+    #
+    # def test_calls_on_either_action_for_no_pass
+    #   interactor = interactor_klass.new false
+    #   mock = MiniTest::Mock.new
+    #   mock.expect :report, true
+    #   interactor.on :success, :failure do
+    #     mock.report
+    #   end
+    #   mock.verify
+    # end
+
+    def test_doesnt_call_on_success_action_for_no_pass
+      interactor = interactor_klass.new false
+      interactor.on :success do
+        flunk 'Should not process'
+      end
+    end
+
+    def test_calls_success_action_for_pass
+      interactor = interactor_klass.new true
+      mock = MiniTest::Mock.new
+      mock.expect :report, true
+      interactor.success do
+        mock.report
+      end
+      mock.verify
+    end
+
+    def test_doesnt_call_success_for_no_pass
+      interactor = interactor_klass.new false
+      interactor.success do
+        flunk 'Should not be a success'
+      end
+    end
+
+    def test_calls_failure_action_for_no_pass
+      interactor = interactor_klass.new false
+      mock = MiniTest::Mock.new
+      mock.expect :report, true
+      interactor.failure do
+        mock.report
+      end
+      mock.verify
+    end
+
+    def test_doesnt_call_failure_for_pass
+      interactor = interactor_klass.new true
+      interactor.failure do
+        flunk 'Should not be a failure'
+      end
+    end
+  end
+
+end

data/test/interactor/output_test.rb

@@ -0,0 +1,80 @@
+require_relative '../test_config'
+
+module AllSystems
+  class InteractorOutputTest < MiniTest::Test
+    def interactor_klass
+      @interactor_klass ||= Class.new(AllSystems::Interactor) do
+        def initialize(value)
+          @value = value
+        end
+
+        def outcomes
+          [:none, :one, :two, :unique]
+        end
+
+        def go!
+          case @value
+          when 0
+            report :none
+          when 1
+            report :one, 1
+          when 2
+            report :two, 1, 2
+          when :unique
+            report :unique, Class.new
+          end
+        end
+      end
+    end
+
+    def test_empty_out_put_array_when_none_given
+      interactor = interactor_klass.new 0
+      assert_equal [], interactor.output
+    end
+
+    def test_callback_recives_no_output
+      interactor = interactor_klass.new 0
+      mock = MiniTest::Mock.new
+      mock.expect :report, true, []
+      interactor.none do |*args|
+        mock.report *args
+      end
+      mock.verify
+    end
+
+    def test_single_item_output
+      interactor = interactor_klass.new 1
+      assert_equal [1], interactor.output
+    end
+
+    def test_callback_recives_single_output
+      interactor = interactor_klass.new 1
+      mock = MiniTest::Mock.new
+      mock.expect :report, true, [1]
+      interactor.one do |*args|
+        mock.report *args
+      end
+      mock.verify
+    end
+
+    def test_two_item_output
+      interactor = interactor_klass.new 2
+      assert_equal [1, 2], interactor.output
+    end
+
+    def test_callback_recives_double_output
+      interactor = interactor_klass.new 2
+      mock = MiniTest::Mock.new
+      mock.expect :report, true, [1, 2]
+      interactor.two do |*args|
+        mock.report *args
+      end
+      mock.verify
+    end
+
+    def test_go_is_only_executed_once
+      interactor = interactor_klass.new :unique
+      assert_equal interactor.output.first, interactor.output.first
+    end
+  end
+end

data/test/interactor/report_helper_test.rb

@@ -0,0 +1,64 @@
+require_relative '../test_config'
+
+module AllSystems
+  class InteractorReportHelperTest < MiniTest::Test
+    def interactor_klass
+      @interactor_klass ||= Class.new(AllSystems::Interactor) do
+        def initialize(pass)
+          @pass = pass
+        end
+
+        def outcomes
+          [:success, :failure]
+        end
+
+        def go!
+          report_success :item if @pass
+          report_failure
+        end
+      end
+    end
+
+    def test_reports_outcome_as_success_for_pass
+      interactor = interactor_klass.new true
+      assert_equal :success, interactor.outcome
+    end
+
+    def test_reports_outoutput_for_pass
+      interactor = interactor_klass.new true
+      assert_equal [:item], interactor.output
+    end
+
+    def test_reports_outcome_as_failure_for_no_pass
+      interactor = interactor_klass.new false
+      assert_equal :failure, interactor.outcome
+    end
+    class Undefined < AllSystems::Interactor
+      def outcomes
+        []
+      end
+
+      def go!
+        report_created
+      end
+    end
+
+    def test_handles_undefined_outcomes
+      assert_raises AllSystems::UnknownOutcomeReportError do
+        Undefined.new().outcome
+      end
+    end
+
+    class Nonedefined < AllSystems::Interactor
+      def go!
+        report_created
+      end
+    end
+
+    def test_handles_nonedefined_outcomes
+      assert_raises AllSystems::UnknownOutcomeReportError do
+        Nonedefined.new().outcome
+      end
+    end
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,6 @@
+require 'all_systems'
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+reporter_options = {color: true, slow_count: 5}
+Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(reporter_options)]

data/usecase.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'all_systems/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "all_systems"
+  spec.version       = AllSystems::VERSION
+  spec.authors       = ["Peter Saxton"]
+  spec.email         = ["peterhsaxton@gmail.com"]
+  spec.summary       = %q{Simple usecase/interactor/service objects to encapsulate business logic}
+  spec.description   = %q{An interactor encapsulates the action of specific business usecase. For example a `LogIn` or `CreatePost`. It executes this action by coordinating the interaction of over business objects in the system.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.4.3"
+  spec.add_development_dependency "minitest-reporters", "~> 1.0.6"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: all_systems
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Peter Saxton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+description: An interactor encapsulates the action of specific business usecase. For
+  example a `LogIn` or `CreatePost`. It executes this action by coordinating the interaction
+  of over business objects in the system.
+email:
+- peterhsaxton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/all_systems.rb
+- lib/all_systems/errors.rb
+- lib/all_systems/interactor.rb
+- lib/all_systems/version.rb
+- test/interactor/error_test.rb
+- test/interactor/invalid_outcomes_test.rb
+- test/interactor/outcome_test.rb
+- test/interactor/output_test.rb
+- test/interactor/report_helper_test.rb
+- test/test_config.rb
+- usecase.gemspec
+homepage: ''
+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.6
+signing_key: 
+specification_version: 4
+summary: Simple usecase/interactor/service objects to encapsulate business logic
+test_files:
+- test/interactor/error_test.rb
+- test/interactor/invalid_outcomes_test.rb
+- test/interactor/outcome_test.rb
+- test/interactor/output_test.rb
+- test/interactor/report_helper_test.rb
+- test/test_config.rb