statesman 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d60f1115392a3fb65d3911e82fb0afbda37fa632
-  data.tar.gz: 09691527947f5a9b5b788191a84beb6503c1d175
+  metadata.gz: f687db42dd1b0fc5cd988d7ec0ebcab007987a15
+  data.tar.gz: 659f1fd7fe54809344ef91627df309ea7aa5765b
 SHA512:
-  metadata.gz: 9a3c0edea7bf34a8eccd9106cb916f85599b7afff8b0e8ad781972ac38535e1a325659be2f71a91332323790309cf0103e3034ccc97d43a2d88b416da882a42d
-  data.tar.gz: f53ba2aea159a9e372a26d8b803459317370082631b4070369ba5e8f8e87315fdd0a8a7117db331d509a2635753651123eb667285b5628025b377992457f8248
+  metadata.gz: f3f81abd3724a20f36f89c518fcaec9058c65571cd49b297d24ab695e1808f1da5b4e6e92ab52177915d95ba54ae13bc014582c7958085b0ba527c82b96a79fa
+  data.tar.gz: a437668bf5b79bd9671f0bd0387ac44ceac25f7767c9204ce78a8338fc6d5117d9afb0620d69f569bb20e5025b4962a31290761a5fcebbdad7d82c0ef4f54bed

data/.rubocop.yml

@@ -18,3 +18,6 @@ MethodLength:
   CountComments: false  # count full line comments?
   Max: 15
 
+# Don't require utf-8 encoding comment
+Encoding:
+  Enabled: false

data/.travis.yml

@@ -1,5 +1,6 @@
 rvm:
   - 2.0.0
