tzu 0.1.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: be375f294991c28ee40881e6e85a43241850517b
-  data.tar.gz: ecc8b1aaa61056c1b9c599490c7bc29435e8188a
+SHA256:
+  metadata.gz: 3461c8cde94996a9366831443f7bc018fea3ecc7bbbf39b051a8186dbc83941c
+  data.tar.gz: a68fedad1cc1379833332982bb56a683a3f5b0d68675cf4e21587bb10dacbaee
 SHA512:
-  metadata.gz: fbbd46f7370634bb89364cc4f5e1a1fddcef871c10a263d7972b13f03476ed43f5717827c60d9d5d3405d10bf711bafabe944af9d8cfe11facec1b814e68a2d3
-  data.tar.gz: 4a4de35db5b1d1b3bf320bacc8961b25309969384fed0cbdb28d93406bd271f0fba72c1b8d39c21543b4c889bb74513fec0c3e1b4d5d7dfda091c0422714a227
+  metadata.gz: 1f7a7b835a3f3340e8af96f4d733523b054cd82ee87b69024c1bc90843fa2452125f18aa12141b9bbcff9ab8adda1f89ff2c6d26a38acc457dbf367873834b2c
+  data.tar.gz: da137e33a5883acd558ff3fbf070055697aeeacc60766f8a71a8b78c4ab43e1e18b59c383309261e9abbf9324fc399529d3d454b77bfb228f84656cb474250a2

data/README.md

@@ -4,7 +4,7 @@ Tzu provides a simple interface for writing classes that encapsulate a single co
 
 **Commands should:**
 
-- Do exactly one thing (Single Responsibility Priciple)
+- Do exactly one thing (Single Responsibility Principle)
 - Be self-documenting
 - Be testable
 - Be easy to mock and stub

data/lib/tzu/failure.rb

@@ -8,7 +8,7 @@ module Tzu
     end
 
     def errors
-      string_error? ? { errors: @raw_errors } : @raw_errors
+      string_error? ? {errors: @raw_errors} : @raw_errors
     end
 
     def message

data/lib/tzu/hooks.rb

@@ -1,5 +1,4 @@
 module Tzu
-
   # Provides hooks for arbitrary pre- and post- processing within a command
   module Hooks
     def self.included(base)

data/lib/tzu/match.rb

@@ -1,5 +1,4 @@
 module Tzu
-
   # with thanks to https://github.com/pzol/deterministic
   class Match
     def initialize(outcome, context)
@@ -12,15 +11,15 @@ module Tzu
       @context.instance_exec(@outcome.result, &matcher.block)
     end
 
-    %w(success failure).each do |type|
-      define_method type.to_sym do |condition=nil, &result_block|
+    %w[success failure].each do |type|
+      define_method type.to_sym do |condition = nil, &result_block|
         push(type, condition, result_block)
       end
     end
 
     # todo: hash and define_method if more overrides identified
     def invalid(&result_block)
-      push('failure', :validation, result_block)
+      push("failure", :validation, result_block)
     end
 
     private
@@ -32,12 +31,15 @@ module Tzu
     end
 
     def push(type, condition, result_block)
-      condition_pred = case
-                         when condition.nil?;          ->(v) { true }
-                         when condition.is_a?(Proc);   condition
-                         when condition.is_a?(Class);  ->(v) { condition === @outcome.type }
-                         else                          ->(v) { @outcome.type == condition }
-                       end
+      condition_pred = if condition.nil?
+        ->(v) { true }
+      elsif condition.is_a?(Proc)
+        condition
+      elsif condition.is_a?(Class)
+        ->(v) { condition === @outcome.type }
+      else
+        ->(v) { @outcome.type == condition }
+      end
 
       matcher_pred = compose_predicates(type_pred[type], condition_pred)
       @collection << Matcher.new(matcher_pred, result_block)
@@ -49,7 +51,7 @@ module Tzu
 
     # return a partial function for matching a matcher's type
     def type_pred
-      (->(type, x) { @outcome.send("#{type.to_s}?") }).curry
+      ->(type, x) { @outcome.send(:"#{type}?") }.curry
     end
   end
 end

data/lib/tzu/outcome.rb

@@ -17,10 +17,10 @@ module Tzu
       !@success
     end
 
