statesman 0.8.3 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: caf6d74f912f306c3431c382639a68d14eb70023
-  data.tar.gz: 9e551630b7eaff3ba8b045394c0269d9a9536349
+  metadata.gz: 55f5eab4bdf1849056059ca216caa5412679967d
+  data.tar.gz: 56d537766abea0884d94e4a55a9051896bbfc902
 SHA512:
-  metadata.gz: 2eb9f50f24c02c9932c58551d164fda32ec47a844f40291064854dcc0239bfbb058a1fb83e44e8f03c640f6ad77e42725830e4295dc8f0ebf42d24b1775c9b0a
-  data.tar.gz: e62600a9070ef38c87677952506c96cda36009a53ac9c9a65997050586f6fcefb293b23f5f679604dbbf46f0da08832e5348581204e7f09e1e42937c40e23cb1
+  metadata.gz: b2bead7fc506334da98f4ab620cb6df1fd49012a3a77c3accb8e779e8f09212e3b9926c5ea145ea7d0d3df2f69db13808d05bb65ec55fdfbb39be3ea55d4e915
+  data.tar.gz: e9c8295a8eca68e22debdb594c4802bdd554c18b6a26b4e7d3940fed0673436bf5aa917b4b3a188191b867f6cb4532d08f9383e378d771752ca4b0e91eab1790

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v1.0.0.rc1 9 October 2014
+*Breaking changes*
+
+- Classes which include `ActiveRecordModel` must define an `initial_state` class method.
+
+*Fixes*
+
+- `ActiveRecordModel.in_state` and `ActiveRecordModel.not_in_state` now handle inital states correctly (patch by [@isaacseymour](https://github.com/isaacseymour))
+
+*Additions*
+
+- Transition tables created by generated migrations have `NOT NULL` constraints on `to_state`, `sort_key` and foreign key columns (patch by [@greysteil](https://github.com/greysteil))
+- `before_transition` and `after_transition` allow an array of to states (patch by [@isaacseymour](https://github.com/isaacseymour))
+
 ## v0.8.3 2 September 2014
 *Fixes*
 

data/README.md

@@ -331,7 +331,7 @@ callback code throws an exception, it will not be caught.)
 
 A mixin is provided for the ActiveRecord adapter which adds scopes to easily
 find all models currently in (or not in) a given state. Include it into your
-model and define a `transition_class` method.
+model and define `transition_class` and `initial_state` class methods:
 
 ```ruby
 class Order < ActiveRecord::Base
@@ -342,14 +342,122 @@ class Order < ActiveRecord::Base
   def self.transition_class
     OrderTransition
   end
+
+  def self.initial_state
+    OrderStateMachine.initial_state
+  end
 end
 ```
 
 #### `Model.in_state(:state_1, :state_2, etc)`
-Returns all models currently in any of the supplied states.
+Returns all models currently in any of the supplied states. Prior to 1.0 this ignored all models in the initial state, and the `initial_state` class method was not required.
 
 #### `Model.not_in_state(:state_1, :state_2, etc)`
-Returns all models not currently in any of the supplied states.
+Returns all models not currently in any of the supplied states. Prior to 1.0 this always excluded models in the initial state, and the `initial_state` class method was not required.
+
+## Frequently Asked Questions
+
+#### `Model.in_state` does not work before first transition
+
+This is expected. State is modelled as a series of tranisitions so initially where there has been no transition, there is no explict state. At GoCardless we get around this by transitioning immediately after creation:
+
+```ruby
+after_create do
+  state_machine.transition_to! "pending"
+end
+```
+
+#### Storing the state on the model object
+
+If you wish to store the model state on the model directly, you can keep it up to date using an `after_transition` hook:
+
+```ruby
+after_transition do |model, transition|
+  model.state = transition.to_state
+  model.save!
+end
+```
+
+#### Accessing metadata from the last transition
+
+Given a field `foo` that was stored in the metadata, you can access it like so:
+
+```ruby
+model_instance.last_transition.metadata["foo"]
+```
+
+## Testing Statesman Implementations
+
+This answer was abstracted from [this issue](https://github.com/gocardless/statesman/issues/77).
+
+At GoCardless we focus on testing that:
+- guards correctly prevent / allow transitions
+- callbacks execute when expected and perform the expected actions
+
+#### Testing Guards
+
+Guards can be tested by asserting that `transition_to!` does or does not raise a `Statesman::GuardFailedError`:
+
+```ruby
+describe "guards" do
+  it "cannot transition from state foo to state bar" do
+    expect { some_model.transition_to!(:bar) }.to raise_error(Statesman::GuardFailedError)
+  end
+
+  it "can transition from state foo to state baz" do
+    expect { some_model.transition_to!(:baz).to_not raise_error
+  end
+end
+```
+
+#### Testing Callbacks
+
+Callbacks are tested by asserting that the action they perform occurs:
+
+```ruby
+describe "some callback" do
+  it "adds one to the count property on the model" do
+    expect { some_model.transition_to!(:some_state) }.
+      to change {
+        some_model.reload.count
+      }.by(1)
+  end
+end
+```
+
+#### Creating models in certain states
+
+Sometimes you'll want to test a guard/transition from one state to another, where the state you want to go from is not the initial state of the model. In this instance you'll need to construct a model instance in the state required. However, if you have strict guards, this can be a pain. One way to get around this in tests is to directly create the transitions in the database, hence avoiding the guards.
+
+We use [FactoryGirl](https://github.com/thoughtbot/factory_girl) for creating our test objects. Given an `Order` model that is backed by Statesman, we can easily set it up to be in a particular state:
+
+```ruby
+factory :order do
+  property "value"
+  ...
+
+  trait :shipped do
+    after(:create) do |order|
+      FactoryGirl.create(:order_transition, :shipped, order: order)
+    end
+  end
+end
+
+factory :order_transition do
+  order
+  ...
+
+  trait :shipped do
+    to_state "shipped"
+  end
+end
+```
+
+This means you can easily create an `Order` in the `shipped` state:
+
+```ruby
+let(:shipped_order) { FactoryGirl.create(:order, :shipped) }
+```
 
 ---
 

data/lib/generators/statesman/templates/create_migration.rb.erb

@@ -1,10 +1,10 @@
 class Create<%= migration_class_name %> < ActiveRecord::Migration
   def change
     create_table :<%= table_name %> do |t|
-      t.string :to_state
+      t.string :to_state, null: false
       t.text :metadata<%= ", default: \"{}\"" unless mysql? %>
-      t.integer :sort_key
-      t.integer :<%= parent_id %>
+      t.integer :sort_key, null: false
+      t.integer :<%= parent_id %>, null: false
       t.timestamps
     end
 

data/lib/generators/statesman/templates/update_migration.rb.erb

@@ -1,9 +1,9 @@
 class AddStatesmanTo<%= migration_class_name %> < ActiveRecord::Migration
   def change
-    add_column :<%= table_name %>, :to_state, :string
+    add_column :<%= table_name %>, :to_state, :string, null: false
     add_column :<%= table_name %>, :metadata, :text<%= ", default: \"{}\"" unless mysql? %>
-    add_column :<%= table_name %>, :sort_key, :integer
-    add_column :<%= table_name %>, :<%= parent_id %>, :integer
+    add_column :<%= table_name %>, :sort_key, :integer, null: false
+    add_column :<%= table_name %>, :<%= parent_id %>, :integer, null: false
     add_column :<%= table_name %>, :created_at, :datetime
     add_column :<%= table_name %>, :updated_at, :datetime
 

data/lib/statesman/adapters/active_record.rb

@@ -23,6 +23,8 @@ module Statesman
       end
 
       def create(from, to, metadata = {})
+        from = from.to_s
+        to = to.to_s
         create_transition(from, to, metadata)
       rescue ::ActiveRecord::RecordNotUnique => e
         if e.message.include?('sort_key') &&
@@ -36,7 +38,9 @@ module Statesman
 
       def history
         if transitions_for_parent.loaded?
-          transitions_for_parent.sort_by(&:sort_key)
+          # Workaround for Rails bug which causes infinite loop when sorting
+          # already loaded result set. Introduced in rails/rails@b097ebe
+          transitions_for_parent.to_a.sort_by(&:sort_key)
         else
           transitions_for_parent.order(:sort_key)
         end

data/lib/statesman/adapters/active_record_model.rb

@@ -7,16 +7,20 @@ module Statesman
 
       module ClassMethods
         def in_state(*states)
-          joins(transition_name)
-            .joins(transition_join)
-            .where("#{transition_name}.to_state" => states.map(&:to_s))
+          states = states.map(&:to_s)
+
+          joins(transition1_join)
+            .joins(transition2_join)
+            .where(state_inclusion_where(states), states)
             .where("transition2.id" => nil)
         end
 
         def not_in_state(*states)
-          joins(transition_name)
-            .joins(transition_join)
-            .where("#{transition_name}.to_state NOT IN (?)", states.map(&:to_s))
+          states = states.map(&:to_s)
+
+          joins(transition1_join)
+            .joins(transition2_join)
+            .where("NOT (#{state_inclusion_where(states)})", states)
             .where("transition2.id" => nil)
         end
 
@@ -27,6 +31,11 @@ module Statesman
                                      "defined on the model"
         end
 
+        def initial_state
+          raise NotImplementedError, "An initial_state method should be " \
+                                     "defined on the model"
+        end
+
         def transition_name
           transition_class.table_name.to_sym
         end
@@ -35,10 +44,25 @@ module Statesman
           reflections[transition_name].foreign_key
         end
 
-        def transition_join
+        def transition1_join
+          "LEFT OUTER JOIN #{transition_name} transition1
+             ON transition1.#{model_foreign_key} = #{table_name}.id"
+        end
+
+        def transition2_join
           "LEFT OUTER JOIN #{transition_name} transition2
              ON transition2.#{model_foreign_key} = #{table_name}.id
-             AND transition2.sort_key > #{transition_name}.sort_key"
+             AND transition2.sort_key > transition1.sort_key"
+        end
+
+        def state_inclusion_where(states)
+          if initial_state.in?(states)
+            'transition1.to_state IN (?) OR ' \
+            'transition1.to_state IS NULL'
+          else
+            'transition1.to_state IN (?) AND ' \
+            'transition1.to_state IS NOT NULL'
+          end
         end
       end
     end

data/lib/statesman/adapters/memory.rb

@@ -17,6 +17,8 @@ module Statesman
       end
 
       def create(from, to, metadata = {})
+        from = from.to_s
+        to = to.to_s
         transition = transition_class.new(to, next_sort_key, metadata)
 
         @observer.execute(:before, from, to, transition)

data/lib/statesman/adapters/mongoid.rb

@@ -16,6 +16,8 @@ module Statesman
       end
 
       def create(from, to, metadata = {})
+        from = from.to_s
+        to = to.to_s
         transition = transitions_for_parent.build(to_state: to,
                                                   sort_key: next_sort_key,
                                                   statesman_metadata: metadata)

data/lib/statesman/callback.rb

@@ -11,8 +11,8 @@ module Statesman
         raise InvalidCallbackError, "No callback passed"
       end
 
-      @from = options[:from]
-      @to = options[:to]
+      @from     = options[:from]
+      @to       = Array(options[:to])
       @callback = options[:callback]
     end
 
@@ -34,19 +34,19 @@ module Statesman
     end
 
     def matches_all_transitions
-      from.nil? && to.nil?
+      from.nil? && to.empty?
     end
 
     def matches_from_state(from, to)
-      (from == self.from  && (to.nil? || self.to.nil?))
+      (from == self.from  && (to.nil? || self.to.empty?))
     end
 
     def matches_to_state(from, to)
-      ((from.nil? || self.from.nil?) && to == self.to)
+      ((from.nil? || self.from.nil?) && self.to.include?(to))
     end
 
     def matches_both_states(from, to)
-      from == self.from && to == self.to
+      from == self.from && self.to.include?(to)
     end
   end
 end

data/lib/statesman/machine.rb

@@ -64,7 +64,7 @@ module Statesman
 
       def transition(options = { from: nil, to: nil }, event = nil)
         from = to_s_or_nil(options[:from])
-        to = Array(options[:to]).map { |item| to_s_or_nil(item) }
+        to = array_to_s_or_nil(options[:to])
 
         raise InvalidStateError, "No to states provided." if to.empty?
 
@@ -82,44 +82,39 @@ module Statesman
       end
 
       def before_transition(options = { from: nil, to: nil }, &block)
-        from = to_s_or_nil(options[:from])
-        to   = to_s_or_nil(options[:to])
+        add_callback(
+          options.merge(callback_class: Callback, callback_type: :before),
+          &block)
+      end
 
-        validate_callback_condition(from: from, to: to)
-        callbacks[:before] << Callback.new(from: from, to: to, callback: block)
+      def guard_transition(options = { from: nil, to: nil }, &block)
+        add_callback(
+          options.merge(callback_class: Guard, callback_type: :guards),
+          &block)
       end
 
       def after_transition(options = { from: nil, to: nil,
                                        after_commit: false }, &block)
-        from = to_s_or_nil(options[:from])
-        to   = to_s_or_nil(options[:to])
+        callback_type = options[:after_commit] ? :after_commit : :after
 
-        validate_callback_condition(from: from, to: to)
-        phase = options[:after_commit] ? :after_commit : :after
-        callbacks[phase] << Callback.new(from: from, to: to, callback: block)
-      end
-
-      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)
-        callbacks[:guards] << Guard.new(from: from, to: to, callback: block)
+        add_callback(
+          options.merge(callback_class: Callback, callback_type: callback_type),
+          &block)
       end
 
       def validate_callback_condition(options = { from: nil, to: nil })
         from = to_s_or_nil(options[:from])
-        to   = to_s_or_nil(options[:to])
+        to   = array_to_s_or_nil(options[:to])
 
-        [from, to].compact.each { |state| validate_state(state) }
-        return if from.nil? && to.nil?
+        ([from] + to).compact.each { |state| validate_state(state) }
+        return if from.nil? && to.empty?
 
         validate_not_from_terminal_state(from)
-        validate_not_to_initial_state(to)
+        to.each { |state| validate_not_to_initial_state(state) }
 
-        return if from.nil? || to.nil?
+        return if from.nil? || to.empty?
 
-        validate_from_and_to_state(from, to)
+        to.each { |state| validate_from_and_to_state(from, state) }
       end
 
       # Check that the 'from' state is not terminal
@@ -148,6 +143,17 @@ module Statesman
 
       private
 
+      def add_callback(options, &block)
+        from = to_s_or_nil(options[:from])
+        to   = array_to_s_or_nil(options[:to])
+        callback_klass = options.fetch(:callback_class)
+        callback_type = options.fetch(:callback_type)
+
+        validate_callback_condition(from: from, to: to)
+        callbacks[callback_type] <<
+          callback_klass.new(from: from, to: to, callback: block)
+      end
+
       def validate_state(state)
         unless states.include?(state.to_s)
           raise InvalidStateError, "Invalid state '#{state}'"
@@ -164,6 +170,10 @@ module Statesman
       def to_s_or_nil(input)
         input.nil? ? input : input.to_s
       end
+
+      def array_to_s_or_nil(input)
+        Array(input).map { |item| to_s_or_nil(item) }
+      end
     end
 
     def initialize(object,

data/lib/statesman/version.rb

@@ -1,3 +1,3 @@
 module Statesman
-  VERSION = "0.8.3"
+  VERSION = "1.0.0.beta1"
 end

data/spec/generators/statesman/migration_generator_spec.rb

@@ -28,5 +28,6 @@ describe Statesman::MigrationGenerator, type: :generator do
 
     it { is_expected.to contain(/:bacon_transition/) }
     it { is_expected.not_to contain(/:yummy\/bacon/) }
+    it { is_expected.to contain(/null: false/) }
   end
 end

data/spec/statesman/adapters/active_record_model_spec.rb

@@ -12,46 +12,69 @@ describe Statesman::Adapters::ActiveRecordModel do
       def self.transition_class
         MyActiveRecordModelTransition
       end
+
+      def self.initial_state
+        MyStateMachine.initial_state
+      end
     end
   end
 
   let!(:model) do
     model = MyActiveRecordModel.create
-    model.my_active_record_model_transitions.create(to_state: :state_a)
+    model.my_active_record_model_transitions.create(to_state: :succeeded)
     model
   end
 
   let!(:other_model) do
     model = MyActiveRecordModel.create
-    model.my_active_record_model_transitions.create(to_state: :state_b)
+    model.my_active_record_model_transitions.create(to_state: :failed)
+    model
+  end
+
+  let!(:initial_state_model) { MyActiveRecordModel.create }
+
+  let!(:returned_to_initial_model) do
+    model = MyActiveRecordModel.create
+    model.my_active_record_model_transitions.create(to_state: :failed)
+    model.my_active_record_model_transitions.create(to_state: :initial)
     model
   end
 
   describe ".in_state" do
     context "given a single state" do
-      subject { MyActiveRecordModel.in_state(:state_a) }
+      subject { MyActiveRecordModel.in_state(:succeeded) }
 
       it { is_expected.to include model }
     end
 
     context "given multiple states" do
-      subject { MyActiveRecordModel.in_state(:state_a, :state_b) }
+      subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
 
       it { is_expected.to include model }
       it { is_expected.to include other_model }
     end
+
+    context "given the initial state" do
+      subject { MyActiveRecordModel.in_state(:initial) }
+
+      it { is_expected.to include initial_state_model }
+      it { is_expected.to include returned_to_initial_model }
+    end
   end
 
   describe ".not_in_state" do
     context "given a single state" do
-      subject { MyActiveRecordModel.not_in_state(:state_b) }
+      subject { MyActiveRecordModel.not_in_state(:failed) }
       it { is_expected.to include model }
       it { is_expected.not_to include other_model }
     end
 
     context "given multiple states" do
-      subject { MyActiveRecordModel.not_in_state(:state_a, :state_b) }
-      it { is_expected.to eq([]) }
+      subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+      it do
+        is_expected.to match_array([initial_state_model,
+                                    returned_to_initial_model])
+      end
     end
   end
 end

data/spec/statesman/adapters/active_record_spec.rb

@@ -56,7 +56,7 @@ describe Statesman::Adapters::ActiveRecord do
   end
 
   describe "#create" do
-    let(:adapter) do
+    let!(:adapter) do
       described_class.new(MyActiveRecordModelTransition, model, observer)
     end
     let(:from) { :x }
@@ -123,8 +123,8 @@ describe Statesman::Adapters::ActiveRecord do
 
     context "with a pre-fetched transition history" do
       before do
-        # inspect the transitions to coerce a [pre-]load
-        model.my_active_record_model_transitions.inspect
+        adapter.create(:x, :y)
+        model.my_active_record_model_transitions.load_target
       end
 
       it "doesn't query the database" do

data/spec/statesman/callback_spec.rb

@@ -72,7 +72,7 @@ describe Statesman::Callback do
 
     context "with any from value on the callback" do
       let(:callback) do
-        Statesman::Callback.new(to: :y, callback: cb_lambda)
+        Statesman::Callback.new(to: [:y, :z], callback: cb_lambda)
       end
       let(:from) { :x }
 
@@ -81,6 +81,11 @@ describe Statesman::Callback do
         it { is_expected.to be_truthy }
       end
 
+      context "and another allowed to value" do
+        let(:to) { :z }
+        it { is_expected.to be_truthy }
+      end
+
       context "and a disallowed to value" do
         let(:to) { :a }
         it { is_expected.to be_falsey }

data/spec/statesman/machine_spec.rb

@@ -218,54 +218,94 @@ describe Statesman::Machine do
       machine.class_eval do
         state :x, initial: true
         state :y
-        transition from: :x, to: :y
+        state :z
+        transition from: :x, to: [:y, :z]
       end
     end
 
-    it "stores callbacks" do
-      expect do
-        machine.send(assignment_method) {}
-      end.to change(machine.callbacks[callback_store], :count).by(1)
+    let(:options) { { from: nil, to: [] } }
+    let(:set_callback) { machine.send(assignment_method, options) {} }
+
+    shared_examples "fails" do |error_type|
+      it "raises an exception" do
+        expect { set_callback }.to raise_error(error_type)
+      end
+
+      it "does not add a callback" do
+        expect do
+          begin
+            set_callback
+          rescue error_type
+            nil
+          end
+        end.to_not change(machine.callbacks[callback_store], :count)
+      end
     end
 
-    it "stores callback instances" do
-      machine.send(assignment_method) {}
-      machine.callbacks[callback_store].each do |callback|
-        expect(callback).to be_a(Statesman::Callback)
+    shared_examples "adds callback" do
+      it "does not raise" do
+        expect { set_callback }.to_not raise_error
+      end
+
+      it "stores callbacks" do
+        expect { set_callback }.to change(
+          machine.callbacks[callback_store], :count).by(1)
+      end
+
+      it "stores callback instances" do
+        set_callback
+        machine.callbacks[callback_store].each do |callback|
+          expect(callback).to be_a(Statesman::Callback)
+        end
       end
     end
 
     context "with invalid states" do
-      it "raises an exception when both are invalid" do
-        expect do
-          machine.send(assignment_method, from: :foo, to: :bar) {}
-        end.to raise_error(Statesman::InvalidStateError)
+      context "when both are invalid" do
+        let(:options) { { from: :foo, to: :bar } }
+        it_behaves_like "fails", Statesman::InvalidStateError
       end
 
-      it "raises an exception with a terminal from state and nil to state" do
-        expect do
-          machine.send(assignment_method, from: :y) {}
-        end.to raise_error(Statesman::InvalidTransitionError)
+      context "from a terminal state to anything" do
+        let(:options) { { from: :y, to: [] } }
+        it_behaves_like "fails", Statesman::InvalidTransitionError
       end
 
-      it "raises an exception with an initial to state and nil from state" do
-        expect do
-          machine.send(assignment_method, to: :x) {}
-        end.to raise_error(Statesman::InvalidTransitionError)
+      context "to an initial state and from anything" do
+        let(:options) { { from: nil, to: :x } }
+        it_behaves_like "fails", Statesman::InvalidTransitionError
+      end
+
+      context "from a terminal state and to multiple states" do
+        let(:options) { { from: :y, to: [:x, :z] } }
+        it_behaves_like "fails", Statesman::InvalidTransitionError
+      end
+
+      context "to an initial state and other states" do
+        let(:options) { { from: nil, to: [:y, :x, :z] } }
+        it_behaves_like "fails", Statesman::InvalidTransitionError
       end
     end
 
     context "with validate_states" do
-      it "allows a nil from state" do
-        expect do
-          machine.send(assignment_method, to: :y) {}
-        end.to_not raise_error
+      context "from anything" do
+        let(:options) { { from: nil, to: :y } }
+        it_behaves_like "adds callback"
       end
 
-      it "allows a nil to state" do
-        expect do
-          machine.send(assignment_method, from: :x) {}
-        end.to_not raise_error
+      context "to anything" do
+        let(:options) { { from: :x, to: [] } }
+        it_behaves_like "adds callback"
+      end
+
+      context "to several" do
+        let(:options) { { from: :x, to: [:y, :z] } }
+        it_behaves_like "adds callback"
+      end
+
+      context "from any to several" do
+        let(:options) { { from: nil, to: [:y, :z] } }
+        it_behaves_like "adds callback"
       end
     end
   end

data/spec/support/active_record.rb

@@ -3,8 +3,24 @@ require "json"
 
 DB = Pathname.new("test.sqlite3")
 
+class MyStateMachine
+  include Statesman::Machine
+
+  state :initial, initial: true
+  state :succeeded
+  state :failed
+
+  transition from: :initial, to: [:succeeded, :failed]
+  transition from: :failed,  to: :initial
+end
+
 class MyActiveRecordModel < ActiveRecord::Base
   has_many :my_active_record_model_transitions
+
+  def state_machine
+    @state_machine ||= MyStateMachine
+      .new(self, transition_class: MyActiveRecordModelTransition)
+  end
 end
 
 class MyActiveRecordModelTransition < ActiveRecord::Base

data/spec/support/mongoid.rb

@@ -7,6 +7,8 @@ end
 class MyMongoidModel
   include Mongoid::Document
 
+  field :current_state, type: String
+
   has_many :my_mongoid_model_transitions
 end
 

data/statesman.gemspec

@@ -20,13 +20,13 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler",       "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec",         "~> 3.0"
+  spec.add_development_dependency "rspec",         "~> 3.1"
   spec.add_development_dependency "rspec-its",     "~> 1.0"
   spec.add_development_dependency "guard-rspec",   "~> 4.3"
-  spec.add_development_dependency "rubocop",       "~> 0.24.1"
+  spec.add_development_dependency "rubocop",       "~> 0.26"
   spec.add_development_dependency "guard-rubocop", "~> 1.1"
-  spec.add_development_dependency "sqlite3",       "~> 1.3.8"
-  spec.add_development_dependency "mongoid",       "~> 3.1.5"
-  spec.add_development_dependency "rails",         "~> 3.2"
+  spec.add_development_dependency "sqlite3",       "~> 1.3"
+  spec.add_development_dependency "mongoid",       "~> 4.0"
+  spec.add_development_dependency "activerecord",  "~> 4.1"
   spec.add_development_dependency "ammeter",       "~> 1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statesman
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Harry Marr
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-02 00:00:00.000000000 Z
+date: 2014-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -45,14 +45,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -87,14 +87,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.24.1
+        version: '0.26'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.24.1
+        version: '0.26'
 - !ruby/object:Gem::Dependency
   name: guard-rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -115,42 +115,42 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.8
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.8
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.1.5
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.1.5
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '4.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '4.1'
 - !ruby/object:Gem::Dependency
   name: ammeter
   requirement: !ruby/object:Gem::Requirement
@@ -240,9 +240,9 @@ 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.4.1