skywalker 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f34e5d3df438e1dded141d4b9e093785bb392cdd
-  data.tar.gz: e108b0e461eddb8f298ca5c771a0baf988e6c86f
+  metadata.gz: 2ff0a320a2103cf8829980f9ef745f34ea00ebc6
+  data.tar.gz: 4c04009e7c751282cd1f6b0d88d0e0e046486276
 SHA512:
-  metadata.gz: 2f0fe7a5edd3bc67f0478dc91369e10001ce9fb037a464cde6016241f202f1afc724d2b879e95e8198d1eda1663448984d9ec81e278df20687e65399f5f97f92
-  data.tar.gz: 53d3eff371345c36dbe9ea155a29fbbad8806743ddac162abfda4e8c3c9557b6a9df224f56c6cfe63d72b8ac83f807eb9f01075d3149242c6da024c6b8b7c99d
+  metadata.gz: d74caa0e24ad0681fdf6133eecf290967059090c09892932c3450aa04f1c97da3e770bfa36eda60fc31a8d4b628f4131253fe4e3a38061086312ab03762e711f
+  data.tar.gz: a381af6335e0eb034047bec3877434271be6dd1e6d32a19cb40974e0c37eabd723f8c7c6ec5c8b37549293afca5691adeef6d0f5580bda3e73ba5fcf3e897bd8

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 All commits by Rob Yurkowski unless otherwise noted.
 
+## 2.2.0 (2016-06-21)
+
+- Extracts command behaviour to `Skywalker::Callable` and
+  `Skywalker::Transactional`.
+
+  This simplifies the `Command` object, making it basically a combination of
+  `Callable` and `Transactional` mixins. It also allows for the reuse of the
+  constituent parts on a larger scale.
+
+- Remove dependency on `ActiveRecord`.
+
+  We now do a check to see if ActiveRecord is defined. If not, we simply default
+  to calling the passed block. This allows us to avoid having to require
+  ActiveRecord, which lightens our dependencies and also makes us feel just a
+  tiny bit less dirty.
+
 ## 2.1.0 (2015-05-14)
 
 - Yields self to any block given to any object implementing `Skywalker::Acceptable`.

data/README.md

@@ -1,11 +1,16 @@
 # Skywalker
 
