stator 0.2.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f80f0783f3bbff0062fee1ebbb2e4f32ebb2f4dc8605809aab25273482a5f09f
-  data.tar.gz: 8a8f5f91f72f29fae9579048aae6e1e42c105f9fabf29f698b5c2b9c0382279d
+  metadata.gz: c4db54f443ba466ae3fc6f79857816b8719e0cbacf0615f8c014ae0c71c32e81
+  data.tar.gz: 53d72d27aafa1a340c02d2d5459235488bf5e12df9198312ffe1d5121fc24912
 SHA512:
-  metadata.gz: 21c4d54970b04402dba07658b815c13009bd0dd0a1f8c440202f62fa1f6670848a45abc163815c75d0ca69694343a139e76f5491ac83a768f364efd81c4f7500
-  data.tar.gz: '0280f986830d8065267696f1bc264123d75b06688d6327657e83ea7d49db7f95ffdf4f7eca0b1d8e3677cb3758d4e4d3eaee8b3bbba21c96c7e7725f949858ee'
+  metadata.gz: a2e76eb8e8bbe0e1dab6d8fbdbb6516f12cff56c26c3d10d974d4aadce08fbcabdcd49dbba710d0f904a1a04ea4c489125b18475a119de5e625a9cbb6e9406a4
+  data.tar.gz: 0fef985f07d95f3d8801f4e3534f478feb516fea223532e1e562cc85bebdc54c09222ee0087517d4c3f396f4d094ad80a9404f7e0cb69829ffa6c5ddc40bb297

data/.travis.yml

@@ -4,12 +4,38 @@ rvm:
   - 2.0.0
   - 2.1.6
   - 2.2.3
+  - 2.4.5
+  - 2.5.3
 
 gemfile:
   - gemfiles/ar40.gemfile
   - gemfiles/ar41.gemfile
   - gemfiles/ar42.gemfile
+  - gemfiles/ar52.gemfile
 
 matrix:
   allow_failures:
     - gemfile: gemfiles/ar42.gemfile
+    - gemfile: gemfiles/ar52.gemfile
+
+  exclude:
+    - rvm: 2.0.0
+      gemfile: gemfiles/ar52.gemfile
+
+    - rvm: 2.1.6
+      gemfile: gemfiles/ar52.gemfile
+
+    - rvm: 2.2.3
+      gemfile: gemfiles/ar52.gemfile
+
+    - rvm: 2.4.5
+      gemfile: gemfiles/ar40.gemfile
+
+    - rvm: 2.4.5
+      gemfile: gemfiles/ar41.gemfile
+
+    - rvm: 2.5.3
+      gemfile: gemfiles/ar40.gemfile
+
+    - rvm: 2.5.3
+      gemfile: gemfiles/ar41.gemfile

data/Gemfile

@@ -1,10 +1,10 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in stator.gemspec
-gem 'activerecord', '4.0.0'
+gem 'activerecord', '5.2.3'
 
 gemspec
 
+gem 'activerecord-nulldb-adapter', '~> 0.4.0', require: false
 gem 'rake'
-gem 'activerecord-nulldb-adapter', :require => false, :git => 'git@github.com:nulldb/nulldb.git', :ref => 'ffc7dae4697c6b9fb15bed9edca3acb1f00eb5f0'
 gem 'rspec'

data/gemfiles/ar42.gemfile

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in stator.gemspec
-gem 'activerecord', '~> 4.2.0'
+gem 'activerecord', '~> 4.0.0'
 
 gemspec :path => '../'
 

data/gemfiles/ar52.gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stator.gemspec
+gem 'activerecord', '~> 5.2.0'
+
+gemspec :path => '../'
+
+gem 'rake'
+gem 'activerecord-nulldb-adapter', '~> 0.4.0', :require => false, :git => 'git@github.com:nulldb/nulldb.git'
+gem 'rspec'

data/lib/stator/integration.rb

