tzu 0.0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b809317c8b5ff13fcb4784360d28703691ea3d9d
+  data.tar.gz: 141562074c39e1d23fc945f2d6d7bf825eb37c6c
+SHA512:
+  metadata.gz: 1b231785af2e5ca4fab9e1a8590676875f87796592050391f9e32a2358e70878e31cc85c42b5c383c2fb484ab00afc7abb549c15a56a5f0b29fa0dccd3f96878
+  data.tar.gz: bff733337e18acb528bd37978f3034f67e788225b23b487c878f60d00bca8c0ef95b07c362ec5166024b633b102f968d1c0418451b7ab13a4accee6911d4ff93

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Blake Turner
+
+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 @@
+# Tzu

data/lib/tzu.rb

@@ -0,0 +1,88 @@
+require 'tzu/failure'
+require 'tzu/hooks'
+require 'tzu/invalid'
+require 'tzu/match'
+require 'tzu/organizer'
+require 'tzu/outcome'
+require 'tzu/validation'
+require 'tzu/validation_result'
+
+module Tzu
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      include Hooks
+    end
+  end
+
+  module ClassMethods
+    def run(params, *context, &block)
+      result = get_instance(*context).run(params)
+      if block
+        result.handle(&block)
+      else
+        result
+      end
+    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
+  end
+
+  def command_name
+    self.class.command_name
+  end
+
+  def run(params)
+    run!(request_object(params))
+  rescue Failure => f
+    Outcome.new(false, f.errors, f.type)
+  end
+
+  def run!(params)
+    with_hooks(params) do |p|
+      outcome = call(p)
+      outcome.is_a?(Tzu::Outcome) ? outcome : Outcome.new(true, outcome)
+    end
+  rescue
+    rollback! if self.respond_to?(:rollback!)
+    raise
+  end
+
+  def fail!(type, data={})
+    raise Failure.new(type, data)
+  end
+
+  private
+
+  def request_object(params)
+    klass = request_class
+    return klass.new(params) if klass && !params.is_a?(klass)
+    params
+  end
+
+  # Get the name of a request class related to calling class
+  # ie.   Tzus::MyNameSpace::MyTzu
+  # has   Tzus::MyNameSpace::Requests::MyTzu
+  def request_class
+    namespace =  self.class.name.deconstantize.constantize
+    request_object_name = "Requests::#{ self.class.name.demodulize}"
+    namespace.qualified_const_get(request_object_name)
+  rescue NameError
+    false
+  end
+end

data/lib/tzu/failure.rb

@@ -0,0 +1,10 @@
+module Tzu
+  class Failure < StandardError
+    attr_reader :errors, :type
+
+    def initialize(type = nil, errors = nil)
+      @errors, @type = errors, type
+    end
+
+  end
+end

data/lib/tzu/hooks.rb

@@ -0,0 +1,57 @@
+module Tzu
+
+  # Provides hooks for arbitrary pre- and post- processing within a command
+  module Hooks
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def before(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| before_hooks.push(hook) }
+      end
+
+      def after(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| after_hooks.push(hook) }
+      end
+
+      def before_hooks
+        @before_hooks ||= []
+      end
+
+      def after_hooks
+        @after_hooks ||= []
+      end
+    end
+
+    def with_hooks(params, &block)
+      run_before_hooks(params)
+      result = block.call(params)
+      run_after_hooks(params)
+      result
+    end
+
+    private
+
+    def run_before_hooks(params)
+      run_hooks(self.class.before_hooks, params)
+    end
+
+    def run_after_hooks(params)
+      run_hooks(self.class.after_hooks, params)
+    end
+
+    def run_hooks(hooks, params)
+      hooks.each { |hook| run_hook(hook, params) }
+    end
+
+    def run_hook(hook, args)
+      hook.is_a?(Symbol) ? send(hook, args) : instance_exec(args, &hook)
+    end
+
+  end
+end

