slayer 0.3.1 → 0.4.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edff62ac6c3e45fdd46766caf1c9c49633413f48
-  data.tar.gz: 433b5038d863ad187fbe4537fb535dbb31c428c4
+  metadata.gz: b6ddcd92133adc30cc39358c00cfd4cf8494d879
+  data.tar.gz: b427f2b04fe18881c4448de84e06e2593a1bcece
 SHA512:
-  metadata.gz: 4c3a4d548e02caccc81c52d431146c345f3a4c5a8e74ce1e5141c971c8097cc9f4ee304e63aaadc4333cb4dfdc846ad2fccac1e20abe25890684b1122657d766
-  data.tar.gz: ef8cc22437e472d3f59e5056441735550e24e5b6fb440b382df8c1cc0e9176451b40f80dae05cecb22f87d2ea84368124456f3e5113f318c9d545aadb6b3ede9
+  metadata.gz: 578355462582a7e68883d7aa7d73f9e52f4d8870d797c63f3f75061c9ccdd445342e9f51c0348583a022403e3a7569503808952764b07816536627eca2cf5a95
+  data.tar.gz: 6ce3eda0fce30e75602a50fefd714d3df12baf17a89f1fdd37914c6b47120fd1488830ac4e6a8a63fbae6b8c2410a51ddce178296b56788ebba1d9543a102865

data/.gitignore