-    def handle(context=nil, &block)
-      context ||= block.binding.eval('self')
+    def handle(context = nil, &block)
+      context ||= block.binding.eval("self")
       match = Match.new(self, context)
-      match.instance_eval &block
+      match.instance_eval(&block)
       match.result
     end
   end

data/lib/tzu/run_methods.rb

@@ -21,7 +21,7 @@ module Tzu
       if value.nil?
         @name ||= name.underscore.to_sym
       else
-        @name = (value.presence && value.to_sym)
+        @name = value.presence && value.to_sym
       end
     end
 

data/lib/tzu/sequence.rb

@@ -21,7 +21,7 @@ module Tzu
           end
 
           def step(klass, &block)
-            @steps = [] unless @steps
+            @steps ||= []
 
             step = Step.new(klass)
             step.instance_eval(&block) if block
@@ -56,7 +56,7 @@ module Tzu
         private
 
         def last_outcome_is_failure?
-          return true if (@last_outcome.respond_to?(:failure?) && @last_outcome.failure?)
+          return true if @last_outcome.respond_to?(:failure?) && @last_outcome.failure?
           false
         end
 

data/lib/tzu/step.rb

@@ -1,8 +1,11 @@
+require "active_support"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+
 module Tzu
   class Step
-    DOUBLE_MUTATOR = 'You cannot define both receives and receives_many'
+    DOUBLE_MUTATOR = "You cannot define both receives and receives_many"
 
-    String.send(:include, ::Tzu::CoreExtensions::String)
     attr_reader :klass, :single_mutator, :splat_mutator
 
     def initialize(klass)
@@ -21,8 +24,9 @@ module Tzu
     end
 
     def name
-      return @name if @name && @name.is_a?(Symbol)
-      @klass.to_s.split('::').last.symbolize
+      return @name if @name&.is_a?(Symbol)
+
+      @klass.to_s.split("::").last.underscore.to_sym
     end
 
     def receives(&block)

data/lib/tzu/validation.rb

@@ -1,6 +1,5 @@
 module Tzu
   module Validation
-
     def self.included(base)
       base.class_eval do
         # registers validation as a before hook
@@ -16,12 +15,13 @@ module Tzu
 
     def validate(params)
       return ValidationResult.new(params.valid?, params.errors) if params.respond_to?(:valid?)
+
       ValidationResult.new(true)
     end
 
     def invalid!(obj)
       output = [:errors, :messages, :message].reduce(obj) do |result, m|
-        result = result.respond_to?(m) ? result.send(m) : result
+        result.respond_to?(m) ? result.send(m) : result
       end
 
       raise Invalid.new(output)

data/lib/tzu/validation_result.rb

@@ -10,4 +10,4 @@ module Tzu
       @valid
     end
   end
-end
+end

data/lib/tzu/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tzu
+  VERSION = "1.0.0"
+end

data/lib/tzu.rb

@@ -1,15 +1,14 @@
-require 'tzu/core_extensions/string'
-require 'tzu/errors'
-require 'tzu/run_methods'
-require 'tzu/failure'
-require 'tzu/hooks'
-require 'tzu/invalid'
-require 'tzu/match'
-require 'tzu/sequence'
-require 'tzu/step'
-require 'tzu/outcome'
-require 'tzu/validation'
-require 'tzu/validation_result'
+require "tzu/errors"
+require "tzu/run_methods"
+require "tzu/failure"
+require "tzu/hooks"
+require "tzu/invalid"
+require "tzu/match"
+require "tzu/sequence"
+require "tzu/step"
+require "tzu/outcome"
+require "tzu/validation"
+require "tzu/validation_result"
 
 module Tzu
   def self.included(base)
@@ -32,7 +31,7 @@ module Tzu
       outcome.is_a?(Tzu::Outcome) ? outcome : Outcome.new(true, outcome)
     end
   rescue
-    rollback! if self.respond_to?(:rollback!)
+    rollback! if respond_to?(:rollback!)
     raise
   end
 

metadata

@@ -1,114 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: tzu
 version: !ruby/object:Gem::Version
-  version: 0.1.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Morgan Bruce
 - Blake Turner
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-10-23 00:00:00.000000000 Z
+date: 2024-01-08 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.15
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.15
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.15
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.15
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '4.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 2.4.0
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '8'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: virtus
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+        version: '4.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '8'
 description: Tzu is a library for issuing commands in Ruby
 email: morgan@onfido.com
 executables: []