data/lib/tzu/invalid.rb

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

data/lib/tzu/match.rb

@@ -0,0 +1,55 @@
+module Tzu
+
+  # with thanks to https://github.com/pzol/deterministic
+  class Match
+    def initialize(outcome, context)
+      @outcome, @context, @collection = outcome, context, []
+    end
+
+    def result
+      matcher = @collection.detect { |m| m.matches?(@outcome.type) }
+      raise "No match could be made for #{@outcome}" if matcher.nil?
+      @context.instance_exec(@outcome.result, &matcher.block)
+    end
+
+    %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)
+    end
+
+    private
+
+    Matcher = Struct.new(:condition, :block) do
+      def matches?(value)
+        condition.call(value)
+      end
+    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
+
+      matcher_pred = compose_predicates(type_pred[type], condition_pred)
+      @collection << Matcher.new(matcher_pred, result_block)
+    end
+
+    def compose_predicates(f, g)
+      ->(*args) { f[*args] && g[*args] }
+    end
+
+    # return a partial function for matching a matcher's type
+    def type_pred
+      (->(type, x) { @outcome.send("#{type.to_s}?") }).curry
+    end
+  end
+end

data/lib/tzu/organizer.rb

@@ -0,0 +1,35 @@
+require 'ostruct'
+
+module Tzu
+  module Organizer
+    def self.included(base)
+      base.class_eval do
+        include Tzu
+      end
+    end
+
+    Step = Struct.new(:command, :transform)
+
+    def steps
+      @steps ||= []
+    end
+
+    def add_step(command, &transform)
+      steps << Step.new(command, transform)
+    end
+
+    def call(params)
+      result = call_steps(params)
+      self.respond_to?(:parse) ? parse(result) : result
+    end
+
+    def call_steps(params)
+      result = ::OpenStruct.new
+      steps.each do |step|
+        call_with = step.transform ? step.transform(params, result) : params
+        result[step.command.command_name] = step.command.run!(call_with)
+      end
+      result
+    end
+  end
+end

data/lib/tzu/outcome.rb

@@ -0,0 +1,28 @@
+module Tzu
+
+  # The result of executing a command
+  class Outcome
+    attr_reader :success, :result, :type
+
+    def initialize(success, result, type = nil)
+      @success = success
+      @result = result
+      @type = type
+    end
+
+    def success?
+      @success
+    end
+
+    def failure?
+      !@success
+    end
+
+    def handle(context=nil, &block)
+      context ||= block.binding.eval('self')
+      match = Match.new(self, context)
+      match.instance_eval &block
+      match.result
+    end
+  end
+end

data/lib/tzu/validation.rb

@@ -0,0 +1,43 @@
+module Tzu
+  module Validation
+
+    def self.included(base)
+      base.class_eval do
+        # registers validation as a before hook
+        before :when_valid
+      end
+    end
+
+    def when_valid(params)
+      validation_result = validate(params)
+      invalid!(validation_result.errors) unless validation_result.valid?
+      validation_result
+    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)
+    end
+
+    def invalid!(obj)
+      output = [:errors, :messages].reduce(obj) do |result, m|
+        result = result.respond_to?(m) ? result.send(m) : result
+      end
+
+      raise Invalid.new(output)
+    end
+
+  end
+end

data/lib/tzu/validation_result.rb

@@ -0,0 +1,13 @@
+module Tzu
+  class ValidationResult
+    attr_reader :errors, :valid
+
+    def initialize(valid, errors = [])
+      @valid, @errors = valid, errors
+    end
+
+    def valid?
+      @valid
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Tzu do
+
+  context 'command fails' do
+    subject do
+      Class.new do
+        include Tzu
+
+        def call(params)
+          fail! :something
+        end
+      end
+    end
+
+    it 'returns failure' do
+      result = subject.run(nil)
+      expect(result).to have_attributes(success: false, type: :something)
+    end
+  end
+
+  context 'command succeeds' do
+    subject do
+      Class.new do
+        include Tzu
+
+        def call(params)
+          1234
+        end
+      end
+    end
+
+    it 'returns result' do
+      result = subject.run(nil)
+      expect(result).to have_attributes(success: true, result: 1234)
+    end
+  end
+
+end

