can_has_state 0.2.2 → 0.3.0

data/README.md

@@ -104,7 +104,8 @@ Add it to your `Gemfile`:
         #   triggers are useful for logging or cascading changes to association
         #   models. Deferred trigger actions are run within the same database
         #   transaction (for ActiveRecord and other ActiveModel children that
-        #   implement this).
+        #   implement this). Deferred triggers require support for after_save
+        #   callbacks, compatible with that supported by ActiveRecord.
         #
         # Last, wildcards are supported. Note that the ruby parser requires a
         #   space after the asterisk for wildcards on the left side:
@@ -131,11 +132,13 @@ Add it to your `Gemfile`:
 ### Just ActiveModel ###
 
     class Account
-      include ActiveModel::Dirty
+      include CanHasState::DirtyHelper
       include ActiveModel::Validations
       include ActiveModel::Validations::Callbacks
       include CanHasState::Machine
 
+      track_dirty :account_state
+
       state_machine :account_state do
         state :active, :initial,
           :from => :inactive
@@ -148,6 +151,16 @@ Add it to your `Gemfile`:
 
     end
 
+ActiveModel::Dirty tracking must be enabled for the attribute(s) that hold the
+state(s) in your model (see docs for ActiveModel::Dirty). If you're building on
+top of a library that supports this (ActiveRecord, Mongoid, etc.), you're fine.
+If not, CanHasState provides a helper module, `CanHasState::DirtyHelper`, that
+provides the supporting implementation required by ActiveModel::Dirty. Just call
+`track_dirty :attr_one, :attr_two` as shown above.
+
+Hint: deferred triggers aren't supported with bare ActiveModel. However, if a
+non-ActiveRecord persistence engine provides #after_save, then deferred triggers
+will be enabled.
 
 
 ## Managing states ##
@@ -230,7 +243,9 @@ will be called.
 ## Notes on triggers and initial state ##
 
 `can_has_state` relies on the `ActiveModel::Dirty` module to detect when a state
-attribute has changed. In general, this shouldn't matter much to you.
+attribute has changed. In general, this shouldn't matter much to you as long as
+you're using ActiveRecord, Mongoid, or something that implements full Dirty
+support.
 
 However, triggers involving initial values can be tricky. If your database
 schema sets the default value to the initial value, `:on_enter` and custom
@@ -242,4 +257,4 @@ because the initial state value changed from nil to the initial state.
 
 ## Compatibility ##
 
-Tested with Ruby 1.9 and ActiveSupport and ActiveModel 3.2.8.
+Tested with Ruby 1.9 and ActiveSupport and ActiveModel 4.0.

data/Rakefile

@@ -1,30 +1,4 @@
-#!/usr/bin/env rake
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-begin
-  require 'rdoc/task'
-rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
-  RDoc::Task = Rake::RDocTask
-end
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'CanHasState'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-
-
-
-Bundler::GemHelper.install_tasks
-
+require 'bundler/gem_tasks'
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
@@ -34,5 +8,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
 task :default => :test

data/lib/can_has_state/definition.rb

@@ -35,20 +35,26 @@ module CanHasState
         when :from
           from_vals = Array(val).map(&:to_s)
           from_vals << nil # for new records
-          guards << Proc.new{|r| from_vals.include? r.send("#{column}_was").try(:to_s)}
+          guards << Proc.new do |r|
+            val_was = r.send("#{column}_was")
+            val_was &&= val_was.to_s
+            from_vals.include? val_was
+          end
         when :guard, :require
           guards += Array(val)
         when :message
           message = val
         when :timestamp
-          @triggers << {:from=>["*"], :to=>[state_name], :trigger=>[Proc.new{|r| r.send("#{val}=", Time.current)}]}
+          @triggers << {:from=>["*"], :to=>[state_name], :trigger=>[Proc.new{|r| r.send("#{val}=", Time.now.utc)}]}
         when :on_enter
           @triggers << {:from=>["*"], :to=>[state_name], :trigger=>Array(val), :type=>:on_enter}
         when :on_enter_deferred
+          raise(ArgumentError, "use of deferred triggers requires support for #after_save callbacks") unless respond_to?(:after_save)
           @triggers << {:from=>["*"], :to=>[state_name], :trigger=>Array(val), :type=>:on_enter, :deferred=>true}
         when :on_exit
           @triggers << {:from=>[state_name], :to=>["*"], :trigger=>Array(val), :type=>:on_exit}
         when :on_exit_deferred
+          raise(ArgumentError, "use of deferred triggers requires support for #after_save callbacks") unless respond_to?(:after_save)
           @triggers << {:from=>[state_name], :to=>["*"], :trigger=>Array(val), :type=>:on_exit, :deferred=>true}
         end
       end