@@ -9,4 +9,6 @@
 /spec/reports/
 /tmp/
 /log*/*
-.byebug_history
+.byebug_history
+
+.DS_Store

data/README.md

@@ -16,13 +16,15 @@ Slayer provides 3 base classes for organizing your business logic: `Forms`, `Com
 
 ### Commands
 
-`Slayer::Commands` are the bread and butter of your application's business logic. `Commands` are where you compose services, and perform one-off business logic tasks. In our applications, we usually create a single `Command` per `Controller` endpoint.
+`Slayer::Commands` are the bread and butter of your application's business logic, and a specific implementation of the `Slayer::Service` object. `Commands` are where you compose services, and perform one-off business logic tasks. In our applications, we usually create a single `Command` per `Controller` endpoint.
 
-`Commands` should call `Services`, but `Services` should never call `Commands`.
+`Slayer::Commands` must implement a `call` method, which always return a structured `Slayer::Result` object making operating on results straightforward. The `call` method can also take a block, which provides `Slayer::ResultMatcher` object, and enforces handling of both `pass` and `fail` conditions for that result.
+
+This helps provide confidence that your core business logic is behaving in expected ways, and helps coerce you to develop in a clean and testable way.
 
 ### Services
 
-`Services` are the building blocks of `Commands`, and encapsulate re-usable chunks of application logic.
+`Slayer::Service`s are the base class of `Slayer::Command`s, and encapsulate re-usable chunks of application logic. `Services` also return structured `Slayer::Result` objects.
 
 ## Installation
 
@@ -44,6 +46,224 @@ Or install it yourself as:
 $ gem install slayer
 ```
 
+## Usage
+
+### Commands
+
+Slayer Commands should implement `call`, which will `pass` or `fail` the service based on input. Commands return a `Slayer::Result` which has a predictable interface for determining `success?` or `failure?`, a 'value' payload object, a 'status' value, and a user presentable `message`.
+
+```ruby
+# A Command that passes when given the string "foo"
+# and fails if given anything else.
+class FooCommand < Slayer::Command
+  def call(foo:)
+    unless foo == "foo"
+      flunk! value: foo, message: "Argument must be foo!"
+    end
+
+    pass! value: foo
+  end
+end
+```
+
+Handling the results of a command can be done in two ways. The primary way is through a handler block. This block is passed a handler object, which is in turn given blocks to handle different result outcomes:
+
+```ruby
+FooCommand.call(foo: "foo") do |m|
+  m.pass do |result|
+    puts "This code runs on success"
+  end
+
+  m.fail do |result|
+    puts "This code runs on failure. Message: #{result.message}"
+  end
+
+  m.all do
+    puts "This code runs on failure or success"
+  end
+
+  m.ensure do
+    puts "This code always runs after other handler blocks"
+  end
+end
+```
+
+The second is less comprehensive, but can be useful for very simple commands. The `call` method on a `Command` returns its result object, which has statuses set on itself:
+
+```ruby
+result = FooCommand.call(foo: "foo")
+puts result.success? # => true
+
+result = FooCommand.call(foo: "bar")
+puts result.success? # => false
+```
+
+Here's a more complex example demonstrating how the command pattern can be used to encapuslate the logic for validating and creating a new user. This example is shown using a `rails` controller, but the same approach can be used regardless of the framework.
+
+```ruby
+# commands/user_controller.rb
+class CreateUserCommand < Slayer::Command
+  def call(create_user_form:)
+    unless arguments_valid?(create_user_form)
+      flunk! value: create_user_form, status: :arguments_invalid
+    end
+
+    user = nil
+    transaction do
+      user = User.create(create_user_form.attributes)
+    end
+
+    unless user.persisted?
+      flunk! message: I18n.t('user.create.error'), status: :unprocessible_entity
+    end
+
+    pass! value: user
+  end
+
+  def arguments_valid?(create_user_form)
+    create_user_form.kind_of?(CreateUserForm) &&
+      create_user_form.valid? &&
+      !User.exists?(email: create_user_form.email)
+  end
+end
+
+# controllers/user_controller.rb
+class UsersController < ApplicationController
+  def create
+    @create_user_form = CreateUserForm.from_params(create_user_params)
+
+    CreateUserCommand.call(create_user_form: @create_user_form) do |m|
+      m.pass do |user|
+        auto_login(user)
+        redirect_to root_path, notice: t('user.create.success')
+      end
+
+      m.fail(:arguments_invalid) do |result|
+        flash[:error] = result.errors.full_messages.to_sentence
+        render :new, status: :unprocessible_entity
+      end
+
+      m.fail do |result|
+        flash[:error] = t('user.create.error')
+        render :new, status: :bad_request
+      end
+    end
+  end
+
+  private
+
+    def required_user_params
+      [:first_name, :last_name, :email, :password]
+    end
+
+    def create_user_params
+      permitted_params = required_user_params << :password_confirmation
+      params.require(:user).permit(permitted_params)
+    end
+end
+```
+
+### Result Matcher
+
+The result matcher is an object that is used to handle `Slayer::Result` objects based on their status.
+
+#### Handlers: `pass`, `fail`, `all`, `ensure`
+
+The result matcher block can take 4 types of handler blocks: `pass`, `fail`, `all`, and `ensure`. They operate as you would expect based on their names.
+
+* The `pass` block runs if the command was successful.
+* The `fail` block runs if the command was `flunked`.
+* The `all` block runs on any type of result --- `pass` or `fail` --- unless the result has already been handled.
+* The `ensure` block always runs after the result has been handled.
+
+#### Handler Params
+
+Every handler in the result matcher block is given three arguments: `value`, `result`, and `command`. These encapsulate the `value` provided in the `pass!` or `flunk!` call from the `Command`, the returned `Slayer::Result` object, and the `Slayer::Command` instance that was just run:
+
+```ruby
+class NoArgCommand < Slayer::Command
+  def call
+    @instance_var = 'instance'
+    pass value: 'pass'
+  end
+end
+
+
+NoArgCommand.call do |m|
+  m.all do |value, result, command|
+    puts value # => 'pass'
+    puts result.success? # => true
+    puts command.instance_var # => 'instance'
+  end
+endpoint
+```
+
+#### Statuses
+
+You can pass a `status` flag to both the `pass!` and `flunk!` methods that allows the result matcher to process different kinds of successes and failures differently:
+
+```ruby
+class StatusCommand < Slayer::Command
+  def call
+    flunk! message: "Generic flunk"
+    flunk! message: "Specific flunk", status: :specific_flunk
+    flunk! message: "Extra specific flunk", status: :extra_specific_flunk
+
+    pass! message: "Generic pass"
+    pass! message: "Specific pass", status: :specific_pass
+  end
+end
+
+StatusCommand.call do |m|
+  m.fail                        { puts "generic fail" }
+  m.fail(:specific_flunk)       { puts "specific flunk" }
+  m.fail(:extra_specific_flunk) { puts "extra specific flunk" }
+
+  m.pass                        { puts "generic pass" }
+  m.pass(:specific_pass)        { puts "specific pass" }
+end
+```
+
+### Forms
+
+### Services
+
+## RSpec & Minitest Integrations
+
+`Slayer` provides assertions and matchers that make testing your `Commands` simpler.
+
+### RSpec
+
+To use with RSpec, update your `spec_helper.rb` file to include:
+
+`require 'slayer/rspec'`
+
+This provides you with two new matchers: `be_successful_result` and `be_failed_result`, both of which can be chained with a `with_status` expectation:
+
+```ruby
+RSpec.describe RSpecCommand do
+  describe '#call' do
+    context 'should pass' do
+      subject(:result) { RSpecCommand.call(should_pass: true) }
+
+      it { is_expected.to be_success_result }
+      it { is_expected.not_to be_failed_result }
+      it { is_expected.not_to be_successful_result.with_status(:no_status) }
+    end
+
+    context 'should fail' do
+      subject(:result) { RSpecCommand.call(should_pass: false) }
+
+      it { is_expected.to be_failed_result }
+      it { is_expected.not_to be_failed_result }
+      it { is_expected.not_to be_failed_result.with_status(:no_status) }
+    end
+  end
+end
+```
+
+### Minitest
+
 ## Rails Integration
 
 While Slayer is independent of any framework, we do offer a first-class integration with Ruby on Rails. To install the Rails extensions, add this line to your application's Gemfile:
@@ -121,58 +341,6 @@ $ bin/rails g slayer:command foo_command
 $ bin/rails g slayer:service foo_service
 ```
 
-## Usage
-
-### Commands
-
-Slayer Commands should implement `call`, which will `pass` or `fail` the service based on input. Commands return a `Slayer::Result` which has a predictable interface for determining `success?` or `failure?`, a 'value' payload object, a 'status' value, and a user presentable `message`.
-
-```ruby
-# A Command that passes when given the string "foo"
-# and fails if given anything else.
-class FooCommand < Slayer::Command
-  def call(foo:)
-    if foo == "foo"
-      pass! value: foo, message: "Passing FooCommand"
-    else
-      fail! value: foo, message: "Failing FooCommand"
-    end
-  end
-end
-
-result = FooCommand.call(foo: "foo")
-result.success? # => true
-
-result = FooCommand.call(foo: "bar")
-result.success? # => false
-```
-
-### Forms
-
-### Services
-
-Slayer Services are objects that should implement re-usable pieces of application logic or common tasks. To prevent circular dependencies Services are required to declare which other Service classes they depend on. If a circular dependency is detected an error is raised.
-
-In order to enforce the lack of circular dependencies, Service objects can only call other Services that are declared in their dependencies.
-
-```ruby
-class NetworkService < Slayer::Service
-    def self.post()
-        ...
-    end
-end
-
-class StripeService < Slayer::Service
-  dependencies NetworkService
-
-  def self.pay()
-    ...
-    NetworkService.post(url: "stripe.com", body: my_payload)
-    ...
-  end
-end
-```
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -185,7 +353,6 @@ To generate documentation run `yard`. To view undocumented files run `yard stats
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/apsislabs/slayer.
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -7,4 +7,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task default: :test

data/lib/slayer.rb

@@ -2,6 +2,7 @@ require 'ext/string_ext' unless defined?(Rails)
 
 require 'slayer/version'
 require 'slayer/errors'
+require 'slayer/hook'
 require 'slayer/result'
 require 'slayer/result_matcher'
 require 'slayer/service'

data/lib/slayer/command.rb

@@ -1,73 +1,18 @@
 module Slayer
-  class Command
-    attr_accessor :result
+  class Command < Service
+    singleton_skip_hook :call
 
-    # Internal: Command Class Methods
     class << self
-      def call(*args, &block)
-        execute_call(block, *args) { |c, *a| c.run(*a) }
-      end
-
-      def call!(*args, &block)
-        execute_call(block, *args) { |c, *a| c.run!(*a) }
+      def method_added(name)
+        return unless name == :call
+        super(name)
       end
 
-      private
-
-      def execute_call(command_block, *args)
-        # Run the Command and capture the result
-        command = self.new
-        result  = command.tap { yield(command, *args) }.result
-
-        # Throw an exception if we don't return a result
-        raise CommandNotImplementedError unless result.is_a? Result
-
-        # Run the command block if one was provided
-        unless command_block.nil?
-          matcher = Slayer::ResultMatcher.new(result, command)
-
-          command_block.call(matcher)
-
-          # raise error if not all defaults were handled
-          unless matcher.handled_defaults?
-            raise(CommandResultNotHandledError, 'The pass or fail condition of a result was not handled')
-          end
-
-          begin
-            matcher.execute_matching_block
-          ensure
-            matcher.execute_ensure_block
-          end
-        end
-
-        return result
+      def call(*args, &block)
+        self.new.call(*args, &block)
       end
-    end # << self
-
-    def run(*args)
-      call(*args)
-    rescue CommandFailureError
-      # Swallow the Command Failure
-    end
-
-    # Run the Command
-    def run!(*args)
-      call(*args)
-    end
-
-    # Fail the Command
-
-    def fail!(value: nil, status: :default, message: nil)
-      @result = Result.new(value, status, message)
-      @result.fail!
-    end
-
-    # Pass the Command
-    def pass!(value: nil, status: :default, message: nil)
-      @result = Result.new(value, status, message)
     end
 
-    # Call the command
     def call
       raise NotImplementedError, 'Commands must define method `#call`.'
     end

data/lib/slayer/errors.rb

@@ -1,5 +1,5 @@
 module Slayer
-  class CommandFailureError < StandardError
+  class ResultFailureError < StandardError
     attr_reader :result
 
     def initialize(result)
@@ -10,13 +10,12 @@ module Slayer
 
   class CommandNotImplementedError < StandardError
     def initialize(message = nil)
-      message ||= 'Command implementation must call `fail!` or `pass!`, or '\
-                  'return a <Slayer::Result> object'
+      message ||= 'Command implementation must return a <Slayer::Result> object'
       super message
     end
   end
 
-  class CommandResultNotHandledError < StandardError; end
+  class ResultNotHandledError < StandardError; end
   class FormValidationError < StandardError; end
   class ServiceDependencyError < StandardError; end
 end

data/lib/slayer/hook.rb

@@ -0,0 +1,154 @@
+module Slayer
+  # Hook adds the ability to wrap all calls to a class in a wrapper method. The
+  # wrapper method is provided with a block that can be used to invoke the called
+  # method.
+  #
+  # The methods #skip_hook and #only_hook can be used to control which methods are
+  # and are not wrapped with the hook call.
+  #
+  # @example Including Hook on a class.
+  #   class MyHookedClass
+  #     include Hook
+  #
+  #     hook :say_hello_and_goodbye
+  #
+  #     def self.say_hello_and_goodbye
+  #       puts "hello!"
+  #
+  #       yield # calls hooked method
+  #
+  #       puts "goodbye!"
+  #     end
+  #
+  #     def self.say_something
+  #       puts "something"
+  #     end
+  #   end
+  #
+  #   MyHookedClass.say_something
+  #    # => "hello!"
+  #    #    "something"
+  #    #    "goodbye!"
+  #
+  # @example Skipping Hooks
+  #
+  # skip_hook :say_something, :do_something # the hook method will not be invoked for
+  #                                         # these methods. They will be called directly.
+  #
+  # @example Only hooking
+  #
+  # only_hook :see_something, :hear_something # These are the only methods that will be
+  #                                           # be hooked. All other methods will be
+  #                                           # called directly.
+  module Hook
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    # Everything in Hook::ClassMethods automatically get extended onto the
+    # class that includes Hook.
+    module ClassMethods
+      # Define the method that will be invoked whenever another method is invoked.
+      # This should be a class method.
+      def hook(hook_method)
+        @__hook = hook_method
+      end
+
+      # Define the set of methods that should always be called directly, and should
+      # never be hooked
+      def skip_hook(*hook_skips)
+        @__hook_skips = hook_skips
+      end
+
+      def singleton_skip_hook(*hook_skips)
+        @__singleton_hook_skips = hook_skips
+      end
+
+      # If only_hook is called then only the methods provided will be hooked. All
+      # other methods will be called directly.
+      def only_hook(*hook_only)
+        @__hook_only = hook_only
+      end
+
+      private
+
+        def __hook
+          @__hook ||= nil
+        end
+
+        def __hook_skips
+          @__hook_skips ||= []
+        end
+
+        def __singleton_hook_skips
+          @__singleton_hook_skips ||= []
+        end
+
+        def __hook_only
+          @__hook_only ||= nil
+        end
+
+        def __current_methods
+          @__current_methods ||= nil
+        end
+
+        def run_hook(name, instance, passed_block, &block)
+          if __hook
+            send(__hook, name, instance, passed_block, &block)
+          else
+            # rubocop:disable Performance/RedundantBlockCall
+            block.call
+            # rubocop:enable Performance/RedundantBlockCall
+          end
+        end
+
+        def singleton_method_added(name)
+          insert_hook_for(name,
+                          define_method_fn: :define_singleton_method,
+                          hook_target: self,
+                          alias_target: singleton_class,
+                          skip_methods: blacklist(__singleton_hook_skips))
+        end
+
+        def method_added(name)
+          insert_hook_for(name,
+                          define_method_fn: :define_method,
+                          hook_target: self,
+                          alias_target: self,
+                          skip_methods: blacklist(__hook_skips))
+        end
+
+        def insert_hook_for(name, define_method_fn:, hook_target:, alias_target:, skip_methods: [])
+          return if __current_methods && __current_methods.include?(name)
+
+          with_hooks = :"__#{name}_with_hooks"
+          without_hooks = :"__#{name}_without_hooks"
+
+          return if __hook_only && !__hook_only.include?(name.to_sym)
+          return if skip_methods.include? name.to_sym
+
+          @__current_methods = [name, with_hooks, without_hooks]
+          send(define_method_fn, with_hooks) do |*args, &block|
+            hook_target.send(:run_hook, name, self, block) do
+              send(without_hooks, *args)
+            end
+          end
+
+          alias_target.send(:alias_method, without_hooks, name)
+          alias_target.send(:alias_method, name, with_hooks)
+
+          @__current_methods = nil
+        end
+
+        def blacklist(additional = [])
+          list = Object.methods(false) + Object.private_methods(false)
+          list += Slayer::Hook::ClassMethods.private_instance_methods(false)
+          list += Slayer::Hook::ClassMethods.instance_methods(false)
+          list += additional
+          list << __hook if __hook
+
+          list
+        end
+    end
+  end
+end

data/lib/slayer/result.rb

@@ -13,12 +13,12 @@ module Slayer
     end
 
     def failure?
-      @failure || false
+      @failure ||= false
     end
 
-    def fail!
-      @failure = true
-      raise CommandFailureError, self
+    def fail
+      @failure ||= true
+      self
     end
   end
 end

data/lib/slayer/result_matcher.rb

@@ -30,7 +30,7 @@ module Slayer
   #
   # If the block form of a {Command.call} is invoked, both the block must handle the default
   # status for both a {Result#success?} and a {Result#failure?}. If both are not handled,
-  # the matching block will not be invoked and a {CommandResultNotHandledError} will be
+  # the matching block will not be invoked and a {ResultNotHandledError} will be
   # raised.
   #
   # @example Matcher invokes the matching pass block, with precedence given to {#pass} and {#fail}
@@ -74,7 +74,7 @@ module Slayer
   #     m.pass(:ok) { puts "Pass, OK!"}
   #     m.fail      { puts "Fail!" }
   #   end
-  #   # => raises CommandResultNotHandledError (because no default pass was provided)
+  #   # => raises ResultNotHandledError (because no default pass was provided)
   #
   #   # Call produces a successful Result with status :ok
   #   SuccessCommand.call do |m|
@@ -94,7 +94,7 @@ module Slayer
   #   SuccessCommand.call do |m|
   #     m.pass(:ok, :default) { puts "Pass, OK!"}
   #   end
-  #   # => raises CommandResultNotHandledError (because no default fail was provided)
+  #   # => raises ResultNotHandledError (because no default fail was provided)
   class ResultMatcher
     attr_reader :result, :command
 

data/lib/slayer/rspec.rb

@@ -0,0 +1,42 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :be_success_result do
+  match do |result|
+    result.success?
+  end
+
+  chain :with_status do |status|
+    @status = status
+  end
+
+  failure_message do |result|
+    return 'expected command to succeed' if @status.nil?
+    return "expected command to succeed with status :#{@status}, but got :#{result.status}"
+  end
+
+  failure_message_when_negated do |result|
+    return "expected command not to have status :#{@status}" if @status.present? && result.status == @status
+    return 'expected command to fail'
+  end
+end
+
+RSpec::Matchers.define :be_failed_result do
+  match do |result|
+    return result.failure? if @status.nil?
+    return result.failure? && (result.status == @status)
+  end
+
+  chain :with_status do |status|
+    @status = status
+  end
+
+  failure_message do |result|
+    return 'expected command to fail' if @status.nil?
+    return "expected command to fail with status :#{@status}, but got :#{result.status}"
+  end
+
+  failure_message_when_negated do |result|
+    return "expected command not to have status :#{@status}" if @status.present? && result.status == @status
+    return 'expected command to succeed'
+  end
+end

data/lib/slayer/service.rb

@@ -1,182 +1,98 @@
 module Slayer
   # Slayer Services are objects that should implement re-usable pieces of
-  # application logic or common tasks. To prevent circular dependencies Services
-  # are required to declare which other Service classes they depend on. If a
-  # circular dependency is detected an error is raised.
-  #
-  # In order to enforce the lack of circular dependencies, Service objects can
-  # only call other Services that are declared in their dependencies.
+  # application logic or common tasks. All methods in a service are wrapped
+  # by default to enforce the return of a +Slayer::Result+ object.
   class Service
-    # List the other Service class that this service class depends on. Only
-    # dependencies that are included in this call my be invoked from class
-    # or instances methods of this service class.
-    #
-    # If no dependencies are provided, no other Service classes may be used by
-    # this Service class.
-    #
-    # @param deps [Array<Class>] An array of the other Slayer::Service classes that are used as dependencies
-    #
-    # @example Service calls with dependency declared
-    #   class StripeService < Slayer::Service
-    #     dependencies NetworkService
-    #
-    #     def self.pay()
-    #       ...
-    #       NetworkService.post(url: "stripe.com", body: my_payload) # OK
-    #       ...
-    #     end
-    #   end
-    #
-    # @example Service calls without a dependency declared
-    #   class JiraApiService < Slayer::Service
-    #
-    #     def self.create_issue()
-    #       ...
-    #       NetworkService.post(url: "stripe.com", body: my_payload) # Raises Slayer::ServiceDependencyError
-    #       ...
-    #     end
-    #   end
-    #
-    # @return [Array<Class>] The transitive closure of dependencies for this object.
-    def self.dependencies(*deps)
-      raise(ServiceDependencyError, "There were multiple dependencies calls of #{self}") if @deps
-
-      deps.each do |dep|
-        unless dep.is_a?(Class)
-          raise(ServiceDependencyError, "The object #{dep} passed to dependencies service was not a class")
-        end
-
-        unless dep < Slayer::Service
-          raise(ServiceDependencyError, "The object #{dep} passed to dependencies was not a subclass of #{self}")
-        end
-      end
+    include Hook
 
-      unless deps.uniq.length == deps.length
-        raise(ServiceDependencyError, "There were duplicate dependencies in #{self}")
-      end
-
-      @deps = deps
+    skip_hook :pass, :flunk, :flunk!, :try!
+    singleton_skip_hook :pass, :flunk, :flunk!, :try!
 
-      # Calculate the transitive dependencies and raise an error if there are circular dependencies
-      transitive_dependencies
-    end
+    attr_accessor :result
 
     class << self
+      # Create a passing Result
+      def pass(value: nil, status: :default, message: nil)
+        Result.new(value, status, message)
+      end
 
-      attr_reader :deps
-
-      def transitive_dependencies(dependency_hash = {}, visited = [])
-        return @transitive_dependencies if @transitive_dependencies
-
-        @deps ||= []
+      # Create a failing Result
+      def flunk(value: nil, status: :default, message: nil)
+        Result.new(value, status, message).fail
+      end
 
-        # If we've already visited ourself, bail out. This is necessary to halt
-        # execution for a circular chain of dependencies. #halting-problem-solved
-        return dependency_hash[self] if visited.include?(self)
+      # Create a failing Result and halt execution of the Command
+      def flunk!(value: nil, status: :default, message: nil)
+        raise ResultFailureError, flunk(value: value, status: status, message: message)
+      end
 
-        visited << self
-        dependency_hash[self] ||= []
+      # If the block produces a successful result the value of the result will be
+      # returned. Otherwise, this will create a failing result and halt the execution
+      # of the Command.
+      def try!(value: nil, status: nil, message: nil)
+        r = yield
+        flunk!(value: value, status: status || :default, message: message) unless r.is_a?(Result)
+        return r.value if r.success?
+        flunk!(value: value || r.value, status: status || r.status, message: message || r.message)
+      end
+    end
 
-        # Add each of our dependencies (and it's transitive dependency chain) to our
-        # own dependencies.
+    def pass(*args)
+      self.class.pass(*args)
+    end
 
-        @deps.each do |dep|
-          dependency_hash[self] << dep
+    def flunk(*args)
+      self.class.flunk(*args)
+    end
 
-          unless visited.include?(dep)
-            child_transitive_dependencies = dep.transitive_dependencies(dependency_hash, visited)
-            dependency_hash[self].concat(child_transitive_dependencies)
-          end
+    def flunk!(*args)
+      self.class.flunk!(*args)
+    end
 
-          dependency_hash[self].uniq
-        end
+    def try!(*args, &block)
+      self.class.try!(*args, &block)
+    end
 
-        # NO CIRCULAR DEPENDENCIES!
-        if dependency_hash[self].include? self
-          raise(ServiceDependencyError, "#{self} had a circular dependency")
-        end
+    # Make sure child classes also hook correctly
+    def self.inherited(klass)
+      klass.include Hook
+      klass.hook :__service_hook
+    end
 
-        # Store these now, so next time we can short-circuit.
-        @transitive_dependencies = dependency_hash[self]
+    hook :__service_hook
 
-        return @transitive_dependencies
+    # rubocop:disable Metrics/MethodLength
+    def self.__service_hook(_, instance, service_block)
+      begin
+        result = yield
+      rescue ResultFailureError => error
+        result = error.result
       end
 
-      def before_each_method(*)
-        @deps ||= []
-        @@allowed_services ||= nil
+      raise CommandNotImplementedError unless result.is_a? Result
 
-        # Confirm that this method call is allowed
-        raise_if_not_allowed
+      unless service_block.nil?
+        matcher = Slayer::ResultMatcher.new(result, instance)
 
-        @@allowed_services ||= []
-        @@allowed_services << (@deps + [self])
-      end
+        service_block.call(matcher)
 
-      def raise_if_not_allowed
-        if @@allowed_services
-          allowed = @@allowed_services.last
-          if !allowed || !allowed.include?(self)
-            raise(ServiceDependencyError, "Attempted to call #{self} from another #{Slayer::Service}"\
-                                          ' which did not declare it as a dependency')
-          end
+        # raise error if not all defaults were handled
+        unless matcher.handled_defaults?
+          raise(ResultNotHandledError, 'The pass or fail condition of a result was not handled')
         end
-      end
 
-      def after_each_method(*)
-        @@allowed_services.pop
-        @@allowed_services = nil if @@allowed_services.empty?
-      end
-
-      def singleton_method_added(name)
-        return if self == Slayer::Service
-        return if @__last_methods_added && @__last_methods_added.include?(name)
-
-        with = :"#{name}_with_before_each_method"
-        without = :"#{name}_without_before_each_method"
-
-        @__last_methods_added = [name, with, without]
-        define_singleton_method with do |*args, &block|
-          before_each_method name
-          begin
-            send without, *args, &block
-          rescue
-            raise
-          ensure
-            after_each_method name
-          end
+        begin
+          matcher.execute_matching_block
+        ensure
+          matcher.execute_ensure_block
         end
-
-        singleton_class.send(:alias_method, without, name)
-        singleton_class.send(:alias_method, name, with)
-
-        @__last_methods_added = nil
       end
+      return result
+    end
+    # rubocop:enable Metrics/MethodLength
 
-      def method_added(name)
-        return if self == Slayer::Service
-        return if @__last_methods_added && @__last_methods_added.include?(name)
-
-        with = :"#{name}_with_before_each_method"
-        without = :"#{name}_without_before_each_method"
-
-        @__last_methods_added = [name, with, without]
-        define_method with do |*args, &block|
-          self.class.before_each_method name
-          begin
-            send without, *args, &block
-          rescue
-            raise
-          ensure
-            self.class.after_each_method name
-          end
-        end
-
-        alias_method without, name
-        alias_method name, with
+    private_class_method :inherited
+    private_class_method :__service_hook
 
-        @__last_methods_added = nil
-      end
-    end # << self
   end # class Service
 end # module Slayer

data/lib/slayer/version.rb

@@ -1,3 +1,3 @@
 module Slayer
-  VERSION = '0.3.1'
+  VERSION = '0.4.0.beta2'
 end

data/slayer.gemspec

@@ -1,4 +1,4 @@
-# coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'slayer/version'
@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Wyatt Kirby', 'Noah Callaway']
   spec.email         = ['wyatt@apsis.io', 'noah@apsis.io']
 
-  spec.summary       = %q{A killer service layer}
+  spec.summary       = 'A killer service layer'
   spec.homepage      = 'http://www.apsis.io'
   spec.license       = 'MIT'
 
@@ -19,16 +19,15 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'virtus', '~> 1.0'
-  spec.add_dependency 'dry-validation', '~> 0.10'
 
-  spec.add_development_dependency 'coveralls'
-  spec.add_development_dependency 'simplecov', '~> 0.13'
   spec.add_development_dependency 'bundler', '~> 1.12'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'byebug', '~> 9.0'
+  spec.add_development_dependency 'coveralls'
   spec.add_development_dependency 'minitest', '~> 5.0'
   spec.add_development_dependency 'minitest-reporters', '~> 1.1'
   spec.add_development_dependency 'mocha', '~> 1.2'
-  spec.add_development_dependency 'byebug', '~> 9.0'
+  spec.add_development_dependency 'rubocop', '~> 0.48.1'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'simplecov', '~> 0.13'
   spec.add_development_dependency 'yard', '~> 0.9'
-  spec.add_development_dependency 'rubocop', '~> 0.47.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slayer
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0.beta2
 platform: ruby
 authors:
 - Wyatt Kirby
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2018-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -26,131 +26,131 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: dry-validation
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
-  type: :runtime
+        version: '1.12'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '9.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: minitest-reporters
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 0.48.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 0.48.1
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '0.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '0.13'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -165,20 +165,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.47.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.47.1
 description: 
 email:
 - wyatt@apsis.io
@@ -205,8 +191,10 @@ files:
 - lib/slayer/command.rb
 - lib/slayer/errors.rb
 - lib/slayer/form.rb
+- lib/slayer/hook.rb
 - lib/slayer/result.rb
 - lib/slayer/result_matcher.rb
+- lib/slayer/rspec.rb
 - lib/slayer/service.rb
 - lib/slayer/version.rb
 - slayer.gemspec
@@ -226,12 +214,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: A killer service layer