@@ -1,27 +1,28 @@
+# frozen_string_literal: true
+
 module Stator
   class Integration
 
-    delegate :states,       :to => :@machine
-    delegate :transitions,  :to => :@machine
-    delegate :namespace,    :to => :@machine
+    delegate :states,       to: :@machine
+    delegate :transitions,  to: :@machine
+    delegate :namespace,    to: :@machine
+
+    attr_reader :skip_validations
+    attr_reader :skip_transition_tracking
 
     def initialize(machine, record)
       @machine = machine
       @record  = record
     end
 
-
-
-
     def state=(new_value)
-      @record.send("#{@machine.field}=",  new_value)
+      @record.send("#{@machine.field}=", new_value)
     end
 
     def state
       @record.send(@machine.field)
     end
 
-
     def state_was(use_previous = false)
       if use_previous
         @record.previous_changes[@machine.field.to_s].try(:[], 0)
@@ -30,7 +31,6 @@ module Stator
       end
     end
 
-
     def state_changed?(use_previous = false)
       if use_previous
         !!@record.previous_changes[@machine.field.to_s]
@@ -39,14 +39,12 @@ module Stator
       end
     end
 
-
-
     def validate_transition
-      return unless self.state_changed?
-      return if @machine.skip_validations
+      return unless state_changed?
+      return if skip_validations
 
-      was = self.state_was
-      is  = self.state
+      was = state_was
+      is  = state
 
       if @record.new_record?
         invalid_state! unless @machine.matching_transition(::Stator::Transition::ANY, is)
@@ -55,7 +53,7 @@ module Stator
       end
     end
 
-    # todo: i18n
+    # TODO: i18n
     def invalid_state!
       @record.errors.add(@machine.field, "is not a valid state")
     end
@@ -65,10 +63,10 @@ module Stator
     end
 
     def track_transition
-      return if @machine.skip_transition_tracking
+      return if skip_transition_tracking
 
-      self.attempt_to_track_state(self.state)
-      self.attempt_to_track_state_changed_timestamp
+      attempt_to_track_state(state)
+      attempt_to_track_state_changed_timestamp
 
       true
     end
@@ -89,7 +87,6 @@ module Stator
 
       # grab all the states and their timestamps that occur on or after state_at and on or before the time in question
       later_states = all_states.map do |s|
-
         next if state == s
 
         at = @record.send("#{s}_#{@machine.field}_at")
@@ -105,8 +102,8 @@ module Stator
       return true if later_states.empty?
 
       # grab the states that were present at the lowest timestamp
-      later_groups = later_states.group_by{|s| s[:at] }
-      later_group_key = later_groups.keys.sort[0]
+      later_groups = later_states.group_by { |s| s[:at] }
+      later_group_key = later_groups.keys.min
       later_states = later_groups[later_group_key]
 
       # if the lowest timestamp is the same as the state's timestamp, evaluate based on state index
@@ -118,14 +115,30 @@ module Stator
     end
 
     def likely_state_at(t)
-      @machine.states.reverse.detect{|s| in_state_at?(s,t) }
+      @machine.states.reverse.detect { |s| in_state_at?(s, t) }
     end
 
+    def without_validation
+      was = @skip_validations
+      @skip_validations = true
+      yield @record
+    ensure
+      @skip_validations = was
+    end
+
+    def without_transition_tracking
+      was = @skip_transition_tracking
+      @skip_transition_tracking = true
+      yield @record
+    ensure
+      @skip_transition_tracking = was
+    end
 
     protected
 
     def attempt_to_track_state(state_to_track)
       return unless state_to_track
+
       _attempt_to_track_change("#{state_to_track}_#{@machine.field}_at")
     end
 
@@ -136,7 +149,8 @@ module Stator
     def _attempt_to_track_change(field_name)
       return unless @record.respond_to?(field_name)
       return unless @record.respond_to?("#{field_name}=")