data/spec/hooks_spec.rb

@@ -0,0 +1,169 @@
+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/organizer_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Tzu::Organizer do
+  let(:params) { [1, 2, 3] }
+  let(:commands) { [spy(run!: :step1, command_name: :step1), spy(run!: :step2, command_name: :step2)] }
+
+  let(:organized) do
+    organized = Class.new do
+      include Tzu::Organizer
+
+      def initialize(commands)
+        commands.each { |s| add_step(s) }
+      end
+    end
+
+    organized
+  end
+
+  context 'when organizer is called' do
+
+    it 'calls each step' do
+      organized.run(params, commands)
+      commands.each { |s| expect(s).to have_received(:run!).with(params) }
+    end
+
+    it 'collates result of steps' do
+      result = organized.run(params, commands)
+      expect(result.result.step1).to eq(:step1)
+      expect(result.result.step2).to eq(:step2)
+    end
+  end
+
+  context 'when organizer defines parse' do
+    before do
+      organized.class_eval do
+        def parse(result)
+          12345
+        end
+      end
+    end
+
+    it 'it parses results from commands' do
+      result = organized.run(params, commands)
+      expect(result).to have_attributes(success: true, result: 12345)
+    end
+  end
+
+end

data/spec/outcome_spec.rb

@@ -0,0 +1,48 @@
+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/spec_helper.rb

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

data/spec/tzu_spec.rb