@@ -60,6 +66,7 @@ module CanHasState
     def on(pairs)
       trigger  = pairs.delete :trigger
       deferred = pairs.delete :deferred
+      raise(ArgumentError, "use of deferred triggers requires support for #after_save callbacks") if deferred && !respond_to?(:after_save)
       pairs.each do |from, to|
         @triggers << {:from=>Array(from).map(&:to_s), :to=>Array(to).map(&:to_s), 
                       :trigger=>Array(trigger), :type=>:trigger, :deferred=>!!deferred}
@@ -69,10 +76,12 @@ module CanHasState
 
 
     def known?(to)
-       @states.keys.include? to
+      to &&= to.to_s
+      @states.keys.include? to
     end
 
     def allow?(record, to)
+      to &&= to.to_s
       return false unless known?(to)
       states[to][:guards].all? do |g|
         case g
@@ -87,11 +96,14 @@ module CanHasState
     end
 
     def message(to)
+      to &&= to.to_s
       states[to][:message]
     end
 
 
     def trigger(record, from, to, deferred=false)
+      from &&= from.to_s
+      to &&= to.to_s
       # Rails.logger.debug "Checking triggers for transition #{from} to #{to} (deferred:#{deferred.inspect})"
       @triggers.select do |trigger|
         deferred ? trigger[:deferred] : !trigger[:deferred]

data/lib/can_has_state/dirty_helper.rb

@@ -0,0 +1,28 @@
+module CanHasState
+  module DirtyHelper
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Dirty
+    end
+
+    module ClassMethods
+
+      def track_dirty(*attrs)
+        define_attribute_methods attrs
+        attrs.each do |attr|
+          attr = attr.to_s
+          attr_reader(attr) unless respond_to?(attr)
+          has_writer = respond_to?("#{attr}=")
+          define_method "#{attr}=" do |val|
+            send("#{attr}_will_change!") unless val == instance_variable_get("@#{attr}")
+            has_writer ? super(val) : instance_variable_set("@#{attr}", val)
+            changed_attributes.delete(attr) if attribute_was(attr) == send(attr)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/can_has_state/machine.rb

@@ -16,7 +16,7 @@ module CanHasState
 
       def extend_state_machine(column, &block)
         sm = state_machines.detect{|(col, stm)| col == column}
-        raise("Unknown state machine #{column}") unless sm
+        raise(ArgumentError, "Unknown state machine #{column}") unless sm
         sm[1].extend_machine &block
       end
 
@@ -30,7 +30,7 @@ module CanHasState
       before_validation :can_has_initial_states
       before_validation :can_has_state_triggers
       validate :can_has_valid_state_machines
-      after_save :can_has_deferred_state_triggers
+      after_save :can_has_deferred_state_triggers if respond_to?(:after_save)
     end
 
 
@@ -81,7 +81,7 @@ module CanHasState
         from, to = send("#{column}_was"), send(column)
         next if from == to
         if !sm.known?(to)
-          err << [column, "is not a known state"]
+          err << [column, "is not in a known state"]
         elsif !sm.allow?(self, to) #state_machine_allow?(column, to)
           err << [column, sm.message(to) % {:from=>from, :to=>to}]
         end

data/lib/can_has_state/version.rb

@@ -1,3 +1,3 @@
 module CanHasState
-  VERSION = "0.2.2"
+  VERSION = '0.3.0'
 end

data/lib/can_has_state.rb

@@ -1,7 +1,8 @@
 require 'active_support'
 require 'active_model'
 
-require 'can_has_state/definition'
-require 'can_has_state/machine'
+%w(definition dirty_helper machine).each do |f|
+  require "can_has_state/#{f}"
+end
 
 require 'can_has_state/railtie' if defined?(Rails)

data/test/can_has_state_test.rb

@@ -1,7 +1,212 @@
 require 'test_helper'
 