-      return unless @record.send("#{field_name}").nil? || self.state_changed?
+      return unless @record.send(field_name.to_s).nil? || state_changed?
+      return if @record.send("#{field_name}_changed?")
 
       @record.send("#{field_name}=", (Time.zone || Time).now)
     end

data/lib/stator/machine.rb

@@ -7,16 +7,14 @@ module Stator
     attr_reader :transitions
     attr_reader :states
     attr_reader :namespace
-    attr_reader :skip_validations
-    attr_reader :skip_transition_tracking
-
 
     def initialize(klass, options = {})
-      @class_name    = klass.name
-      @field         = options[:field] || :state
-      @namespace     = options[:namespace] || nil
+      @class_name       = klass.name
+      @field            = options[:field] || :state
+      @namespace        = options[:namespace]
 
-      @initial_state = options[:initial]
+      @initial_state    = options[:initial] && options[:initial].to_s
+      @tracking_enabled = options[:track] || false
 
       @transitions      = []
       @aliases          = []
@@ -26,7 +24,6 @@ module Stator
       @states           = [@initial_state].compact
 
       @options       = options
-
     end
 
     def integration(record)
@@ -38,7 +35,6 @@ module Stator
     end
 
     def transition(name, &block)
-
       t = ::Stator::Transition.new(@class_name, name, @namespace)
       t.instance_eval(&block) if block_given?
 
@@ -66,8 +62,14 @@ module Stator
       end
     end
 
+    def tracking_enabled?
+      @tracking_enabled
+    end
+
     def conditional(*states, &block)
-      klass.instance_exec("#{states.map(&:to_s).inspect}.include?(self._stator(#{@namespace.inspect}).integration(self).state)", &block)
+      _namespace = @namespace
+
+      klass.instance_exec(proc { states.map(&:to_s).include?(self._stator(_namespace).integration(self).state) }, &block)
     end
 
     def matching_transition(from, to)
@@ -86,22 +88,6 @@ module Stator
       @class_name.constantize
     end
 
-    def without_validation
-      was = @skip_validations
-      @skip_validations = true
-      yield
-    ensure
-      @skip_validations = was
-    end
-
-    def without_transition_tracking
-      was = @skip_transition_tracking
-      @skip_transition_tracking = true
-      yield
-    ensure
-      @skip_transition_tracking = was
-    end
-
     protected
 
     def verify_transition_validity(transition)

data/lib/stator/model.rb

@@ -14,7 +14,7 @@ module Stator
         f = options[:field] || :state
         # rescue nil since the table may not exist yet.
         initial = self.columns_hash[f.to_s].default rescue nil
-        options = options.reverse_merge(initial: initial)
+        options = options.merge(initial: initial) if initial
       end
 
       machine = (self._stators[options[:namespace].to_s] ||= ::Stator::Machine.new(self, options))
@@ -35,27 +35,25 @@ module Stator
 
       def self.included(base)
         base.class_eval do
-          before_validation :_stator_track_transition, prepend: true
+          before_save :_stator_maybe_track_transition, prepend: true
         end
       end
 
       def in_state_at?(state, t, namespace = '')
-        machine = self._stator(namespace)
-        machine.integration(self).in_state_at?(state, t)
+        _integration(namespace).in_state_at?(state, t)
       end
 
       def likely_state_at(t, namespace = '')
-        machine = self._stator(namespace)
-        machine.integration(self).likely_state_at(t)
+        _integration(namespace).likely_state_at(t)
       end
 
       protected
 
-
-      def _stator_track_transition
-
+      def _stator_maybe_track_transition
         self._stators.each do |namespace, machine|
-          machine.integration(self).track_transition
+          next unless machine.tracking_enabled?
+
+          _integration(namespace).track_transition
         end
 
         true
@@ -71,23 +69,28 @@ module Stator
         end
       end
 
+      def initialize_dup(other)
+        @_integrations = {}
+        super
+      end
+
       def without_state_transition_validations(namespace = '')