@@ -118,7 +40,6 @@ files:
 - LICENSE.txt
 - README.md
 - lib/tzu.rb
-- lib/tzu/core_extensions/string.rb
 - lib/tzu/errors.rb
 - lib/tzu/failure.rb
 - lib/tzu/hooks.rb
@@ -130,18 +51,12 @@ files:
 - lib/tzu/step.rb
 - lib/tzu/validation.rb
 - lib/tzu/validation_result.rb
-- spec/hooks_spec.rb
-- spec/outcome_spec.rb
-- spec/sequence_spec.rb
-- spec/spec_helper.rb
-- spec/step_spec.rb
-- spec/tzu_spec.rb
-- spec/validation_spec.rb
+- lib/tzu/version.rb
 homepage: https://github.com/onfido/tzu
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -156,16 +71,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
-signing_key: 
+rubygems_version: 3.4.22
+signing_key:
 specification_version: 4
 summary: Standardise and encapsulate your application's actions
-test_files:
-- spec/hooks_spec.rb
-- spec/outcome_spec.rb
-- spec/sequence_spec.rb
-- spec/spec_helper.rb
-- spec/step_spec.rb
-- spec/tzu_spec.rb
-- spec/validation_spec.rb
+test_files: []

data/lib/tzu/core_extensions/string.rb

@@ -1,17 +0,0 @@
-module Tzu
-  module CoreExtensions
-    module String
-      def symbolize
-        underscore.to_sym
-      end
-
-      def underscore
-        gsub(/::/, '/')
-        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .tr('-', '_')
-        .downcase
-      end
-    end
-  end
-end

data/spec/hooks_spec.rb

@@ -1,169 +0,0 @@
-require 'spec_helper'
-
-describe Tzu::Hooks do
-  describe '#with_hooks' do
-    def build_hooked(&block)
-      hooked = Class.new.send(:include, Tzu::Hooks)
-
-      hooked.class_eval do
-        attr_reader :steps
-
-        def self.process
-          new.tap(&:process).steps
-        end
-
-        def initialize
-          @steps = []
-        end
-
-        def process
-          with_hooks({}) { steps << :process }
-        end
-      end
-
-      hooked.class_eval(&block) if block
-      hooked
-    end
-
-    context 'when before hook is a method' do
-      let(:hooked) do
-        build_hooked do
-          before :add_before
-
-          def add_before(p)
-            steps << :before
-          end
-        end
-      end
-
-      it 'runs the before hook method' do
-        expect(hooked.process).to eq([:before, :process])
-      end
-    end
-
-    context 'when before hook is a block' do
-      let(:hooked) do
-        build_hooked do
-          before do
-            steps << :before
-          end
-        end
-      end
-
-      it 'runs the before hook block' do
-        expect(hooked.process).to eq([:before, :process])
-      end
-    end
-
-    context 'when after hook is a method' do
-      let(:hooked) do
-        build_hooked do
-          after :add_after
-
-          def add_after(p)
-            steps << :after
-          end
-        end
-      end
-
-      it 'runs the after hook method' do
-        expect(hooked.process).to eq([:process, :after])
-      end
-    end
-
-    context 'when after hook is a block' do
-      let(:hooked) do
-        build_hooked do
-          after do
-            steps << :after
-          end
-        end
-      end
-
-      it 'runs the after hook block' do
-        expect(hooked.process).to eq([:process, :after])
-      end
-    end
-
-    context 'when both before and after blocks are defined' do
-      let(:hooked) do
-        build_hooked do
-          before do
-            steps << :before
-          end
-
-          after do
-            steps << :after
-          end
-        end
-      end
-
-      it 'runs hooks in the expected order' do
-        expect(hooked.process).to eq([:before, :process, :after])
-      end
-    end
-
-
-    context 'when both before and after methods are defined' do
-      let(:hooked) do
-        build_hooked do
-          before :add_before
-          after :add_after
-
-          def add_before(p)
-            steps << :before
-          end
-
-          def add_after(p)
-            steps << :after
-          end
-        end
-      end
-
-      it 'runs hooks in the expected order' do
-        expect(hooked.process).to eq([:before, :process, :after])
-      end
-    end
-
-    context 'when multiple before methods are defined' do
-      let(:hooked) do
-        build_hooked do
-          before :add_before1, :add_before2
-
-          def add_before1(p)
-            steps << :before1
-          end
-
-          def add_before2(p)
-            steps << :before2
-          end
-        end
-      end
-
-      it 'runs hooks in the expected order' do
-        expect(hooked.process).to eq([:before1, :before2, :process])
-      end
-    end
-
-    context 'when multiple after methods are defined' do
-      let(:hooked) do
-        build_hooked do
-          after :add_after1, :add_after2
-
-          def add_after1(p)
-            steps << :after1
-          end
-
-          def add_after2(p)
-            steps << :after2
-          end
-        end
-      end
-
-      it 'runs hooks in the expected order' do
-        expect(hooked.process).to eq([:process, :after1, :after2])
-      end
-    end
-
-  end
-end