-class CanHasStateTest < ActiveSupport::TestCase
-  test "truth" do
-    assert_kind_of Module, CanHasState
+class Account
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+  include CanHasState::DirtyHelper
+  include CanHasState::Machine
+
+  attr_accessor :deleted_at, :undeleted, :allow_special
+  track_dirty :account_state
+
+  state_machine :account_state do
+    state :active,
+      from: [:inactive, :special]
+    state :special,
+      require: :allow_special
+    state :inactive,
+      from: [:active, :deleted, :special]
+    state :deleted,
+      from: [:active, :inactive],
+      timestamp: :deleted_at
+    on :deleted => :*, trigger: ->(acct){ acct.undeleted = true }
+  end
+
+  def fake_persist
+    if valid?
+      # just reset dirty tracking and pretend all is good
+      changed_attributes.clear
+      true
+    end
+  end
+end
+
+class UserBare ; end
+class UserState
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+  include CanHasState::Machine
+  state_machine :state do
+    state :awesome
+    state :fabulous, :initial
+  end
+end
+class UserExtended
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+  include CanHasState::Machine
+  state_machine :state do
+    state :awesome
+    state :fabulous, :initial
+  end
+  extend_state_machine :state do
+    state :incredible, :initial
+  end
+  extend_state_machine :state do
+    state :fantastic
+  end
+end
+class UserPreState
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+  include CanHasState::Machine
+end
+
+class CanHasStateTest < MiniTest::Unit::TestCase #Minitest::Test
+
+  def test_builder_simple
+    refute UserBare.respond_to?(:state_machine)
+    assert UserState.respond_to?(:state_machine)
+    assert UserState.respond_to?(:state_machines)
+    assert UserState.new.respond_to?(:allow_state?)
+    assert_equal 1, UserState.state_machines.size
+    sm = UserState.state_machines[0][1]
+    assert_equal :state, sm.column
+    assert_equal 2, sm.states.size
+    assert_equal 0, sm.triggers.size
+    assert_equal 'fabulous', sm.initial_state
+  end
+
+  def test_builder_extended
+    assert_equal 1, UserExtended.state_machines.size
+    sm = UserExtended.state_machines[0][1]
+    assert_equal :state, sm.column
+    assert_equal 4, sm.states.size
+    assert_equal 0, sm.triggers.size
+    assert_equal 'incredible', sm.initial_state
+  end
+
+  def test_extending
+    assert_raises(ArgumentError) do
+      UserState.class_eval do
+        extend_state_machine :doesnt_exist do
+          state :phantom
+        end
+      end
+    end
+  end
+
+  def test_deferred_unavailable
+    assert_raises(ArgumentError) do
+      UserPreState.class_eval do
+        state_machine :state_one do
+          state :one, on_enter_deferred: ->{ raise "Shouldn't get here" }
+        end
+      end
+    end
+
+    assert_raises(ArgumentError) do
+      UserPreState.class_eval do
+        state_machine :state_two do
+          state :two, on_exit_deferred: ->{ raise "Shouldn't get here" }
+        end
+      end
+    end
+
+    assert_raises(ArgumentError) do
+      UserPreState.class_eval do
+        state_machine :state_three do
+          state :three
+          on :* => :*, trigger: ->{ raise "Shouldn't get here" }, deferred: true
+        end
+      end
+    end
   end
+
+  def test_builder_complex
+    assert_equal 1, Account.state_machines.size
+    sm = Account.state_machines[0][1]
+    assert_equal :account_state, sm.column
+    assert_equal 4, sm.states.size
+    assert_equal 2, sm.triggers.size
+    assert_equal 'active', sm.initial_state
+  end
+
+  def test_state_builder
+    sm_acct = Account.state_machines[0][1]
+    sm_user = UserState.state_machines[0][1]
+    assert_equal 0, sm_user.states['awesome'][:guards].size
+    assert_equal 1, sm_acct.states['active'][:guards].size
+  end
+
+
+  def test_dirty_helper
+    assert Account.new.respond_to?(:account_state)
+    assert Account.new.respond_to?(:account_state_was)
+
+    a = Account.new
+    a.fake_persist
+    assert_equal 'active', a.account_state
+    assert_equal 'active', a.account_state_was
+    a.account_state = 'inactive'
+    assert_equal 'inactive', a.account_state
+    assert_equal 'active', a.account_state_was
+    a.fake_persist
+    assert_equal 'inactive', a.account_state
+    assert_equal 'inactive', a.account_state_was
+  end
+
+  def test_state_vals
+    a = Account.new
+    a.account_state = :inactive
+    assert a.valid?, "Should be valid; got errors: #{a.errors.to_a}"
+
+    a = Account.new
+    a.account_state = 'inactive'
+    assert a.valid?, "Should be valid; got errors: #{a.errors.to_a}"
+
+    a = Account.new
+    a.account_state = 'madeup'
+    refute a.valid?
+    assert_equal ['Account state is not in a known state'], a.errors.to_a
+  end
+
+  def test_triggers
+    a = Account.new
+    a.fake_persist
+    assert_equal 'active', a.account_state
+    refute a.deleted_at
+    refute a.undeleted
+
+    a.account_state = 'deleted'
+    assert a.fake_persist
+    assert_kind_of Time, a.deleted_at
+    refute a.undeleted
+
+    a.account_state = 'inactive'
+    assert a.fake_persist, "Unexpected error: #{a.errors.to_a}"
+    assert a.undeleted, 'Expecting undeleted to be set'
+  end
+
+  def test_guards
+    a = Account.new
+    a.account_state = 'deleted'
+    assert a.fake_persist
+
+    a.account_state = 'active'
+    a.valid?
+    assert_match /invalid transition/, a.errors.to_a.first
+
+    a.account_state = 'inactive'
+    assert a.valid?, "Errors: #{a.errors.to_a}"
+
+
+    a.account_state = 'special'
+    a.valid?
+    assert_match /invalid transition/, a.errors.to_a.first
+
+    a.allow_special = true
+    assert a.valid?, "Errors: #{a.errors.to_a}"
+  end
+
 end