-        self._stator(namespace).without_validation do
-          yield
+        _integration(namespace).without_validation do
+          yield self
         end
       end
 
       def without_state_transition_tracking(namespace = '')
-        self._stator(namespace).without_transition_tracking do
-          yield
+        _integration(namespace).without_transition_tracking do
+          yield self
         end
       end
 
       protected
 
       def _stator_validate_transition
-        self._stators.each do |namespace, machine|
-          machine.integration(self).validate_transition
+        self._stators.each_key do |namespace|
+          _integration(namespace).validate_transition
         end
       end
 
@@ -95,6 +98,12 @@ module Stator
         self.class._stator(namespace)
       end
 
+      def _integration(namespace = '')
+        @_integrations ||= {}
+        @_integrations[namespace] ||= _stator(namespace).integration(self)
+        @_integrations[namespace]
+      end
+
     end
   end
 end

data/lib/stator/transition.rb

@@ -42,7 +42,7 @@ module Stator
     end
 
     def conditional(options = {}, &block)
-      klass.instance_exec(conditional_string(options), &block)
+      klass.instance_exec(conditional_block(options), &block)
     end
 
     def any
@@ -63,25 +63,30 @@ module Stator
       @callbacks[kind] || []
     end
 
-    def conditional_string(options = {})
+    def conditional_block(options = {})
       options[:use_previous] ||= false