+  - 1.9.3
 services: mongodb
 script:
  - bundle exec rubocop

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+## v0.2.0, 16 December 2013
+*Additions*
+- Adds Ruby 1.9.3 support (patch by [@jakehow](https://github.com/jakehow))
+- All Mongo dependent tests are tagged so they can be excluded from test runs
+
+*Changes*
+- Specs now crash immediately if Mongo is not running
+
+## v0.1.0, 5 November 2013
+
+*Additions*
+- Adds Mongoid adapter and generators (patch by [@dluxemburg](https://github.com/dluxemburg))
+
+*Changes*
+- Replaces `config#transition_class` with `Statesman::Adapters::ActiveRecordTransition` mixin. (inspired by [@cjbell88](https://github.com/cjbell88))
+- Renames the active record transition generator from `statesman:transition` to `statesman:active_record_transition`.
+- Moves to using `require_relative` internally where possible to avoid stomping on application load paths.
+
+## v0.0.1, 28 October 2013.
+- Initial release

data/README.md

@@ -1,14 +1,20 @@
 ![Statesman](http://f.cl.ly/items/410n2A0S3l1W0i3i0o2K/statesman.png)
 
-A statesmanlike state machine library for Ruby 2.0.
+A statesmanlike state machine library for Ruby 1.9.3 and 2.0.
 
 [![Gem Version](https://badge.fury.io/rb/statesman.png)](http://badge.fury.io/rb/statesman)
 [![Build Status](https://travis-ci.org/gocardless/statesman.png?branch=master)](https://travis-ci.org/gocardless/statesman)
 [![Code Climate](https://codeclimate.com/github/gocardless/statesman.png)](https://codeclimate.com/github/gocardless/statesman)
 
-Statesman is a little different from other state machine libraries which tack state behaviour directly onto a model. A statesman state machine is defined as a separate class which is instantiated with the model to which it should apply. State transitions are also modelled as a class which can optionally be persisted to the database for a full audit history, including JSON metadata which can be set during a transition.
+Statesman is a little different from other state machine libraries which tack
+state behaviour directly onto a model. A statesman state machine is defined as a
+separate class which is instantiated with the model to which it should
+apply. State transitions are also modelled as a class which can optionally be
+persisted to the database for a full audit history, including JSON metadata
+which can be set during a transition.
 
-This data model allows for interesting things like using a different state machine depending on the value of a model attribute.
+This data model allows for interesting things like using a different state
+machine depending on the value of a model attribute.
 
 ## TL;DR Usage
 
@@ -24,7 +30,7 @@ class OrderStateMachine
   state :failed
   state :refunded
 
-  transition from: :created,      to: [:checking_out, :cancelled]
+  transition from: :pending,      to: [:checking_out, :cancelled]
   transition from: :checking_out, to: [:purchased, :cancelled]
   transition from: :purchased,    to: [:shipped, :failed]
   transition from: :shipped,      to: :refunded
@@ -61,7 +67,7 @@ class OrderTransition < ActiveRecord::Base
 end
 
 Order.first.state_machine.current_state
-# => "created"
+# => "pending"
 
 Order.first.state_machine.can_transition_to?(:cancelled)
 # => true/false
@@ -78,7 +84,7 @@ Order.first.state_machine.transition_to!(:cancelled)
 By default Statesman stores transition history in memory only. It can be
 persisted by configuring Statesman to use a different adapter. For example,
 ActiveRecord within Rails:
-  
+
 `config/initializers/statesman.rb`:
 
 ```ruby
@@ -123,7 +129,9 @@ Statesman.configure do
   storage_adapter(Statesman::Adapters::Mongoid)
 end
 ```
-Statesman defaults to storing transitions in memory. If you're using rails, you can instead configure it to persist transitions to the database by using the ActiveRecord or Mongoid adapter.
+Statesman defaults to storing transitions in memory. If you're using rails, you
+can instead configure it to persist transitions to the database by using the
+ActiveRecord or Mongoid adapter.
 
 
 ## Class methods
@@ -139,7 +147,8 @@ Define a new state and optionally mark as the initial state.
 ```ruby
 Machine.transition(from: :some_state, to: :another_state)
 ```
-Define a transition rule. Both method parameters are required, `to` can also be an array of states (`.transition(from: :some_state, to: [:another_state, :some_other_state])`).
+Define a transition rule. Both method parameters are required, `to` can also be
+an array of states (`.transition(from: :some_state, to: [:another_state, :some_other_state])`).
 
 #### `Machine.guard_transition`
 ```ruby
@@ -147,15 +156,19 @@ Machine.guard_transition(from: :some_state, to: another_state) do |object|
   object.some_boolean?
 end
 ```
-Define a guard. `to` and `from` parameters are optional, a nil parameter means guard all transitions. The passed block should evaluate to a boolean and must be idempotent as it could be called many times.
+Define a guard. `to` and `from` parameters are optional, a nil parameter means
+guard all transitions. The passed block should evaluate to a boolean and must
+be idempotent as it could be called many times.
 
 #### `Machine.before_transition`
 ```ruby
-Machine.before_transition(from: :some_state, to: another_state) do |object| 
+Machine.before_transition(from: :some_state, to: another_state) do |object|
   object.side_effect
 end
 ```
-Define a callback to run before a transition. `to` and `from` parameters are optional, a nil parameter means run before all transitions. This callback can have side-effects as it will only be run once immediately before the transition.
+Define a callback to run before a transition. `to` and `from` parameters are
+optional, a nil parameter means run before all transitions. This callback can
+have side-effects as it will only be run once immediately before the transition.
 
 #### `Machine.after_transition`
 ```ruby
@@ -163,13 +176,19 @@ Machine.after_transition(from: :some_state, to: another_state) do |object, trans
   object.side_effect
 end
 ```
-Define a callback to run after a successful transition. `to` and `from` parameters are optional, a nil parameter means run after all transitions. The model object and transition object are passed as arguments to the callback. This callback can have side-effects as it will only be run once immediately after the transition.
+Define a callback to run after a successful transition. `to` and `from`
+parameters are optional, a nil parameter means run after all transitions. The
+model object and transition object are passed as arguments to the callback.
+This callback can have side-effects as it will only be run once immediately
+after the transition.
 
 #### `Machine.new`
 ```ruby
 my_machine = Machine.new(my_model, transition_class: MyTransitionModel)
 ```
-Initialize a new state machine instance. `my_model` is required. If using the ActiveRecord adapter `my_model` should have a `has_many` association with `MyTransitionModel`.
+Initialize a new state machine instance. `my_model` is required. If using the
+ActiveRecord adapter `my_model` should have a `has_many` association with
+`MyTransitionModel`.
 
 ## Instance methods
 
@@ -183,13 +202,16 @@ Returns a sorted array of all transition objects.
 Returns the most recent transition object.
 
 #### `Machine#can_transition_to?(:state)`
-Returns true if the current state can transition to the passed state and all applicable guards pass.
+Returns true if the current state can transition to the passed state and all
+applicable guards pass.
 
 #### `Machine#transition_to!(:state)`
-Transition to the passed state, returning `true` on success. Raises `Statesman::GuardFailedError` or `Statesman::TransitionFailedError` on failure.
+Transition to the passed state, returning `true` on success. Raises
+`Statesman::GuardFailedError` or `Statesman::TransitionFailedError` on failure.
 
 #### `Machine#transition_to(:state)`
-Transition to the passed state, returning `true` on success. Swallows all exceptions and returns false on failure.
+Transition to the passed state, returning `true` on success. Swallows all
+exceptions and returns false on failure.
 
 ---
 

data/lib/statesman/callback.rb

@@ -6,21 +6,23 @@ module Statesman
     attr_reader :to
     attr_reader :callback
 
-    def initialize(from: nil, to: nil, callback: nil)
-      unless callback.respond_to?(:call)
+    def initialize(options = { from: nil, to: nil, callback: nil })
+      unless options[:callback].respond_to?(:call)
         raise InvalidCallbackError, "No callback passed"
       end
 
-      @from = from
-      @to = to
-      @callback = callback
+      @from = options[:from]
+      @to = options[:to]
+      @callback = options[:callback]
     end
 
     def call(*args)
       callback.call(*args)
     end
 
-    def applies_to?(from: nil, to: nil)
+    def applies_to?(options = { from: nil, to: nil })
+      from = options[:from]
+      to = options[:to]
       # rubocop:disable RedundantSelf
       (self.from.nil? && self.to.nil?) ||
       (from.nil? && to == self.to) ||

data/lib/statesman/machine.rb

@@ -19,9 +19,9 @@ module Statesman
         @states ||= []
       end
 
-      def state(name, initial: false)
+      def state(name, options = { initial: false })
         name = name.to_s
-        if initial
+        if options[:initial]
           validate_initial_state(name)
           @initial_state = name
         end
@@ -44,9 +44,9 @@ module Statesman
         @guards ||= []
       end
 
-      def transition(from: nil, to: nil)
-        from = to_s_or_nil(from)
-        to = Array(to).map { |item| to_s_or_nil(item) }
+      def transition(options = { from: nil, to: nil })
+        from = to_s_or_nil(options[:from])
+        to = Array(options[:to]).map { |item| to_s_or_nil(item) }
 
         successors[from] ||= []
 
@@ -55,33 +55,33 @@ module Statesman
         successors[from] += to
       end
 
-      def before_transition(from: nil, to: nil, &block)
-        from = to_s_or_nil(from)
-        to   = to_s_or_nil(to)
+      def before_transition(options = { from: nil, to: nil }, &block)
+        from = to_s_or_nil(options[:from])
+        to   = to_s_or_nil(options[:to])
 
         validate_callback_condition(from: from, to: to)
         before_callbacks << Callback.new(from: from, to: to, callback: block)
       end
 
-      def after_transition(from: nil, to: nil, &block)
-        from = to_s_or_nil(from)
-        to   = to_s_or_nil(to)
+      def after_transition(options = { from: nil, to: nil }, &block)
+        from = to_s_or_nil(options[:from])
+        to   = to_s_or_nil(options[:to])
 
         validate_callback_condition(from: from, to: to)
         after_callbacks << Callback.new(from: from, to: to, callback: block)
       end
 
-      def guard_transition(from: nil, to: nil, &block)
-        from = to_s_or_nil(from)
-        to   = to_s_or_nil(to)
+      def guard_transition(options = { from: nil, to: nil }, &block)
+        from = to_s_or_nil(options[:from])
+        to   = to_s_or_nil(options[:to])
 
         validate_callback_condition(from: from, to: to)
         guards << Guard.new(from: from, to: to, callback: block)
       end
 
-      def validate_callback_condition(from: nil, to: nil)
-        from = to_s_or_nil(from)
-        to   = to_s_or_nil(to)
+      def validate_callback_condition(options = { from: nil, to: nil })
+        from = to_s_or_nil(options[:from])
+        to   = to_s_or_nil(options[:to])
 
         [from, to].compact.each { |state| validate_state(state) }
         return if from.nil? && to.nil?
@@ -139,10 +139,12 @@ module Statesman
     end
 
     def initialize(object,
-                   transition_class: Statesman::Adapters::MemoryTransition)
+                      options = {
+                        transition_class: Statesman::Adapters::MemoryTransition
+                      })
       @object = object
-      @storage_adapter = Statesman.storage_adapter.new(transition_class,
-                                                       object)
+      @storage_adapter = Statesman.storage_adapter.new(
+                                            options[:transition_class], object)
     end
 
     def current_state
@@ -191,31 +193,31 @@ module Statesman
 
     private
 
-    def guards_for(from: nil, to: nil)
-      select_callbacks_for(self.class.guards, from: from, to: to)
+    def guards_for(options = { from: nil, to: nil })
+      select_callbacks_for(self.class.guards, options)
     end
 
-    def before_callbacks_for(from: nil, to: nil)
-      select_callbacks_for(self.class.before_callbacks, from: from, to: to)
+    def before_callbacks_for(options = { from: nil, to: nil })
+      select_callbacks_for(self.class.before_callbacks, options)
     end
 
-    def after_callbacks_for(from: nil, to: nil)
-      select_callbacks_for(self.class.after_callbacks, from: from, to: to)
+    def after_callbacks_for(options = { from: nil, to: nil })
+      select_callbacks_for(self.class.after_callbacks, options)
     end
 
-    def select_callbacks_for(callbacks, from: nil, to: nil)
-      from = to_s_or_nil(from)
-      to   = to_s_or_nil(to)
+    def select_callbacks_for(callbacks, options = { from: nil, to: nil })
+      from = to_s_or_nil(options[:from])
+      to   = to_s_or_nil(options[:to])
       callbacks.select { |callback| callback.applies_to?(from: from, to: to) }
     end
 
-    def validate_transition(from: nil, to: nil, metadata: nil)
-      from = to_s_or_nil(from)
-      to   = to_s_or_nil(to)
+    def validate_transition(options = { from: nil, to: nil, metadata: nil })
+      from = to_s_or_nil(options[:from])
+      to   = to_s_or_nil(options[:to])
 
       # Call all guards, they raise exceptions if they fail
       guards_for(from: from, to: to).each do |guard|
-        guard.call(@object, last_transition, metadata)
+        guard.call(@object, last_transition, options[:metadata])
       end
 
       successors = self.class.successors[from] || []

data/lib/statesman/version.rb

@@ -1,3 +1,3 @@
 module Statesman
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/spec_helper.rb

@@ -2,13 +2,29 @@ require "statesman"
 require "sqlite3"
 require "active_record"
 require "support/active_record"
+require "mongoid"
 
 RSpec.configure do |config|
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
 
-  config.order = 'random'
+  config.order = "random"
+
+  # Try a mongo connection at the start of the suite and raise if it fails
+  begin
+    Mongoid.configure do |mongo_config|
+      mongo_config.connect_to("statesman_test")
+      mongo_config.sessions["default"]["options"]["max_retries"] = 2
+    end
+    # Attempting a mongo operation will trigger 2 retries then throw an
+    # exception if mongo is not running.
+    Mongoid.purge! unless config.exclusion_filter[:mongo]
+  rescue Moped::Errors::ConnectionFailure => error
+    puts "The spec suite requires MongoDB to be installed and running locally"
+    puts "Mongo dependent specs can be filtered with rspec --tag '~mongo'"
+    raise(error)
+  end
 
   config.before(:each) do
     # Connect to & cleanup test database

data/spec/statesman/adapters/mongoid_spec.rb

@@ -4,7 +4,7 @@ require "statesman/exceptions"
 require "support/mongoid"
 require "mongoid"
 
-describe Statesman::Adapters::Mongoid do
+describe Statesman::Adapters::Mongoid, mongo: true do
 
   after do
     Mongoid.purge!

data/spec/statesman/machine_spec.rb

@@ -331,7 +331,7 @@ describe Statesman::Machine do
 
       context "with a guard" do
         let(:result) { true }
-        let(:guard_cb) { -> (*args) { result } }
+        let(:guard_cb) { ->(*args) { result } }
         before { machine.guard_transition(from: :x, to: :y, &guard_cb) }
 
         context "and an object to act on" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statesman
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Harry Marr
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-05 00:00:00.000000000 Z
+date: 2013-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,6 +147,7 @@ files:
 - .gitignore
 - .rubocop.yml
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE.txt