data/test/test_helper.rb

@@ -1,15 +1,4 @@
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
+require 'minitest/autorun'
+require 'turn'
 
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
-require "rails/test_help"
-
-Rails.backtrace_cleaner.remove_silencers!
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# Load fixtures from the engine
-if ActiveSupport::TestCase.method_defined?(:fixture_path=)
-  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
-end
+require 'can_has_state'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: can_has_state
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-10 00:00:00.000000000 Z
+date: 2013-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -56,7 +56,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: turn
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -80,6 +96,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/can_has_state/definition.rb
+- lib/can_has_state/dirty_helper.rb
 - lib/can_has_state/machine.rb
 - lib/can_has_state/railtie.rb
 - lib/can_has_state/version.rb
@@ -89,34 +106,6 @@ files:
 - Rakefile
 - README.md
 - test/can_has_state_test.rb
-- test/dummy/app/assets/javascripts/application.js
-- test/dummy/app/assets/stylesheets/application.css
-- test/dummy/app/controllers/application_controller.rb
-- test/dummy/app/helpers/application_helper.rb
-- test/dummy/app/views/layouts/application.html.erb
-- test/dummy/config/application.rb
-- test/dummy/config/boot.rb
-- test/dummy/config/database.yml
-- test/dummy/config/environment.rb
-- test/dummy/config/environments/development.rb
-- test/dummy/config/environments/production.rb
-- test/dummy/config/environments/test.rb
-- test/dummy/config/initializers/backtrace_silencers.rb
-- test/dummy/config/initializers/inflections.rb
-- test/dummy/config/initializers/mime_types.rb
-- test/dummy/config/initializers/secret_token.rb
-- test/dummy/config/initializers/session_store.rb
-- test/dummy/config/initializers/wrap_parameters.rb
-- test/dummy/config/locales/en.yml
-- test/dummy/config/routes.rb
-- test/dummy/config.ru
-- test/dummy/public/404.html
-- test/dummy/public/422.html
-- test/dummy/public/500.html
-- test/dummy/public/favicon.ico
-- test/dummy/Rakefile
-- test/dummy/README.rdoc
-- test/dummy/script/rails
 - test/test_helper.rb
 homepage: https://github.com/zarqman/can_has_state
 licenses: []
@@ -130,52 +119,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1517895089536744781
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1517895089536744781
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Super simple state machine for ActiveModel
 test_files:
 - test/can_has_state_test.rb
-- test/dummy/app/assets/javascripts/application.js
-- test/dummy/app/assets/stylesheets/application.css
-- test/dummy/app/controllers/application_controller.rb
-- test/dummy/app/helpers/application_helper.rb
-- test/dummy/app/views/layouts/application.html.erb
-- test/dummy/config/application.rb
-- test/dummy/config/boot.rb
-- test/dummy/config/database.yml
-- test/dummy/config/environment.rb
-- test/dummy/config/environments/development.rb
-- test/dummy/config/environments/production.rb
-- test/dummy/config/environments/test.rb
-- test/dummy/config/initializers/backtrace_silencers.rb
-- test/dummy/config/initializers/inflections.rb
-- test/dummy/config/initializers/mime_types.rb
-- test/dummy/config/initializers/secret_token.rb
-- test/dummy/config/initializers/session_store.rb
-- test/dummy/config/initializers/wrap_parameters.rb
-- test/dummy/config/locales/en.yml
-- test/dummy/config/routes.rb
-- test/dummy/config.ru
-- test/dummy/public/404.html
-- test/dummy/public/422.html
-- test/dummy/public/500.html
-- test/dummy/public/favicon.ico
-- test/dummy/Rakefile
-- test/dummy/README.rdoc
-- test/dummy/script/rails
 - test/test_helper.rb