-      %Q{
-          (
-            self._stator(#{@namespace.inspect}).integration(self).state_changed?(#{options[:use_previous].inspect})
-          ) && (
-            #{@froms.inspect}.include?(self._stator(#{@namespace.inspect}).integration(self).state_was(#{options[:use_previous].inspect})) ||
-            #{@froms.inspect}.include?(::Stator::Transition::ANY)
-          ) && (
-            self._stator(#{@namespace.inspect}).integration(self).state == #{@to.inspect} ||
-            #{@to.inspect} == ::Stator::Transition::ANY
-          )
-        }
+
+      _namespace = @namespace
+      _froms     = @froms
+      _to        = @to
+
+      Proc.new do
+        (
+          self._stator(_namespace).integration(self).state_changed?(options[:use_previous])
+        ) && (
+          _froms.include?(self._stator(_namespace).integration(self).state_was(options[:use_previous])) ||
+          _froms.include?(::Stator::Transition::ANY)
+        ) && (
+          self._stator(_namespace).integration(self).state == _to ||
+          _to == ::Stator::Transition::ANY
+        )
+      end
     end
 
     def generate_methods
       klass.class_eval <<-EV, __FILE__, __LINE__ + 1
         def #{@full_name}(should_save = true)
-          integration = self._stator(#{@namespace.inspect}).integration(self)
+          integration = _integration(#{@namespace.to_s.inspect})
 
           unless can_#{@full_name}?
             integration.invalid_transition!(integration.state, #{@to.inspect}) if should_save
@@ -93,7 +98,7 @@ module Stator
         end
 
         def #{@full_name}!
-          integration = self._stator(#{@namespace.inspect}).integration(self)
+          integration = _integration(#{@namespace.to_s.inspect})
 
           unless can_#{@full_name}?
             integration.invalid_transition!(integration.state, #{@to.inspect})
@@ -105,10 +110,10 @@ module Stator
         end
 
         def can_#{@full_name}?
-          machine     = self._stator(#{@namespace.inspect})
-          return true if machine.skip_validations
+          integration = _integration(#{@namespace.to_s.inspect})
+          return true if integration.skip_validations
 
-          integration = machine.integration(self)
+          machine     = self._stator(#{@namespace.to_s.inspect})
           transition  = machine.transitions.detect{|t| t.full_name.to_s == #{@full_name.inspect}.to_s }
           transition.can?(integration.state)
         end

data/lib/stator/version.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module Stator
+
   MAJOR       = 0
-  MINOR       = 2
-  PATCH       = 0
+  MINOR       = 3
+  PATCH       = 3
   PRERELEASE  = nil
 
-  VERSION = [MAJOR, MINOR, PATCH, PRERELEASE].compact.join('.')
+  VERSION = [MAJOR, MINOR, PATCH, PRERELEASE].compact.join(".")
+
 end

data/spec/model_spec.rb

@@ -1,101 +1,104 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe Stator::Model do
+require "spec_helper"
 
-  it 'should set the default state after initialization' do
+describe Stator::Model do
+  it "should set the default state after initialization" do
     u = User.new
-    u.state.should eql('pending')
+    u.state.should eql("pending")
   end
 
-  it 'should see the initial setting of the state as a change with the initial state as the previous value' do
+  it "should see the initial setting of the state as a change with the initial state as the previous value" do
     u = User.new
-    u.state = 'activated'
-    u.state_was.should eql('pending')
+    u.state = "activated"
+    u.state_was.should eql("pending")
   end
 
-  it 'should not obstruct normal validations' do
+  it "should not obstruct normal validations" do
     u = User.new
     u.should_not be_valid
     u.errors[:email].grep(/length/).should_not be_empty
   end
 
-  it 'should ensure a valid state transition when given a bogus state' do
+  it "should ensure a valid state transition when given a bogus state" do
     u = User.new
-    u.state = 'anythingelse'
+    u.state = "anythingelse"
 
     u.should_not be_valid
-    u.errors[:state].should eql(['is not a valid state'])
+    u.errors[:state].should eql(["is not a valid state"])
   end
 
-  it 'should allow creation at any state' do
-    u = User.new(:email => 'doug@example.com')
-    u.state = 'hyperactivated'
+  it "should allow creation at any state" do
+    u = User.new(email: "doug@example.com")
+    u.state = "hyperactivated"
 
     u.should be_valid
   end
 
-  it 'should ensure a valid state transition when given an illegal state based on the current state' do
+  it "should ensure a valid state transition when given an illegal state based on the current state" do
     u = User.new
-    u.stub(:new_record?).and_return(false)
-    u.state = 'hyperactivated'
+
+    allow(u).to receive(:new_record?).and_return(false)
+
+    u.state = "hyperactivated"
 
     u.should_not be_valid
     u.errors[:state].should_not be_empty
   end
 
-  it 'should not allow a transition that is currently in a `to` state' do
-    u = User.new(:email => 'fred@example.com')
+  it "should not allow a transition that is currently in a `to` state" do
+    u = User.new(email: "fred@example.com")
     u.activate!
     u.hyperactivate!
 
-    lambda{
+    lambda {
       u.hyperactivate!
     }.should raise_error(/cannot transition to \"hyperactivated\" from \"hyperactivated\"/)
   end
 
-  it 'should run conditional validations' do
+  it "should run conditional validations" do
     u = User.new
-    u.state = 'semiactivated'
+    u.state = "semiactivated"
     u.should_not be_valid
 
     u.errors[:state].should be_empty
     u.errors[:email].grep(/format/).should_not be_empty
   end
 
-  it 'should invoke callbacks' do
-    u = User.new(:activated => true, :email => 'doug@example.com', :name => 'doug')
+  it "should invoke callbacks" do
+    u = User.new(activated: true, email: "doug@example.com", name: "doug")
     u.activated.should == true
 
     u.deactivate
 
     u.activated.should == false
-    u.state.should eql('deactivated')
+    u.state.should eql("deactivated")
     u.activated_state_at.should be_nil
     u.should be_persisted
   end
 
-  it 'should blow up if the record is invalid and a bang method is used' do
-    u = User.new(:email => 'doug@other.com', :name => 'doug')
-    lambda{
+  it "should blow up if the record is invalid and a bang method is used" do
+    u = User.new(email: "doug@other.com", name: "doug")
+    lambda {
       u.activate!
     }.should raise_error(ActiveRecord::RecordInvalid)
   end
 
-  it 'should allow for other fields to be used other than state' do
+  it "should allow for other fields to be used other than state" do
     a = Animal.new
     a.should be_valid
 
     a.birth!
   end
 
-  it 'should create implicit transitions for state declarations' do
+  it "should create implicit transitions for state declarations" do
     a = Animal.new
     a.should_not be_grown_up
-    a.status = 'grown_up'
+    a.status = "grown_up"
     a.save
   end
 
-  it 'should allow multiple machines in the same model' do
+  it "should allow multiple machines in the same model" do
     f = Farm.new
     f.should be_dirty
     f.should be_house_dirty
@@ -110,30 +113,30 @@ describe Stator::Model do
     f.should_not be_house_dirty
   end
 
-  it 'should allow saving to be skipped' do
+  it "should allow saving to be skipped" do
     f = Farm.new
     f.cleanup(false)
 
     f.should_not be_persisted
   end
 
-  it 'should allow no initial state' do
+  it "should allow no initial state" do
     f = Factory.new
     f.state.should be_nil
 
     f.construct.should eql(true)
 
-    f.state.should eql('constructed')
+    f.state.should eql("constructed")
   end
 
-  it 'should allow any transition if validations are opted out of' do
+  it "should allow any transition if validations are opted out of" do
     u = User.new
-    u.email = 'doug@example.com'
+    u.email = "doug@example.com"
 
     u.can_hyperactivate?.should eql(false)
     u.hyperactivate.should eql(false)
 
-    u.state.should eql('pending')
+    u.state.should eql("pending")
 
     u.without_state_transition_validations do
       u.can_hyperactivate?.should eql(true)
@@ -141,13 +144,13 @@ describe Stator::Model do
     end
   end
 
-  it 'should skip tracking timestamps if opted out of' do
+  it "should skip tracking timestamps if opted out of" do
     u = User.new
-    u.email = 'doug@example.com'
+    u.email = "doug@example.com"
 
     u.without_state_transition_tracking do
       u.semiactivate!
-      u.state.should eql('semiactivated')
+      u.state.should eql("semiactivated")
       u.semiactivated_state_at.should be_nil
     end
 
@@ -157,9 +160,44 @@ describe Stator::Model do
     u.activated_state_at.should_not be_nil
   end
 
-  describe 'helper methods' do
+  it "should skip tracking timestamps if opted out of with thread safety" do
+    threads = []
+    skip = User.new(email: "skip@example.com")
+    nope = User.new(email: "nope@example.com")
+
+    threads << Thread.new do
+      sleep 0.5
+      nope.semiactivate!
+    end
+    threads << Thread.new do
+      skip.without_state_transition_tracking do
+        sleep 1
+        skip.semiactivate!
+      end
+    end
+
+    threads.each(&:join)
+
+    nope.semiactivated_state_at.should_not be_nil
+    skip.semiactivated_state_at.should be_nil
+  end
+
+  it "should not inherit _integration cache on dup" do
+    u = User.new(email: "user@example.com")
+    u.save!
+
+    u_duped = u.dup
+
+    u.semiactivate!
+
+    u_duped_integration = u_duped.send(:_integration)
 
-    it 'should answer the question of whether the state is currently the one invoked' do
+    u_duped_integration.state.should_not eql(u.state)
+    u_duped_integration.instance_values["record"].should eq(u_duped)
+  end
+
+  describe "helper methods" do
+    it "should answer the question of whether the state is currently the one invoked" do
       a = Animal.new
       a.should be_unborn
       a.should_not be_born
@@ -170,7 +208,7 @@ describe Stator::Model do
       a.should_not be_unborn
     end
 
-    it 'should determine if it can validly execute a transition' do
+    it "should determine if it can validly execute a transition" do
       a = Animal.new
       a.can_birth?.should eql(true)
 
@@ -178,22 +216,20 @@ describe Stator::Model do
 
       a.can_birth?.should eql(false)
     end
-
   end
 
-  describe 'tracker methods' do
-
+  describe "tracker methods" do
     before do
-      Time.zone = 'Eastern Time (US & Canada)'
+      Time.zone = "Eastern Time (US & Canada)"
     end
 
-    it 'should store the initial state timestamp when the record is created' do
+    it "should store the initial state timestamp when the record is created" do
       a = Animal.new
       a.save
       a.unborn_status_at.should be_within(1).of(Time.zone.now)
     end
 
-    it 'should store when a record changed state for the first time' do
+    it "should store when a record changed state for the first time" do
       a = Animal.new
       a.unborn_status_at.should be_nil
       a.born_status_at.should be_nil
@@ -202,7 +238,7 @@ describe Stator::Model do
       a.born_status_at.should be_within(1).of(Time.zone.now)
     end
 
-    it 'should store when a record change states' do
+    it "should store when a record change states" do
       a = Animal.new
       a.status_changed_at.should be_nil
 
@@ -216,23 +252,64 @@ describe Stator::Model do
       a.save
 
       a.status_changed_at.should eql(previous_status_changed_at)
-
     end
 
-    it 'should prepend the setting of the timestamp so other callbacks can use it' do
+    it "should prepend the setting of the timestamp so other callbacks can use it" do
       u = User.new
+      u.email = "doug@example.com"
+
       u.tagged_at.should be_nil
-      u.semiactivate
+      u.semiactivate!
 
       u.semiactivated_state_at.should_not be_nil
       u.tagged_at.should_not be_nil
     end
 
+    it "should respect the timestamp if explicitly provided" do
+      t = Time.at(Time.now.to_i - 3600)
+
+      u = User.new
+      u.email = "doug@example.com"
+      u.state = "semiactivated"
+      u.semiactivated_state_at = t
+      u.save!
+
+      u.state.should eql("semiactivated")
+      u.semiactivated_state_at.should eql(t)
+    end
+
+    it "should respect the timestamp if explicitly provided via create" do
+      t = Time.at(Time.now.to_i - 3600)
+
+      u = User.create!(
+        email: "doug@example.com",
+        state: "semiactivated",
+        semiactivated_state_at: t
+      )
+
+      u.state.should eql("semiactivated")
+      u.semiactivated_state_at.should eql(t)
+    end
+
+    it "should allow opting into track by namespace" do
+      z = ZooKeeper.new(name: "Doug")
+      z.employment_state.should eql("hired")
+      z.employment_fire!
+      z.fired_employment_state_at.should_not be_nil
+
+      z.employment_hire!
+      z.hired_employment_state_at.should_not be_nil
+
+      z.working_start!
+      z.started_working_state_at.should be_nil
+      z.working_end!
+      z.ended_working_state_at.should be_nil
+    end
   end
 
-  describe 'aliasing' do
-    it 'should allow aliasing within the dsl' do
-      u = User.new(:email => 'doug@example.com')
+  describe "aliasing" do
+    it "should allow aliasing within the dsl" do
+      u = User.new(email: "doug@example.com")
       u.should respond_to(:active?)
       u.should respond_to(:inactive?)
 
@@ -249,11 +326,11 @@ describe Stator::Model do
       u.should be_active
       u.should_not be_inactive
 
-      User::ACTIVE_STATES.should eql(['activated', 'hyperactivated'])
-      User::INACTIVE_STATES.should eql(['pending', 'deactivated', 'semiactivated'])
+      User::ACTIVE_STATES.should eql(%w[activated hyperactivated])
+      User::INACTIVE_STATES.should eql(%w[pending deactivated semiactivated])
 
-      User.active.to_sql.gsub('  ', ' ').should eq("SELECT users.* FROM users WHERE users.state IN ('activated', 'hyperactivated')")
-      User.inactive.to_sql.gsub('  ', ' ').should eq("SELECT users.* FROM users WHERE users.state IN ('pending', 'deactivated', 'semiactivated')")
+      User.active.to_sql.gsub("  ", " ").should eq("SELECT users.* FROM users WHERE users.state IN ('activated', 'hyperactivated')")
+      User.inactive.to_sql.gsub("  ", " ").should eq("SELECT users.* FROM users WHERE users.state IN ('pending', 'deactivated', 'semiactivated')")
     end
 
     it "should evaluate inverses correctly" do
@@ -268,7 +345,7 @@ describe Stator::Model do
       f.should be_house_cleaned
     end
 
-    it 'should namespace aliases just like everything else' do
+    it "should namespace aliases just like everything else" do
       f = Farm.new
       f.should respond_to(:house_cleaned?)
 
@@ -278,19 +355,23 @@ describe Stator::Model do
       f.should be_house_cleaned
     end
 
-    it 'should allow for explicit constant and scope names to be provided' do
+    it "should allow for explicit constant and scope names to be provided" do
       User.should respond_to(:luke_warmers)
       (!!defined?(User::LUKE_WARMERS)).should eql(true)
       u = User.new
       u.should respond_to(:luke_warm?)
     end
 
-    it 'should not create constants or scopes by default' do
+    it "should not create constants or scopes by default" do
       u = User.new
       u.should respond_to(:iced_tea?)
       (!!defined?(User::ICED_TEA_STATES)).should eql(false)
       User.should_not respond_to(:iced_tea)
     end
-  end
 
+    it "should determine the full list of states correctly" do
+      states = User._stator("").states
+      states.should eql(%w[pending activated deactivated semiactivated hyperactivated])
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -12,6 +12,7 @@ require 'stator'
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.expect_with(:rspec) { |c| c.syntax = :should }
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/spec/support/models.rb

@@ -1,10 +1,9 @@
 class User < ActiveRecord::Base
   extend Stator::Model
 
-  before_validation :set_tagged_at
+  before_save :set_tagged_at
 
-  # initial state = pending
-  stator track: true do
+  stator track: true, initial: :pending do
 
     transition :activate do
       from :pending, :semiactivated
@@ -135,6 +134,33 @@ class Zoo < ActiveRecord::Base
   end
 end
 
+class ZooKeeper < ActiveRecord::Base
+  extend Stator::Model
+
+  stator namespace: 'employment', field: 'employment_state', track: true do
+    transition :hire do
+      from nil, :fired
+      to :hired
+    end
+
+    transition :fire do
+      from :hired
+      to :fired
+    end
+  end
+
+  stator namespace: 'working', field: 'working_state', track: false do
+    transition :start do
+      from nil, :ended
+      to :started
+    end
+
+    transition :end do
+      from :started
+      to :ended
+    end
+  end
+end
 
 class Farm < ActiveRecord::Base
   extend Stator::Model

data/spec/support/schema.rb

@@ -22,6 +22,16 @@ ActiveRecord::Schema.define(:version => 20130628161227) do
     t.datetime "born_status_at"
   end
 
+  create_table "zoo_keepers", :force => true do |t|
+    t.string   "name"
+    t.string   "employment_state",                      :default => 'hired'
+    t.datetime "hired_employment_state_at"
+    t.datetime "fired_employment_state_at"
+    t.string   "working_state"
+    t.datetime "started_working_state_at"
+    t.datetime "ended_working_state_at"
+  end
+
   create_table "zoos", :force => true do |t|
     t.string   "name"
     t.string   "state",                                 :default => 'closed'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stator
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.3
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-23 00:00:00.000000000 Z
+date: 2021-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,6 +44,7 @@ files:
 - gemfiles/ar40.gemfile
 - gemfiles/ar41.gemfile
 - gemfiles/ar42.gemfile
+- gemfiles/ar52.gemfile
 - lib/stator.rb
 - lib/stator/alias.rb
 - lib/stator/integration.rb
@@ -74,8 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: The simplest of ActiveRecord state machines