@@ -0,0 +1,354 @@
+# require 'spec_helper'
+#
+# if !defined?(ActiveRecord::Base)
+#   puts "** require 'active_record' to run the specs in #{__FILE__}"
+# else
+#   ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+#
+#   ActiveRecord::Migration.suppress_messages do
+#     ActiveRecord::Schema.define(:version => 0) do
+#       create_table(:employers, force: true) {|t| t.string :name }
+#       create_table(:users, force: true) {|t| t.string :first_name; t.string :last_name; t.references :employer; }
+#       create_table(:sports_cars, force: true) {|t| t.string :make; t.references :employer; }
+#     end
+#   end
+#
+#   module GetSpec
+#     class Employer < ActiveRecord::Base
+#       has_many :users
+#       has_many :sports_cars
+#     end
+#
+#     class User < ActiveRecord::Base
+#       belongs_to :employer
+#     end
+#
+#     class SportsCar < ActiveRecord::Base
+#       belongs_to :employer
+#     end
+#   end
+# end
+#
+# describe Get do
+#   let(:last_name) { 'Turner' }
+#   let(:adapter) { :active_record }
+#
+#   # Preserve system config for other tests
+#   before(:all) { @system_config = Get.configuration }
+#   after(:all) { Get.configuration = @system_config }
+#
+#   # Reset base config with each iteration
+#   before { Get.configure { |config| config.set_adapter(adapter) } }
+#   after do
+#     GetSpec::User.delete_all
+#     GetSpec::Employer.delete_all
+#     Get.reset
+#   end
+#
+#   class MyCustomEntity < Horza::Entities::Collection
+#     def east_london_length
+#       "#{length}, bruv"
+#     end
+#   end
+#
+#   describe '#configure' do
+#     context '#register_entity' do
+#       let(:user_count) { 3 }
+#
+#       before do
+#         Get.configure { |config| config.register_entity(:users_by_last_name, MyCustomEntity) }
+#         user_count.times { GetSpec::User.create(last_name: last_name) }
+#       end
+#       after { Get.reset }
+#
+#       it 'gets registers entity' do
+#         expect(Get.configuration.entity_for(:users_by_last_name)).to eq MyCustomEntity
+#       end
+#
+#       it 'returns specified entity type after querying db' do
+#         result = Get::UsersByLastName.run(last_name)
+#         expect(result.is_a? MyCustomEntity).to be true
+#         expect(result.east_london_length).to eq "#{user_count}, bruv"
+#       end
+#     end
+#   end
+#
+#   context '#entity_for' do
+#     context 'when entity has been registered' do
+#       before do
+#         Get.configure do |config|
+#           config.set_adapter(adapter)
+#           config.register_entity(:users_by_last_name, MyCustomEntity)
+#         end
+#       end
+#       after { Get.reset }
+#
+#       it 'registers entity' do
+#         expect(Get.entity_for(:users_by_last_name)).to eq MyCustomEntity
+#       end
+#     end
+#
+#     context 'when entity has not been registered' do
+#       it 'returns nil' do
+#         expect(Get.entity_for(:users_by_last_name)).to be nil
+#       end
+#     end
+#   end
+#
+#   context '#adapter' do
+#     context 'when the adapter is set' do
+#       it 'returns the correct adapter class' do
+#         expect(Get.adapter).to eq Horza::Adapters::ActiveRecord
+#       end
+#     end
+#
+#     context 'when the adapter is not set' do
+#       before { Get.reset }
+#       after { Get.reset }
+#
+#       it 'throws error' do
+#         expect { Get.adapter }.to raise_error(Get::Errors::Base)
+#       end
+#     end
+#   end
+#
+#   context '#reset' do
+#     before do
+#       Get.configure do |config|
+#         config.set_adapter('my_adapter')
+#         config.register_entity(:users_by_last_name, MyCustomEntity)
+#       end
+#       Get.reset
+#     end
+#     it 'resets the config' do
+#       expect(Get.configuration.adapter).to be nil
+#       expect(Get.entity_for(:users_by_last_name)).to be nil
+#     end
+#   end
+#
+#   context '#run!' do
+#     context 'singular form' do
+#       context 'when the record exists' do
+#         let!(:user) { GetSpec::User.create(last_name: last_name) }
+#
+#         context 'field in class name' do
+#           it 'gets the records based on By[KEY]' do
+#             result = Get::UserById.run!(user.id)
+#             expect(result.to_h).to eq user.attributes
+#           end
+#
+#           it 'returns a dynamically generated response entity' do
+#             expect(Get::UserById.run!(user.id).is_a?(Horza::Entities::Single)).to be true
+#           end
+#         end
+#
+#         context 'field in parameters' do
+#           it 'gets the records based on parameters' do
+#             result = Get::UserBy.run!(last_name: last_name)
+#             expect(result.to_h).to eq user.attributes
+#           end
+#
+#           it 'returns a dynamically generated response entity' do
+#             expect(Get::UserBy.run!(last_name: last_name).is_a?(Horza::Entities::Single)).to be true
+#           end
+#         end
+#       end
+#
+#       context 'when the record does not exist' do
+#         it 'returns nil' do
+#           expect { Get::UserById.run!(999) }.to raise_error Get::Errors::Base
+#         end
+#       end
+#     end
+#
+#     context 'ancestry' do
+#       context 'valid ancestry with no saved parent' do
+#         let(:user2) { GetSpec::User.create }
+#         it 'returns nil' do
+#           expect { Get::EmployerFromUser.run!(user2) }.to raise_error Get::Errors::RecordNotFound
+#         end
+#       end
+#     end
+#   end
+#
+#   context '#run' do
+#     context 'singular form' do
+#       context 'when the record exists' do
+#         let!(:user) { GetSpec::User.create(last_name: last_name) }
+#
+#         context 'field in class name' do
+#           it 'gets the records based on By[KEY]' do
+#             result = Get::UserById.run(user.id)
+#             expect(result.to_h).to eq user.attributes
+#           end
+#
+#           it 'returns a dynamically generated response entity' do
+#             expect(Get::UserById.run(user.id).is_a?(Horza::Entities::Single)).to be true
+#           end
+#         end
+#
+#         context 'field in parameters' do
+#           it 'gets the records based on parameters' do
+#             result = Get::UserBy.run(last_name: last_name)
+#             expect(result.to_h).to eq user.attributes
+#           end
+#
+#           it 'returns a dynamically generated response entity' do
+#             expect(Get::UserBy.run(last_name: last_name).is_a?(Horza::Entities::Single)).to be true
+#           end
+#         end
+#       end
+#
+#       context 'when the record does not exist' do
+#         it 'returns nil' do
+#           expect(Get::UserById.run(999)).to eq nil
+#         end
+#       end
+#     end
+#
+#     context 'plural form' do
+#       let(:last_name) { 'Turner' }
+#       let(:match_count) { 3 }
+#       let(:miss_count) { 2 }
+#
+#       context 'when records exist' do
+#         before do
+#           match_count.times { GetSpec::User.create(last_name: last_name)  }
+#           miss_count.times { GetSpec::User.create }
+#         end
+#
+#         context 'field in class name' do
+#           it 'gets the records based on By[KEY]' do
+#             result = Get::UsersByLastName.run(last_name)
+#             expect(result.length).to eq match_count
+#           end
+#
+#           it 'returns a dynamically generated response entity' do
+#             expect(Get::UsersByLastName.run(last_name).is_a?(Horza::Entities::Collection)).to be true
+#           end
+#         end
+#
+#         context 'field in parameters' do
+#           it 'gets the records based on parameters' do
+#             result = Get::UsersBy.run(last_name: last_name)
+#             expect(result.length).to eq match_count
+#           end
+#
+#           it 'returns a dynamically generated response entity' do
+#             expect(Get::UsersBy.run(last_name: last_name).is_a?(Horza::Entities::Collection)).to be true
+#           end
+#         end
+#       end
+#
+#       context 'when no records exist' do
+#         it 'returns empty collection' do
+#           expect(Get::UsersBy.run(last_name: last_name).empty?).to be true
+#         end
+#       end
+#     end
+#
+#     context 'ancestry' do
+#       context 'direct relation' do
+#         let(:employer) { GetSpec::Employer.create }
+#         let!(:user1) { GetSpec::User.create(employer: employer) }
+#         let!(:user2) { GetSpec::User.create(employer: employer) }
+#
+#         context 'ParentFromChild' do
+#           it 'returns parent' do
+#             expect(Get::EmployerFromUser.run(user1).to_h).to eq employer.attributes
+#           end
+#         end
+#
+#         context 'ChildrenFromParent' do
+#           it 'returns children' do
+#             result = Get::UsersFromEmployer.run(employer)
+#             expect(result.first.to_h).to eq user1.attributes
+#             expect(result.last.to_h).to eq user2.attributes
+#           end
+#         end
+#
+#         context 'invalid ancestry' do
+#           it 'throws error' do
+#             expect { Get::UserFromEmployer.run(employer) }.to raise_error Get::Errors::InvalidAncestry
+#           end
+#         end
+#
+#         context 'valid ancestry with no saved childred' do
+#           let(:employer2) { GetSpec::Employer.create }
+#           it 'returns empty collection error' do
+#             expect(Get::UsersFromEmployer.run(employer2).empty?).to be true
+#           end
+#         end
+#
+#         context 'valid ancestry with no saved parent' do
+#           let(:user2) { GetSpec::User.create }
+#           it 'returns nil' do
+#             expect(Get::EmployerFromUser.run(user2)).to be nil
+#           end
+#         end
+#       end
+#
+#       context 'using via' do
+#         let(:employer) { GetSpec::Employer.create }
+#         let(:user) { GetSpec::User.create(employer: employer) }
+#         let(:sportscar) { GetSpec::SportsCar.create(employer: employer) }
+#
+#         before do
+#           employer.sports_cars << sportscar
+#         end
+#
+#         it 'returns the correct ancestor (single via symbol)' do
+#           result = Get::SportsCarsFromUser.run(user, via: :employer)
+#           expect(result.first.to_h).to eq sportscar.attributes
+#         end
+#
+#         it 'returns the correct ancestor (array of via symbols)' do
+#           result = Get::SportsCarsFromUser.run(user, via: [:employer])
+#           expect(result.first.to_h).to eq sportscar.attributes
+#         end
+#       end
+#     end
+#   end
+# end
+#
+# describe Get::Builders::AncestryBuilder do
+#   let(:name) { 'UserFromEmployer' }
+#
+#   before { Get.configure { |config| config.set_adapter(:active_record) } }
+#   after { Get.reset }
+#
+#   subject { Get::Builders::AncestryBuilder.new(name) }
+#
+#   describe '#class' do
+#     it 'builds a class that inherits from Get::Db' do
+#       expect(subject.class.superclass).to eq Get::Db
+#     end
+#
+#     it 'correctly assigns class-level variables' do
+#       [:entity, :query_key, :collection, :store, :result_key].each do |class_var|
+#         expect(subject.class.respond_to? class_var).to be true
+#       end
+#     end
+#   end
+# end
+#
+# describe Get::Builders::QueryBuilder do
+#   let(:name) { 'UserFromEmployer' }
+#
+#   before { Get.configure { |config| config.set_adapter(:active_record) } }
+#   after { Get.reset }
+#
+#   subject { Get::Builders::QueryBuilder.new(name) }
+#
+#   describe '#class' do
+#     it 'builds a class that inherits from Get::Db' do
+#       expect(subject.class.superclass).to eq Get::Db
+#     end
+#
+#     it 'correctly assigns class-level variables' do
+#       [:entity, :query_key, :collection, :store, :field].each do |class_var|
+#         expect(subject.class.respond_to? class_var).to be true
+#       end
+#     end
+#   end
+# end