data/spec/outcome_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Tzu::Outcome do
-
-  context 'outcome is failed with specified type' do
-    subject { Tzu::Outcome.new(false, 'abc', :validation) }
-
-    it 'calls appropriate handler' do
-      matched = false
-      subject.handle do
-        success { raise }
-        failure(:something) { raise }
-        failure(:validation) { matched = true }
-      end
-      expect(matched).to eq true
-    end
-  end
-
-  context 'outcome is failed with unspecified type' do
-    subject { Tzu::Outcome.new(false, 'abc', :validation) }
-
-    it 'calls appropriate handler' do
-      matched = false
-      subject.handle do
-        success { raise }
-        failure { matched = true }
-        failure(:validation) { raise }
-      end
-      expect(matched).to eq true
-    end
-  end
-
-  context 'outcome is successful' do
-    subject { Tzu::Outcome.new(true, 'abc') }
-
-    it 'calls success handler' do
-      matched = false
-      subject.handle do
-        success { matched = true }
-        failure(:something) { raise }
-      end
-      expect(matched).to eq true
-    end
-  end
-end
-
-
-

data/spec/sequence_spec.rb

@@ -1,232 +0,0 @@
-require 'spec_helper'
-
-class SayMyName
-  include Tzu
-
-  def call(params)
-    "Hello, #{params[:name]}"
-  end
-end
-
-class MakeMeSoundImportant
-  include Tzu
-
-  def call(params)
-    "#{params[:boring_message]}! You are the most important citizen of #{params[:country]}!"
-  end
-end
-
-class ThrowInvalidError
-  include Tzu
-
-  def call(params)
-    invalid!('Who am I? Why am I here?')
-  end
-end
-
-class ConstructGreeting
-  class << self
-    def go(greeting, name)
-      "#{greeting}, #{name}"
-    end
-  end
-end
-
-class MultiStepSimple
-  include Tzu::Sequence
-
-  step SayMyName do
-    receives do |params|
-      { name: params[:name] }
-    end
-  end
-
-  step MakeMeSoundImportant do
-    receives do |params, prior_results|
-      {
-        boring_message: prior_results[:say_my_name],
-        country: params[:country]
-      }
-    end
-  end
-end
-
-class MultiStepNonTzu
-  include Tzu::Sequence
-
-  step ConstructGreeting do
-    as :say_my_name
-    invoke_with :go
-
-    receives_many do |greeting, name, country|
-      [greeting, name]
-    end
-  end
-
-  step MakeMeSoundImportant do
-    receives do |greeting, name, country, prior_results|
-      {
-        boring_message: prior_results[:say_my_name],
-        country: country
-      }
-    end
-  end
-end
-
-class MultiStepComplex
-  include Tzu::Sequence
-
-  step SayMyName do
-    as :first_command
-  end
-
-  step MakeMeSoundImportant do
-    as :final_command
-    receives do |params, prior_results|
-      {
-        boring_message: prior_results[:first_command],
-        country: params[:country]
-      }
-    end
-  end
-
-  result :take_all
-end
-
-class MultiStepProcessResults
-  include Tzu::Sequence
-
-  step SayMyName do
-    as :first_command
-  end
-
-  step MakeMeSoundImportant do
-    as :final_command
-    receives do |params, prior_results|
-      {
-        boring_message: prior_results[:first_command],
-        country: params[:country]
-      }
-    end
-  end
-
-  result do |params, prior_results|
-    {
-      status: :important,
-      message: "BULLETIN: #{prior_results[:final_command]}"
-    }
-  end
-end
-
-class MultiStepInvalid
-  include Tzu::Sequence
-
-  step SayMyName
-
-  step ThrowInvalidError do
-    receives do |params, prior_results|
-      { answer: "#{params[:name]}!!! #{prior_results[:say_my_name]}" }
-    end
-  end
-
-  step MakeMeSoundImportant do
-    receives do |params, prior_results|
-      {
-        boring_message: prior_results[:say_my_name],
-        country: params[:country]
-      }
-    end
-  end
-end
-
-describe Tzu::Sequence do
-  context '#steps' do
-    context MultiStepSimple do
-      let(:steps) { MultiStepSimple.steps }
-
-      it 'returns array of Steps' do
-        steps.each { |step| expect(step.is_a? Tzu::Step).to be true }
-      end
-
-      it 'passes the appropriate klass, name, and param_mutators to each step' do
-        say_my_name = steps.first
-        expect(say_my_name.klass).to eq SayMyName
-        expect(say_my_name.name).to eq :say_my_name
-        expect(say_my_name.single_mutator.is_a? Proc).to be true
-
-        make_me_sound_important = steps.last
-        expect(make_me_sound_important.klass).to eq MakeMeSoundImportant
-        expect(make_me_sound_important.name).to eq :make_me_sound_important
-        expect(make_me_sound_important.single_mutator.is_a? Proc).to be true
-      end
-    end
-
-    context MultiStepComplex do
-      let(:steps) { MultiStepComplex.steps }
-
-      it 'returns array of Steps' do
-        steps.each { |step| expect(step.is_a? Tzu::Step).to be true }
-      end
-
-      it 'passes the appropriate klass, name, and param_mutators to each step' do
-        say_my_name = steps.first
-        expect(say_my_name.klass).to eq SayMyName
-        expect(say_my_name.name).to eq :first_command
-
-        make_me_sound_important = steps.last
-        expect(make_me_sound_important.klass).to eq MakeMeSoundImportant
-        expect(make_me_sound_important.name).to eq :final_command
-        expect(make_me_sound_important.single_mutator.is_a? Proc).to be true
-      end
-    end
-  end
-
-  context '#run' do
-    let(:params) do
-      {
-        name: 'Jessica',
-        country: 'Azerbaijan'
-      }
-    end
-
-    context MultiStepSimple do
-      it 'returns the outcome of the last command' do
-        outcome = MultiStepSimple.run(params)
-        expect(outcome.result).to eq 'Hello, Jessica! You are the most important citizen of Azerbaijan!'
-      end
-    end
-
-    context MultiStepNonTzu do
-      it 'returns the outcome of the last command' do
-        outcome = MultiStepNonTzu.run('Greetings', 'Christopher', 'Canada')
-        expect(outcome.result).to eq 'Greetings, Christopher! You are the most important citizen of Canada!'
-      end
-    end
-
-    context MultiStepComplex do
-      it 'returns the outcome of the last command' do
-        outcome = MultiStepComplex.run(params)
-        results = outcome.result
-        expect(results[:first_command]).to eq 'Hello, Jessica'
-        expect(results[:final_command]).to eq 'Hello, Jessica! You are the most important citizen of Azerbaijan!'
-      end
-    end
-
-    context MultiStepProcessResults do
-      it 'returns the outcome of the last command' do
-        outcome = MultiStepProcessResults.run(params)
-        result = outcome.result
-        expect(result[:status]).to eq :important
-        expect(result[:message]).to eq 'BULLETIN: Hello, Jessica! You are the most important citizen of Azerbaijan!'
-      end
-    end
-
-    context MultiStepInvalid do
-      it 'stops its execution at the invalid command, which it returns' do
-        outcome = MultiStepInvalid.run(params)
-        expect(outcome.success?).to be false
-        expect(outcome.result).to eq(errors: 'Who am I? Why am I here?')
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-require 'rubygems'
-require 'byebug'
-require 'rspec'
-require 'active_record'
-require 'virtus'
-require 'bundler/setup'
-Bundler.setup
-
-require 'tzu'

data/spec/step_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe Tzu::Step do
-  let(:dummy_mutator) { proc { 'Dummy!' } }
-
-  context '#name' do
-    context 'when name is symbol' do
-      let(:step) { Tzu::Step.new(:step_name) }
-
-      it 'returns name' do
-        expect(step.name).to eq :step_name
-      end
-    end
-
-    context 'when name is a class' do
-      let(:step) { Tzu::Step.new(StandardError) }
-      let(:outcome) { ControlledOutcome.run(result: :success) }
-
-      it 'returns underscored name' do
-        expect(step.name).to eq :standard_error
-      end
-    end
-  end
-
-  context '#receives' do
-    context 'when splat_mutator is already defined' do
-      let(:step) { Tzu::Step.new(:step_name) }
-
-      before do
-        step.receives_many do |variable|
-          [1, 2, 3]
-        end
-      end
-
-      it 'throws error' do
-        expect { step.receives { |var| 'foo'} } .to raise_error(Tzu::InvalidSequence)
-      end
-    end
-  end
-
-  context '#receives_many' do
-    context 'when single_mutator is already defined' do
-      let(:step) { Tzu::Step.new(:step_name) }
-
-      before do
-        step.receives do |var|
-          'hello'
-        end
-      end
-
-      it 'throws error' do
-        expect { step.receives_many { |var| [1, 2, 3] } } .to raise_error(Tzu::InvalidSequence)
-      end
-    end
-  end
-end

data/spec/tzu_spec.rb

@@ -1,214 +0,0 @@
-require 'spec_helper'
-
-class ControlledOutcome
-  include Tzu
-
-  def call(params)
-    result = params[:result]
-    return 123 if result == :success
-    return invalid!('Invalid Message') if result == :invalid
-    return fail!(:falure_type, 'Failure Message') if result == :failure
-  end
-end
-
-class MyRequestObject
-  attr_reader :value, :errors
-
-  def initialize(params)
-    @params = params
-    @value = params[:value]
-    @errors = 'Error Message'
-  end
-
-  def valid?
-    @params[:valid]
-  end
-end
-
-class VirtusRequestObject
-  include Virtus.model
-  include ActiveModel::Validations
-
-  validates :name, :age, presence: :true
-
-  attribute :name, String
-  attribute :age, Integer
-end
-
-class ValidatedCommand
-  include Tzu
-
-  request_object MyRequestObject
-
-  def call(request)
-    request.value
-  end
-end
-
-class VirtusValidatedCommand
-  include Tzu
-
-  request_object VirtusRequestObject
-
-  def call(request)
-    "Name: #{request.name}, Age: #{request.age}"
-  end
-end
-
-describe Tzu do
-  context '#run' do
-    context 'when command succeeds' do
-      let(:outcome) { ControlledOutcome.run(result: :success) }
-
-      it 'correctly returns sets pass/fail flags' do
-        expect(outcome.success?).to be true
-        expect(outcome.failure?).to be false
-      end
-
-      it 'returns result' do
-        expect(outcome.result).to eq(123)
-      end
-    end
-
-    context 'when command is invalid' do
-      let(:outcome) { ControlledOutcome.run(result: :invalid) }
-
-      it 'correctly returns sets pass/fail flags' do
-        expect(outcome.success?).to be false
-        expect(outcome.failure?).to be true
-      end
-
-      it 'returns error string as errors hash' do
-        expect(outcome.result).to eq(errors: 'Invalid Message')
-      end
-
-      it 'sets type to validation' do
-        expect(outcome.type).to eq(:validation)
-      end
-    end
-
-    context 'when command fails' do
-      let(:outcome) { ControlledOutcome.run(result: :failure) }
-
-      it 'correctly returns sets pass/fail flags' do
-        expect(outcome.success?).to be false
-        expect(outcome.failure?).to be true
-      end
-
-      it 'returns error string as errors hash' do
-        expect(outcome.result).to eq(errors: 'Failure Message')
-      end
-
-      it 'sets type to falure_type' do
-        expect(outcome.type).to eq(:falure_type)
-      end
-    end
-  end
-
-  context '#run with block' do
-    let(:success_spy) { spy('success') }
-    let(:invalid_spy) { spy('invalid') }
-    let(:failure_spy) { spy('failure') }
-
-    before do
-      ControlledOutcome.run(result: result) do
-        success { |_| success_spy.call }
-        invalid { |_| invalid_spy.call }
-        failure { |_| failure_spy.call }
-      end
-    end
-
-    context 'when command succeeds' do
-      let(:result) { :success }
-      it 'executes success block' do
-        expect(success_spy).to have_received(:call)
-      end
-    end
-
-    context 'when command is invalid' do
-      let(:result) { :invalid }
-      it 'executes invalid block' do
-        expect(invalid_spy).to have_received(:call)
-      end
-    end
-
-    context 'when command fails' do
-      let(:result) { :failure }
-      it 'executes failure block' do
-        expect(failure_spy).to have_received(:call)
-      end
-    end
-  end
-
-  context '#run with request object' do
-    context 'when request is valid' do
-      let(:outcome) { ValidatedCommand.run(value: 1111, valid: true) }
-
-      it 'executes successfully' do
-        expect(outcome.success?).to be true
-      end
-
-      it 'returns value' do
-        expect(outcome.result).to eq 1111
-      end
-    end
-
-    context 'when request is invalid' do
-      let(:outcome) { ValidatedCommand.run(value: 2222, valid: false) }
-
-      it 'does not execute successfully' do
-        expect(outcome.failure?).to be true
-      end
-
-      it 'has outcome type :validation' do
-        expect(outcome.type).to eq :validation
-      end
-
-      it 'returns error string as errors hash' do
-        expect(outcome.result).to eq(errors: 'Error Message')
-      end
-    end
-
-    context 'with virtus/active_model request object' do
-      let(:outcome) { VirtusValidatedCommand.run(params) }
-
-      context 'when request is valid' do
-        let(:params) { { name: 'Young Tzu', age: '19' } }
-
-        it 'executes successfully' do
-          expect(outcome.success?).to be true
-        end
-      end
-
-      context 'when request is invalid' do
-        let(:params) { { name: 'My Name' } }
-
-        it 'does not execute successfully' do
-          expect(outcome.failure?).to be true
-        end
-
-        it 'returns ActiveModel error object' do
-          expect(outcome.result).to eq(age: ["can't be blank"])
-        end
-      end
-    end
-  end
-
-  context '#run!' do
-    context 'when command is invalid' do
-      let(:outcome) { ControlledOutcome.run!(result: :invalid) }
-
-      it 'raises Tzu::Invalid' do
-        expect { outcome }.to raise_error Tzu::Invalid, 'Invalid Message'
-      end
-    end
-
-    context 'when command fails' do
-      let(:outcome) { ControlledOutcome.run!(result: :failure) }
-
-      it 'raises Tzu::Failure' do
-        expect { outcome }.to raise_error Tzu::Failure, 'Failure Message'
-      end
-    end
-  end
-end