-Skywalker is a gem that provides a simple command pattern for applications that use transactions.
+Skywalker is a gem that provides a simple command pattern for applications that
+use transactions. (Or not! In later versions, Skywalker is much more modular and
+can be [used for non-transactional purposes](#components), too.)
 
 ## Why Skywalker?
 
-It's impossible to come up with a single-word name for a gem about commands that's at least marginally
-witty. If you can't achieve wit or cleverness, at least achieve topicality, right?
+Because "Commander Skywalker".
+
+It's impossible to come up with a single-word name for a gem about commands
+that's at least marginally witty. If you can't achieve wit or cleverness, at
+least achieve topicality, right?
 
 ## What is a command?
 
@@ -17,40 +22,47 @@ considering transactional blocks as objects:
 
 ### Testability
 
-With a command, you inject most any argument, which means that you can simulate
-the run of the command without providing real arguments. Best practice is to
-describe the operations in methods, which can then be stubbed out to test small
-portions in isolation.
+Skywalker places a strong emphasis on dependency injection.
+
+This means that you can unit test the command for correctness without having to
+do a full integration test for every single path through the code. That makes
+your test suite lean and mean, and encourages you to aim for weaker forms of
+coupling (i.e. preferring connascence of name, rather than identity).
+
+Best practice is to describe the operations in methods, which can then be
+stubbed out to test small portions in isolation.
 
-This also allows you to make the reasonable inference that the command will abort
-properly if one step raises an error, and by convention, the same method (`on_failure`)
-will be called. In most cases, you can thereby verify happy path and a single bad path
-through integration specs, and that will suffice.
+This also allows you to make the reasonable inference that the command will
+abort properly if one step raises an error, and by convention, the same method
+(`on_failure`) will be called. In most cases, you can thereby verify happy path
+and a single bad path through integration specs, and that will suffice.
 
 ### Reasonability
 
-The benefit of abstraction means that you can easily reason about a command without
-having to know its internals. Standard caveats apply, but if you have a `CreateGroup`
-command, you should be able to infer that calling the command with the correct arguments
-will produce the expected result.
+The benefit of abstraction means that you can easily reason about a command
+without having to know its internals. Standard caveats apply, but if you have a
+`CreateGroup` command, you should be able to infer that calling the command with
+the correct arguments will produce the expected result, rather than having to
+remember all the side effects of an operation.
 
 ### Knowledge of Results Without Knowledge of Response
 
-A command prescriptively takes callbacks or `#call`able objects, which can be called
-depending on the result of the command. By default, `Skywalker::Command` can handle
-an `on_success` and an `on_failure` callback, which are called after their respective
-results. You can define these in your controllers, which lets you run the same command
-but respond in unique ways, and keeps controller concerns inside the controller.
+A command prescriptively takes callbacks or `#call`able objects, which can be
+called depending on the result of the command. By default, `Skywalker::Command`
+can handle an `on_success` and an `on_failure` callback, which are called after
+their respective results. You can define these in your controllers, which lets
+you run the same command but respond in unique ways, and keeps controller
+concerns inside the controller.
 
-You can also easily override which callbacks are run. Need to run a different callback
-if `request.xhr?`? Simply override `run_success_callbacks` and `run_failure_callbacks`
-and call your own.
+You can also easily override which callbacks are run. Need to run a different
+callback if `request.xhr?`? Simply override `run_success_callbacks` and
+`run_failure_callbacks` and call your own.
 
 ### A Gateway to Harder Architectures
 
-It's not hard to create an `Event` class and step up toward full event sourcing, or to
-go a bit further and implement full CQRS. This is the architectural pattern your parents
-warned you about.
+It's not hard to create an `Event` class and step up toward full event sourcing,
+or to go a bit further and implement full CQRS. This is the architectural
+pattern your parents warned you about.
 
 ## Installation
 
@@ -70,11 +82,11 @@ Or install it yourself as:
 
 ## Usage
 
-Let's talk about a situation where you're creating a group and sending an email inside a
-Rails app.
+Let's talk about a situation where you're creating a group and sending an email
+inside a Rails app.
 
-Standard operating procedure usually falls into one of two patterns, both of which are
-mediocre. The first makes use of ActiveRecord callbacks:
+Standard operating procedure usually falls into one of two patterns, both of
+which are mediocre. The first makes use of ActiveRecord callbacks:
 
 ```ruby
 # app/controllers/groups_controller.rb
@@ -106,14 +118,14 @@ class Group < ActiveRecord::Base
 end
 ```
 
-This might seem concise because it keeps the controller small. (Fat model,
-thin controller has been a plank of Rails development for a while, but it's
-slowly going away, thank heavens). But there are two problems here:
-first, it introduces a point of coupling between the model and the mailer,
-which not only makes testing slower, it means that these two objects are
-now entwined. Create a group through the Rails console? You're sending an email with
-no way to skip that. Secondly, it reduces the reasonability of the code. When you
-look at the `GroupsController`, you can't suss out the fact that this sends an email.
+This might seem concise because it keeps the controller small. (Fat model, thin
+controller has been a plank of Rails development for a while, but it's slowly
+going away, thank heavens). But there are two problems here: first, it
+introduces a point of coupling between the model and the mailer, which not only
+makes testing slower, it means that these two objects are now entwined. Create a
+group through the Rails console? You're sending an email with no way to skip
+that. Secondly, it reduces the reasonability of the code. When you look at the
+`GroupsController`, you can't suss out the fact that this sends an email.
 
 **Moral #1: Orthogonal concerns should not be put into ActiveRecord callbacks.**
 
@@ -138,21 +150,24 @@ class GroupsController < ApplicationController
 end
 ```
 
-This is more reasonable, but it's longer in the controller and at some point your eyes
-begin to glaze over. Imagine as these orthogonal concerns grow longer and longer. Maybe
-you're sending a tweet about the group, scheduling a background job to update some thumbnails,
-or hitting a webhook URL. You're losing the reasonability of the code because of the detail.
+This is more reasonable, but it's longer in the controller and at some point
+your eyes begin to glaze over. Imagine as these orthogonal concerns grow longer
+and longer. Maybe you're sending a tweet about the group, scheduling a
+background job to update some thumbnails, or hitting a webhook URL. You're
+losing the reasonability of the code because of the detail.
 
-Moreover, imagine that the group email being sent contains critical instructions on how
-to proceed. What if `NotificationMailer` has a syntax error? The group is created, but the
-mail won't be sent. Now the user hasn't gotten a good error, and your database is potentially
-fouled up by half-performed requests. You can run this in a transaction, but that does not
-reduce the complexity contained within the controller. 
+Moreover, imagine that the group email being sent contains critical instructions
+on how to proceed. What if `NotificationMailer` has a syntax error? The group is
+created, but the mail won't be sent. Now the user hasn't gotten a good error,
+and your database is potentially fouled up by half-performed requests. You can
+run this in a transaction, but that does not reduce the complexity contained
+within the controller. 
 
-**Moral #2: Rails controllers should dispatch to application logic, and receive instructions on how to respond.**
+**Moral #2: Rails controllers should dispatch to application logic, and receive
+instructions on how to respond.**
 
-The purpose of the command is to group orthogonal but interdependent results into logical operations. Here's how that
-looks with a `Skywalker::Command`:
+The purpose of the command is to group orthogonal but interdependent results
+into logical operations. Here's how that looks with a `Skywalker::Command`:
 
 
 ```ruby
@@ -239,13 +254,19 @@ command = AddGroupCommand.call(
 
 ```
 
-You can pass any object responding to `#call` to the `on_success` and `on_failure` handlers, including procs, lambdas, controller methods, or other commands themselves.
+You can pass any object responding to `#call` to the `on_success` and
+`on_failure` handlers, including procs, lambdas, controller methods, or other
+commands themselves.
 
 ### What happens when callbacks fail?
 
-Exceptions thrown inside the success callbacks (`on_success` or your own callbacks defined in `run_success_callbacks`) will cause the command to fail and run the failure callbacks.
+Exceptions thrown inside the success callbacks (`on_success` or your own
+callbacks defined in `run_success_callbacks`) will cause the command to fail and
+run the failure callbacks.
 
-Exceptions thrown inside the failure callbacks (`on_failure` or your own callbacks defined in `run_failure_callbacks`) will not be caught and will bubble out of the command.
+Exceptions thrown inside the failure callbacks (`on_failure` or your own
+callbacks defined in `run_failure_callbacks`) will not be caught and will bubble
+out of the command.
 
 ### Overriding Methods
 
@@ -254,39 +275,63 @@ The following methods are overridable for easy customization:
 - `execute!`
   - Define your operations here.
 - `required_args`
-  - An array of expected keys given to the command. Raises `ArgumentError` if keys are missing.
+  - An array of expected keys given to the command. Raises `ArgumentError` if
+    keys are missing.
 - `validate_arguments!`
-  - Checks required args are present, but can be customized. All instance variables are set by this point.
+  - Checks required args are present, but can be customized. All instance
+    variables are set by this point.
 - `transaction(&block)`
-  - Uses an `ActiveRecord::Base.transaction` by default, but can be customized. `execute!` runs inside of this.
+  - Uses an `ActiveRecord::Base.transaction` by default, but can be customized.
+    `execute!` runs inside of this.
 - `confirm_success`
   - Fires off callbacks on command success (i.e. non-error).
 - `run_success_callbacks`
-  - Dictates which success callbacks are run. Defaults to `on_success` if defined.
+  - Dictates which success callbacks are run. Defaults to `on_success` if
+    defined.
 - `confirm_failure`
-  - Fires off callbacks on command failure (i.e. erroneous state), and sets the exception as `command.error`.
+  - Fires off callbacks on command failure (i.e. erroneous state), and sets the
+    exception as `command.error`.
 - `run_failure_callbacks`
-  - Dictates which failure callbacks are run. Defaults to `on_failure` if defined.
+  - Dictates which failure callbacks are run. Defaults to `on_failure` if
+    defined.
 
-For further reference, simply see the command file. It's less than 90 LOC and well-commented.
+For further reference, simply see the command file. It's less than 90 LOC and
+well-commented.
 
 ## Testing (and TDD)
 
-Take a look at the `examples` directory, which uses example as above of a notifier, but makes it a bit more complicated: it assumes that we only send emails if the user (which we'll pass in) has a preference set to receive email.
+Take a look at the `examples` directory, which uses example as above of a
+notifier, but makes it a bit more complicated: it assumes that we only send
+emails if the user (which we'll pass in) has a preference set to receive email.
 
 ### Assumptions
 
 Here's what you can assume in your tests:
 
-1. Arguments that are present in the list of required_args will throw an error before the command executes if they are not passed.
-2. Operations that throw an error will abort the command and trigger its failure state.
-3. Calling `Command.new().call` is functionally equivalent to calling `Command.call()`
+1. Arguments that are present in the list of required_args will throw an error
+   before the command executes if they are not passed.
+2. Operations that throw an error will abort the command and trigger its failure
+   state.
+3. Calling `Command.new().call` is functionally equivalent to calling
+   `Command.call()`
 
 ### Strategy
 
-There are two tests that you need to write. First, you'll want to write a Command spec, which are very simplistic specs and should be used to verify the validity of the command in isolation from the rest of the system. (This is what the example shows.) You'll also want to write some high-level integration tests to make sure that the command is implemented correctly inside your controller, and has the expected system-wide results. You shouldn't need to write integration specs to test every path -- it should suffice to test a successful path and a failing path, though your situation may vary depending on the detail of error handling you perform.
+There are two tests that you need to write. First, you'll want to write a
+Command spec, which are very simplistic specs and should be used to verify the
+validity of the command in isolation from the rest of the system. (This is what
+the example shows.)
 
-Here's one huge benefit: with a few small steps, you won't need to include `rails_helper` to boot up the entire environment. That means blazingly fast tests. All you need to do is stub `transaction` on your command, like so:
+You'll also want to write some high-level integration tests to make sure that
+the command is implemented correctly inside your controller, and has the
+expected system-wide results. You shouldn't need to write integration specs to
+test every path -- it should suffice to test a successful path and a failing
+path, though your situation may vary depending on the detail of error handling
+you perform.
+
+Here's one huge benefit: with a few small steps, you won't need to include
+`rails_helper` to boot up the entire environment. That means blazingly fast
+tests. All you need to do is stub `transaction` on your command, like so:
 
 ```ruby
 RSpec.describe CreateGroupCommand do
@@ -311,8 +356,96 @@ undefined method `call' for nil:NilClass
   # .../lib/skywalker/command.rb:118:in `run_failure_callbacks'
 ```
 
-This means that the command failed and you didn't specify an `on_failure` callback. You can stick a debugger
-inside of `run_failure_callbacks`, and get the failure exception as `self.error`. You can also reraise the exceptiong to achieve a better result summary, but this is not done by default, as you may also want to test error handling.
+This means that the command failed and you didn't specify an `on_failure`
+callback. You can stick a debugger inside of `run_failure_callbacks`, and get
+the failure exception as `self.error`. You can also reraise the exception to
+achieve a better result summary, but this is not done by default, as you may
+also want to test error handling.
+
+## Components
+
+A `Skywalker::Command` is implemented through a series of modules that can be
+used independently from each other and outside of the context of the `Command`
+object.
+
+### `Acceptable`
+
+`Skywalker::Acceptable` allows an object to receive a keyword list of arguments
+upon instantiation. It creates a reader and writer for each keyword that doesn't
+already have one, and it will raise an error for any keyword not given that is
+present inside its `required_args` list.
+
+Example:
+
+```ruby
+require 'skywalker/acceptable'
+
+class MyClass
+  include Skywalker::Acceptable
+
+  def required_args
+    %w(baz)
+  end
+
+  def bar
+    "definitely not #{@bar}"
+  end
+
+  def baz=(int)
+    @baz = int.to_s.reverse.to_i
+  end
+end
+
+
+MyClass.new(foo: "abc", bar: "xyz") # => ArgumentError, "baz required but not given"
+
+instance = MyClass.new(foo: "abc", bar: "xyz", baz: 123) # => <MyClass#...>
+
+instance.foo # => "abc"
+instance.bar # => "definitely not xyz"
+instance.baz # => 321
+```
+
+
+### `Callable`
+
+A very simple module that allows a class to implement `self.call`, which
+forwards any arguments to a new instance and then calls that instance.
+
+Example:
+
+```ruby
+require 'skywalker/callable'
+
+class MyClass
+  include Skywalker::Callable
+
+  def initialize(message)
+    @message = message
+  end
+
+  def call
+    @message
+  end
+end
+
+
+MyClass.new("Hello World").call # => Hello World
+MyClass.call("Hello World 2") # => Hello World 2
+```
+
+Tiny but convenient.
+
+### `Transactional`
+
+Will include `Acceptable`.
+
+Implements the core transactional logic used by `Skywalker::Command`.
+
+Makes `call` open a transaction, running `execute!` and calling
+`confirm_success` or `confirm_failure` as appropriate.
+
+For example, see `Skywalker::Command` documentation above.
 
 ## Contributing
 

data/examples/Gemfile.lock

@@ -1,33 +1,14 @@
 PATH
   remote: ../
   specs:
-    skywalker (2.1.0)
-      activerecord (>= 4.0)
+    skywalker (2.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.1)
-      activesupport (= 4.2.1)
-      builder (~> 3.1)
-    activerecord (4.2.1)
-      activemodel (= 4.2.1)
-      activesupport (= 4.2.1)
-      arel (~> 6.0)
-    activesupport (4.2.1)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    arel (6.0.0)
-    builder (3.2.2)
     coderay (1.1.0)
     diff-lcs (1.2.5)
-    i18n (0.7.0)
-    json (1.8.2)
     method_source (0.8.2)
-    minitest (5.6.1)
     pry (0.10.1)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
@@ -45,9 +26,6 @@ GEM
       rspec-support (~> 3.1.0)
     rspec-support (3.1.2)
     slop (3.6.0)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
@@ -56,3 +34,6 @@ DEPENDENCIES
   pry
   rspec
   skywalker!
+
+BUNDLED WITH
+   1.12.1

data/lib/skywalker/callable.rb

@@ -0,0 +1,30 @@
+module Skywalker
+  module Callable
+
+    #
+    # Extend instead of include because we'd prefer to keep a uniform interface
+    # among Skywalker extensions, and we have in the past had additional
+    # instance methods defined herein.
+    #
+    # @since 2.2.0
+    #
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+
+    module ClassMethods
+
+      #
+      # Provides a convenient way to call a command without having to instantiate
+      # and call.
+      #
+      # @since 2.2.0
+      #
+      def call(*args)
+        new(*args).call
+      end
+    end
+  end
+end
+

data/lib/skywalker/command.rb

@@ -1,112 +1,9 @@
-require 'active_record'
-require 'skywalker/acceptable'
+require 'skywalker/callable'
+require 'skywalker/transactional'
 
 module Skywalker
   class Command
-    include Acceptable
-
-    ################################################################################
-    # Class interface
-    ################################################################################
-
-    #
-    # Provides a convenient way to call a command without having to instantiate
-    # and call.
-    #
-    # @since 1.0.0
-    #
-    def self.call(*args)
-      new(*args).call
-    end
-
-
-    attr_accessor :on_success,
-                  :on_failure,
-                  :error
-
-
-    #
-    # Call: runs the transaction and all operations.
-    #
-    # @since 1.0.0
-    #
-    def call
-      transaction do
-        execute!
-
-        confirm_success
-      end
-
-    rescue Exception => error
-      confirm_failure error
-    end
-
-
-    #
-    # Procedural execution method. This should be implemented inside subclasses
-    # to add operations.
-    #
-    # @since 1.0.0
-    #
-    protected def execute!
-    end
-
-
-    ################################################################################
-    # Private interface
-    ################################################################################
-
-
-    #
-    # Wraps the given block in transactional logic.
-    #
-    # @since 1.0.0
-    #
-    private def transaction(&block)
-      ::ActiveRecord::Base.transaction(&block)
-    end
-
-    #
-    # Triggers the given callback on success
-    #
-    # @since 1.0.0
-    #
-    private def confirm_success
-      run_success_callbacks
-    end
-
-
-    #
-    # Runs success callback if given. Override to specify additional callbacks
-    # or to add branching logic here.
-    #
-    # @since 1.1.0
-    #
-    private def run_success_callbacks
-      on_success.call(self) unless on_success.nil?
-    end
-
-
-    #
-    # Triggered on failure of transaction. Sets `#error` so the exception can
-    # be retrieved, and triggers the error callbacks.
-    #
-    # @since 1.0.0
-    #
-    private def confirm_failure(error)
-      self.error = error
-      run_failure_callbacks
-    end
-
-
-    #
-    # Runs failure callback if given. Override to specify additional callbacks
-    # or to add branching logic here.
-    #
-    # @since 1.1.0
-    #
-    private def run_failure_callbacks
-      on_failure.call(self) unless on_failure.nil?
-    end
+    include Callable
+    include Transactional
   end
 end

data/lib/skywalker/transactional.rb

@@ -0,0 +1,127 @@
+require 'skywalker/acceptable'
+
+module Skywalker
+  module Transactional
+
+    #
+    # Requires Acceptable and add accessors for callbacks.
+    #
+    # @since 2.2.0
+    #
+    def self.included(klass)
+      klass.include Acceptable
+      klass.send(:attr_accessor, :on_success, :on_failure, :error)
+    end
+
+
+    #
+    # Runs the transaction and all operations.
+    #
+    # @since 2.2.0
+    #
+    def call
+      transaction do
+        execute!
+
+        confirm_success
+      end
+
+    rescue Exception => error
+      confirm_failure error
+    end
+
+
+    #
+    # Procedural execution method. This should be implemented inside subclasses
+    # to add operations.
+    #
+    # @since 2.2.0
+    #
+    protected def execute!
+    end
+
+
+    ################################################################################
+    # Private interface
+    ################################################################################
+
+
+    #
+    # Wraps the given block in transactional logic.
+    #
+    # @since 2.2.0
+    #
+    private def transaction(&block)
+      if active_record_defined?
+        active_record_transaction_method.call(&block)
+      else
+        block.call
+      end
+    end
+
+
+    #
+    # Allows us to artificially declare whether AR is loaded for specs.
+    #
+    # @since 2.2.0
+    #
+    private def active_record_defined?
+      defined?(ActiveRecord)
+    end
+
+    #
+    # Allows us to artificially choose which method to use as the AR
+    # transaction method.
+    #
+    # @since 2.2.0
+    #
+    private def active_record_transaction_method
+      ::ActiveRecord::Base.method(:transaction)
+    end
+
+
+    #
+    # Triggers the given callback on success
+    #
+    # @since 2.2.0
+    #
+    private def confirm_success
+      run_success_callbacks
+    end
+
+
+    #
+    # Runs success callback if given. Override to specify additional callbacks
+    # or to add branching logic here.
+    #
+    # @since 2.2.0
+    #
+    private def run_success_callbacks
+      on_success.call(self) unless on_success.nil?
+    end
+
+
+    #
+    # Triggered on failure of transaction. Sets `#error` so the exception can
+    # be retrieved, and triggers the error callbacks.
+    #
+    # @since 2.2.0
+    #
+    private def confirm_failure(error)
+      self.error = error
+      run_failure_callbacks
+    end
+
+
+    #
+    # Runs failure callback if given. Override to specify additional callbacks
+    # or to add branching logic here.
+    #
+    # @since 2.2.0
+    #
+    private def run_failure_callbacks
+      on_failure.call(self) unless on_failure.nil?
+    end
+
+  end
+end

data/lib/skywalker/version.rb

@@ -1,3 +1,3 @@
 module Skywalker
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

data/skywalker.gemspec

@@ -20,8 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.1.2'
 
-  spec.add_dependency 'activerecord', '>= 4.0'
-
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"

data/spec/lib/skywalker/acceptable_spec.rb

@@ -32,7 +32,7 @@ module Skywalker
 
       it "raises an error if an argument in its required_args is not present" do
         allow_any_instance_of(klass).to receive(:required_args).and_return([:required_arg])
-        expect { klass.new }.to raise_error
+        expect { klass.new }.to raise_error ArgumentError
       end
 
       it "does not raise an error if an argument in its required_args is present" do

data/spec/lib/skywalker/callable_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'skywalker/callable'
+
+module Skywalker
+  RSpec.describe Callable do
+    let(:klass) { Class.new { include Callable } }
+
+    describe ".call" do
+      it "instantiates and calls" do
+        expect(klass).to receive_message_chain('new.call')
+        klass.call
+      end
+    end
+
+
+    describe "#call" do
+      it "raises an error because it is not defined" do
+        instance = klass.new
+        expect { instance.call }.to raise_error NoMethodError
+      end
+    end
+  end
+end

data/spec/lib/skywalker/command_spec.rb

@@ -3,135 +3,5 @@ require 'skywalker/command'
 
 module Skywalker
   RSpec.describe Command do
-    describe "convenience" do
-      it "provides a class call method that instantiates and calls" do
-        expect(Command).to receive_message_chain('new.call')
-        Command.call
-      end
-    end
-
-
-    describe "validity control" do
-      let(:command) { Command.new }
-
-      it "executes in a transaction" do
-        expect(command).to receive(:transaction)
-        command.call
-      end
-    end
-
-
-    describe "execution" do
-      before do
-        allow(command).to receive(:transaction).and_yield
-      end
-
-
-      describe "success handling" do
-        let(:on_success) { double("on_success callback") }
-        let(:command) { Command.new(on_success: on_success) }
-
-        before do
-          allow(command).to receive(:execute!).and_return(true)
-        end
-
-        it "triggers the confirm_success method" do
-          expect(command).to receive(:confirm_success)
-          command.call
-        end
-
-        it "runs the success callbacks" do
-          expect(command).to receive(:run_success_callbacks)
-          command.call
-        end
-
-        describe "on_success" do
-          context "when on_success is not nil" do
-            it "calls the on_success callback with itself" do
-              expect(on_success).to receive(:call).with(command)
-              command.call
-            end
-
-            context "when on_success is not callable" do
-              let(:on_failure) { double("on_failure") }
-              let(:command) { Command.new(on_success: "a string", on_failure: on_failure) }
-
-              it "confirms failure if the on_success callback fails" do
-                expect(on_failure).to receive(:call).with(command)
-                command.call
-              end
-            end
-          end
-
-          context "when on_success is nil" do
-            let(:nil_callback) { double("fakenil", nil?: true) }
-            let(:command) { Command.new(on_success: nil_callback) }
-
-            it "does not call on_success" do
-              expect(nil_callback).not_to receive(:call)
-              command.call
-            end
-          end
-        end
-      end
-
-
-      describe "failure handling" do
-        let(:on_failure) { double("on_failure callback") }
-        let(:command) { Command.new(on_failure: on_failure) }
-
-        before do
-          allow(command).to receive(:execute!).and_raise(ScriptError)
-        end
-
-        it "triggers the confirm_failure method" do
-          expect(command).to receive(:confirm_failure)
-          command.call
-        end
-
-        it "sets the error on the command" do
-          allow(on_failure).to receive(:call)
-          expect(command).to receive(:error=)
-          command.call
-        end
-
-        it "runs the failure callbacks" do
-          allow(command).to receive(:error=)
-          expect(command).to receive(:run_failure_callbacks)
-          command.call
-        end
-
-        describe "on_failure" do
-          before do
-            allow(command).to receive(:error=)
-          end
-
-          context "when on_failure is not nil" do
-            it "calls the on_failure callback with itself" do
-              expect(on_failure).to receive(:call).with(command)
-              command.call
-            end
-
-            context "when on_failure is not callable" do
-              let(:command) { Command.new(on_failure: "a string") }
-
-              it "raises an error" do
-                expect { command.call }.to raise_error
-              end
-            end
-          end
-
-          context "when on_failure is nil" do
-            let(:nil_callback) { double("fakenil", nil?: true) }
-            let(:command) { Command.new(on_failure: nil_callback) }
-
-            it "does not call on_failure" do
-              expect(nil_callback).not_to receive(:call)
-              command.call
-            end
-          end
-        end
-      end
-    end
   end
 end

data/spec/lib/skywalker/transactional_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'skywalker/transactional'
+
+module Skywalker
+  RSpec.describe Transactional do
+    let(:klass) { Class.new { include Transactional } }
+
+    describe "#transaction" do
+      let(:block) { Proc.new { "hey" } }
+      let(:instance) { klass.new }
+      let(:tx_method) { double("tx_method") }
+
+      context "when ActiveRecord is present" do
+        before do
+          allow(instance).to receive(:active_record_defined?).and_return true
+          allow(instance).to receive(:active_record_transaction_method).and_return tx_method
+        end
+
+        it "calls the transaction method with the block" do
+          allow(tx_method).to receive(:call) do |&blk|
+            blk.call(&block)
+          end
+
+          expect(instance.send(:transaction, &block)).to eq "hey"
+        end
+      end
+
+      context "when ActiveRecord is not present" do
+        before do
+          allow(instance).to receive(:active_record_defined?).and_return false
+        end
+
+        it "calls the block" do
+          expect(instance.send(:transaction, &block)).to eq "hey"
+        end
+      end
+    end
+
+    describe "validity control" do
+      let(:instance) { klass.new }
+
+      it "executes in a transaction" do
+        expect(instance).to receive(:transaction)
+        instance.call
+      end
+    end
+
+    describe "execution" do
+      before do
+        allow(instance).to receive(:transaction).and_yield
+      end
+
+
+      describe "success handling" do
+        let(:on_success) { double("on_success callback") }
+        let(:instance) { klass.new(on_success: on_success) }
+
+        before do
+          allow(instance).to receive(:execute!).and_return(true)
+        end
+
+        it "triggers the confirm_success method" do
+          expect(instance).to receive(:confirm_success)
+          instance.call
+        end
+
+        it "runs the success callbacks" do
+          expect(instance).to receive(:run_success_callbacks)
+          instance.call
+        end
+
+        describe "on_success" do
+          context "when on_success is not nil" do
+            it "calls the on_success callback with itself" do
+              expect(on_success).to receive(:call).with(instance)
+              instance.call
+            end
+
+            context "when on_success is not callable" do
+              let(:on_failure) { double("on_failure") }
+              let(:instance) { klass.new(on_success: "a string", on_failure: on_failure) }
+
+              it "confirms failure if the on_success callback fails" do
+                expect(on_failure).to receive(:call).with(instance)
+                instance.call
+              end
+            end
+          end
+
+          context "when on_success is nil" do
+            let(:nil_callback) { double("fakenil", nil?: true) }
+            let(:instance) { klass.new(on_success: nil_callback) }
+
+            it "does not call on_success" do
+              expect(nil_callback).not_to receive(:call)
+              instance.call
+            end
+          end
+        end
+      end
+
+
+      describe "failure handling" do
+        let(:on_failure) { double("on_failure callback") }
+        let(:instance) { klass.new(on_failure: on_failure) }
+
+        before do
+          allow(instance).to receive(:execute!).and_raise(ScriptError)
+        end
+
+        it "triggers the confirm_failure method" do
+          expect(instance).to receive(:confirm_failure)
+          instance.call
+        end
+
+        it "sets the error on the instance" do
+          allow(on_failure).to receive(:call)
+          expect(instance).to receive(:error=)
+          instance.call
+        end
+
+        it "runs the failure callbacks" do
+          allow(instance).to receive(:error=)
+          expect(instance).to receive(:run_failure_callbacks)
+          instance.call
+        end
+
+        describe "on_failure" do
+          before do
+            allow(instance).to receive(:error=)
+          end
+
+          context "when on_failure is not nil" do
+            it "calls the on_failure callback with itself" do
+              expect(on_failure).to receive(:call).with(instance)
+              instance.call
+            end
+
+            context "when on_failure is not callable" do
+              let(:instance) { klass.new(on_failure: "a string") }
+
+              it "raises an error" do
+                expect { instance.call }.to raise_error NoMethodError
+              end
+            end
+          end
+
+          context "when on_failure is nil" do
+            let(:nil_callback) { double("fakenil", nil?: true) }
+            let(:instance) { klass.new(on_failure: nil_callback) }
+
+            it "does not call on_failure" do
+              expect(nil_callback).not_to receive(:call)
+              instance.call
+            end
+          end
+        end
+      end
+    end
+
+  end
+end
+

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: skywalker
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Rob Yurkowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-14 00:00:00.000000000 Z
+date: 2016-06-21 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -116,11 +102,15 @@ files:
 - examples/spec/tiny_spec_helper.rb
 - lib/skywalker.rb
 - lib/skywalker/acceptable.rb
+- lib/skywalker/callable.rb
 - lib/skywalker/command.rb
+- lib/skywalker/transactional.rb
 - lib/skywalker/version.rb
 - skywalker.gemspec
 - spec/lib/skywalker/acceptable_spec.rb
+- spec/lib/skywalker/callable_spec.rb
 - spec/lib/skywalker/command_spec.rb
+- spec/lib/skywalker/transactional_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/robyurkowski/skywalker
 licenses:
@@ -142,11 +132,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A simple command pattern implementation for transactional operations.
 test_files:
 - spec/lib/skywalker/acceptable_spec.rb
+- spec/lib/skywalker/callable_spec.rb
 - spec/lib/skywalker/command_spec.rb
+- spec/lib/skywalker/transactional_spec.rb
 - spec/spec_helper.rb