data/spec/validation_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Tzu::Validation do
+
+  context 'params define valid? method' do
+    subject do
+      Class.new do
+        include Tzu
+        include Tzu::Validation
+      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 'command defines valid? method' do
+    subject do
+      Class.new do
+        include Tzu
+        include Tzu::Validation
+
+        def valid?(params)
+          Tzu::ValidationResult.new(false, [])
+        end
+      end
+    end
+
+    it 'returns validation result' do
+      result = subject.run(nil)
+      expect(result).to have_attributes(success: false, type: :validation)
+    end
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: tzu
+version: !ruby/object:Gem::Version
+  version: 0.0.1.0
+platform: ruby
+authors:
+- Morgan Bruce
+- Blake Turner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-28 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:
+    - - ">="
+      - !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
+  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'
+description: Tzu is a library for issuing commands in Ruby
+email: morgan@onfido.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/tzu.rb
+- lib/tzu/failure.rb
+- lib/tzu/hooks.rb
+- lib/tzu/invalid.rb
+- lib/tzu/match.rb
+- lib/tzu/organizer.rb
+- lib/tzu/outcome.rb
+- lib/tzu/validation.rb
+- lib/tzu/validation_result.rb
+- spec/command_spec.rb
+- spec/hooks_spec.rb
+- spec/organizer_spec.rb
+- spec/outcome_spec.rb
+- spec/spec_helper.rb
+- spec/tzu_spec.rb
+- spec/validation_spec.rb
+homepage: https://github.com/onfido/tzu
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Standardise and encapsulate your application's actions
+test_files:
+- spec/command_spec.rb
+- spec/hooks_spec.rb
+- spec/organizer_spec.rb
+- spec/outcome_spec.rb
+- spec/spec_helper.rb
+- spec/tzu_spec.rb
+- spec/validation_spec.rb
+has_rdoc: