tzu 0.0.2.0 → 0.1.0.0

data/lib/tzu/core_extensions/string.rb

@@ -0,0 +1,17 @@
+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/lib/tzu/hooks.rb

@@ -19,6 +19,11 @@ module Tzu
         hooks.each { |hook| after_hooks.push(hook) }
       end
 
+      def around(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| around_hooks.push(hook) }
+      end
+
       def before_hooks
         @before_hooks ||= []
       end
@@ -26,17 +31,30 @@ module Tzu
       def after_hooks
         @after_hooks ||= []
       end
+
+      def around_hooks
+        @around_hooks ||= []
+      end
     end
 
     def with_hooks(params, &block)
-      run_before_hooks(params)
-      result = block.call(params)
-      run_after_hooks(params)
+      result = nil
+      run_around_hooks do
+        run_before_hooks(params)
+        result = yield(params)
+        run_after_hooks(params)
+      end
       result
     end
 
     private
 
+    def run_around_hooks(&block)
+      self.class.around_hooks.reverse.inject(block) do |chain, hook|
+        proc { run_hook(hook, chain) }
+      end.call
+    end
+
     def run_before_hooks(params)
       run_hooks(self.class.before_hooks, params)
     end
@@ -52,6 +70,5 @@ module Tzu
     def run_hook(hook, args)
       hook.is_a?(Symbol) ? send(hook, args) : instance_exec(args, &hook)
     end
-
   end
 end

data/lib/tzu/invalid.rb

@@ -1,9 +1,7 @@
 module Tzu
   class Invalid < Failure
-
     def initialize(errors = nil)
       super(:validation, errors)
     end
-
   end
 end

data/lib/tzu/outcome.rb

@@ -1,5 +1,4 @@
 module Tzu
-
   # The result of executing a command
   class Outcome
     attr_reader :success, :result, :type

data/lib/tzu/run_methods.rb

@@ -0,0 +1,32 @@
+module Tzu
+  module RunMethods
+    attr_reader :request_klass
+
+    def run(params, *context, &block)
+      result = get_instance(*context).run(params)
+      return result.handle(&block) if block
+      result
+    end
+
+    def run!(params, *context)
+      get_instance(*context).run!(params)
+    end
+
+    def get_instance(*context)
+      method = respond_to?(:build) ? :build : :new
+      send(method, *context)
+    end
+
+    def command_name(value = nil)
+      if value.nil?
+        @name ||= name.underscore.to_sym
+      else
+        @name = (value.presence && value.to_sym)
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      @request_klass = args.first if method == :request_object
+    end
+  end
+end

data/lib/tzu/sequence.rb

@@ -0,0 +1,68 @@
+module Tzu
+  module Sequence
+    def self.included(base)
+      base.class_eval do
+        include Hooks
+
+        class << self
+          attr_reader :steps, :result_block
+
+          def run(params)
+            new(params).run
+          end
+
+          def method_missing(method, *args, &block)
+            return add_step(args.first, &block) if method == :step
+            super
+          end
+
+          def type
+            @type ||= :take_last
+          end
+
+          def result(type = nil, &block)
+            return @result_block = block if block
+            @type = type
+          end
+
+          def add_step(klass, &block)
+            @steps = [] unless @steps
+
+            step = Step.new(klass)
+            step.instance_eval(&block)
+
+            @steps << step
+          end
+        end
+
+        def initialize(params)
+          @params = params
+          @last_outcome = nil
+        end
+
+        def run
+          results = sequence_results
+          return mutated_result(results) if self.class.result_block
+          return @last_outcome if self.class.type == :take_last
+          Outcome.new(true, results)
+        end
+
+        def sequence_results
+          with_hooks(@params) do |params|
+            self.class.steps.reduce({}) do |prior_results, step|
+              @last_outcome = step.run(params, prior_results)
+              break if @last_outcome.failure?
+              prior_results.merge!(step.name => @last_outcome.result)
+            end
+          end
+        end
+
+        private
+
+        def mutated_result(results)
+          Outcome.new(true, instance_exec(@params, results, &self.class.result_block))
+        end
+      end
+    end
+  end
+end

data/lib/tzu/step.rb

@@ -0,0 +1,34 @@
+module Tzu
+  class Step
+    String.send(:include, ::Tzu::CoreExtensions::String)
+    attr_reader :klass, :param_mutator
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def run(params, prior_results)
+      command_params = process(params, prior_results)
+      @klass.run(command_params)
+    end
+
+    def name
+      return @name if @name && @name.is_a?(Symbol)
+      @klass.to_s.symbolize
+    end
+
+    def receives(&block)
+      @param_mutator = block
+    end
+
+    def as(name)
+      @name = name
+    end
+
+    private
+
+    def process(params, prior_results)
+      instance_exec(params, prior_results, &@param_mutator)
+    end
+  end
+end

data/lib/tzu/validation.rb

@@ -15,20 +15,8 @@ module Tzu
     end
 
     def validate(params)
-      # see if the command defines a valid? method
-      if self.respond_to?(:valid?)
-        result = valid?(params)
-        errors = self.respond_to?(:errors) ? self.errors : nil
-        return !!result == result ? ValidationResult.new(result, errors) : result
-      end
-
-      # do the params define their own validation method (cf. ActiveRecord)
-      if params.respond_to?(:valid?)
-        return ValidationResult.new(params.valid?, params.errors)
-      end
-
-      # otherwise valid
-      return ValidationResult.new(true)
+      return ValidationResult.new(params.valid?, params.errors) if params.respond_to?(:valid?)
+      ValidationResult.new(true)
     end
 
     def invalid!(obj)
@@ -39,5 +27,8 @@ module Tzu
       raise Invalid.new(output)
     end
 
+    def fail!(type, data = {})
+      raise Failure.new(type, data)
+    end
   end
 end

data/spec/sequence_spec.rb

@@ -0,0 +1,206 @@
+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 InvalidCommand
+  include Tzu
+
+  def call(params)
+    invalid!('Who am I? Why am I here?')
+  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 MultiStepComplex
+  include Tzu::Sequence
+
+  step SayMyName do
+    as :first_command
+    receives do |params|
+      { name: params[:name] }
+    end
+  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
+    receives do |params|
+      { name: params[:name] }
+    end
+  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 do
+    receives do |params|
+      { name: params[:name] }
+    end
+  end
+
+  step InvalidCommand 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_mutator 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.param_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.param_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_mutator 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
+        expect(say_my_name.param_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 :final_command
+        expect(make_me_sound_important.param_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 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