data/spec/validation_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-describe Tzu::Validation do
-
-  context 'params define valid? method' do
-    subject do
-      Class.new do
-        include Tzu
-      end
-    end
-
-    let(:errors) { [1, 2, 3] }
-    let(:params) { spy(errors: errors, valid?: false) }
-
-    it 'valid? method is called' do
-      subject.run(params)
-      expect(params).to have_received(:valid?)
-    end
-
-    it 'returns validation result' do
-      result = subject.run(params)
-      expect(result).to have_attributes(success: false, type: :validation, result: errors)
-    end
-  end
-
-  context 'invoked directly' do
-    context 'error message is string' do
-      let(:str) { 'error_message' }
-      subject { Tzu::Invalid.new(str) }
-      it 'has string as #message' do
-        expect(subject.message).to eq str
-      end
-
-      it '#errors converts sting to hash' do
-        expect(subject.errors).to eq(errors: str)
-      end
-    end
-  end
-
-  context 'rescued' do
-    subject do
-      Class.new do
-        include Tzu
-
-        def call(params)
-          raise StandardError.new(params[:message])
-        rescue StandardError => e
-          invalid! e
-        end
-      end
-    end
-
-    context 'error message is string' do
-      let(:str) { 'error_message' }
-      let(:params) { { message: str } }
-
-      describe '#run' do
-        it 'returns error hash as result' do
-          outcome = subject.run(params)
-          expect(outcome.result).to eq(errors: str)
-        end
-      end
-
-      describe '#run!' do
-        it 'has string as #message' do
-          expect { subject.run!(params) }.to raise_error Tzu::Invalid, str
-        end
-
-        it 'has string as #errors' do
-          begin
-            subject.run!(params)
-            expect(false).to be true # Should never reach this
-          rescue Tzu::Invalid => e
-            expect(e.errors).to eq(errors: str)
-          end
-        end
-      end
-    end
-  end
-end