state_machine 0.8.0 → 0.8.1

data/CHANGELOG.rdoc

@@ -1,5 +1,24 @@
 == master
 
+== 0.8.1 / 2010-03-14
+
+* Release gems via rake-gemcutter instead of rubyforge
+* Move rake tasks to lib/tasks
+* Dispatch state behavior to the superclass if it's undefined for a particular state [Sandro Turriate and Tim Pope]
+* Fix state / event names not supporting i18n in ActiveRecord
+* Fix original ActiveRecord::Observer#update not being used for non-state_machine callbacks [Jeremy Wells]
+* Add support for ActiveRecord 3.0
+* Fix without_{name} scopes not quoting columns in ActiveRecord [Jon Evans]
+* Fix without_{name} scopes not scoping columns to the table in ActiveRecord and Sequel [Jon Evans]
+* Fix custom state attributes not being marked properly as changed in ActiveRecord
+* Fix tracked attributes changes in ActiveRecord / DataMapper integrations not working correctly for non-loopbacks [Joe Lind]
+* Fix plural scope names being incorrect for DataMapper 0.9.4 - 0.9.6
+* Fix deprecation warnings for ruby-graphviz 0.9.0+
+* Add support for ActiveRecord 2.0.*
+* Fix nil states being overwritten when they're explicitly set in ORM integrations
+* Fix default states not getting set in ORM integrations if the column has a default
+* Fix event transitions being kept around while running actions/callbacks, sometimes preventing object marshalling
+
 == 0.8.0 / 2009-08-15
 
 * Add support for DataMapper 0.10.0

data/README.rdoc

@@ -427,6 +427,16 @@ For example,
 
   rake state_machine:draw:rails CLASS=Vehicle
 
+If you are using this library as a gem, the following must be added to the end
+of your application's Rakefile in order for the above task to work:
+
+  require 'tasks/state_machine'
+
+If you are using Rails 3.0+, you must also add the following to your
+application's Gemfile:
+
+  gem 'ruby-graphviz', :require => 'graphviz'
+
 ==== Merb Integration
 
 Like Ruby on Rails, there is a special integration Rake task for generating
@@ -454,13 +464,23 @@ integrations if the proper dependencies are available):
 
 Target specific versions of integrations like so:
 
-  rake test AR_VERSION=2.1.0 DM_VERSION=0.9.4 SEQUEL_VERSION=2.8.0
+  rake test AR_VERSION=2.0.0 DM_VERSION=0.9.4 SEQUEL_VERSION=2.8.0
+
+== Caveats
+
+The following caveats should be noted when using state_machine:
+
+* DataMapper: dm-validations 0.9.4 - 0.9.6 causes +after+ callbacks for
+attribute-based event transitions to fail
+* Overridden event methods won't get invoked when using attribute-based event
+transitions
 
 == Dependencies
 
-By default, there are no dependencies.  If using specific integrations, those
-dependencies are listed below.
+* Ruby 1.8.6 or later
+
+If using specific integrations:
 
-* ActiveRecord[http://rubyonrails.org] integration: 2.1.0 or later
+* ActiveRecord[http://rubyonrails.org] integration: 2.0.0 or later
 * DataMapper[http://datamapper.org] integration: 0.9.4 or later
 * Sequel[http://sequel.rubyforge.org] integration: 2.8.0 or later

data/Rakefile

@@ -1,16 +1,17 @@
+require 'rubygems'
+require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
-require 'rake/contrib/sshpublisher'
 
 spec = Gem::Specification.new do |s|
   s.name              = 'state_machine'
-  s.version           = '0.8.0'
+  s.version           = '0.8.1'
   s.platform          = Gem::Platform::RUBY
   s.summary           = 'Adds support for creating state machines for attributes on any Ruby class'
   s.description       = s.summary
   
-  s.files             = FileList['{examples,lib,tasks,test}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc) - FileList['test/*.log']
+  s.files             = FileList['{examples,lib,test}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc) - FileList['test/*.log']
   s.require_path      = 'lib'
   s.has_rdoc          = true
   s.test_files        = Dir['test/**/*_test.rb']
@@ -63,17 +64,17 @@ end
 
 Rake::GemPackageTask.new(spec) do |p|
   p.gem_spec = spec
-  p.need_tar = true
-  p.need_zip = true
 end
 
 desc 'Publish the beta gem.'
 task :pgem => [:package] do
+  require 'rake/contrib/sshpublisher'
   Rake::SshFilePublisher.new('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{spec.name}-#{spec.version}.gem").upload
 end
 
 desc 'Publish the API documentation.'
 task :pdoc => [:rdoc] do
+  require 'rake/contrib/sshpublisher'
   Rake::SshDirPublisher.new('aaron@pluginaweek.org', "/home/aaron/api.pluginaweek.org/public/#{spec.name}", 'rdoc').upload
 end
 
@@ -82,17 +83,10 @@ task :publish => [:pgem, :pdoc, :release]
 
 desc 'Publish the release files to RubyForge.'
 task :release => [:gem, :package] do
-  require 'rubyforge'
+  require 'rake/gemcutter'
   
-  ruby_forge = RubyForge.new.configure
-  ruby_forge.login
-  
-  %w(gem tgz zip).each do |ext|
-    file = "pkg/#{spec.name}-#{spec.version}.#{ext}"
-    puts "Releasing #{File.basename(file)}..."
-    
-    ruby_forge.add_release(spec.rubyforge_project, spec.name, spec.version, file)
-  end
+  Rake::Gemcutter::Tasks.new(spec)
+  Rake::Task['gem:push'].invoke
 end
 
-Dir['tasks/**/*.rake'].each {|rake| load rake}
+load 'lib/tasks/state_machine.rake'

data/lib/state_machine.rb

@@ -385,4 +385,4 @@ Class.class_eval do
 end
 
 # Register rake tasks for supported libraries
-Merb::Plugins.add_rakefiles("#{File.dirname(__FILE__)}/../tasks/state_machine") if defined?(Merb::Plugins)
+Merb::Plugins.add_rakefiles("#{File.dirname(__FILE__)}/tasks/state_machine") if defined?(Merb::Plugins)

data/lib/state_machine/event_collection.rb

@@ -102,19 +102,17 @@ module StateMachine
     def attribute_transition_for(object, invalidate = false)
       return unless machine.action
       
-      result = nil
-      
-      if event_name = machine.read(object, :event)
+      result = machine.read(object, :event_transition) || if event_name = machine.read(object, :event)
         if event = self[event_name.to_sym, :name]
-          unless result = machine.read(object, :event_transition) || event.transition_for(object)
+          event.transition_for(object) || begin
             # No valid transition: invalidate
             machine.invalidate(object, :event, :invalid_event, [[:state, machine.states.match!(object).name || 'nil']]) if invalidate
-            result = false
+            false
           end
         else
           # Event is unknown: invalidate
           machine.invalidate(object, :event, :invalid) if invalidate
-          result = false
+          false
         end
       end
       

data/lib/state_machine/integrations/active_record.rb

@@ -259,6 +259,50 @@ module StateMachine
     #       Audit.log(record, transition)
     #     end
     #   end
+    # 
+    # == Internationalization
+    # 
+    # In Rails 2.2+, any error message that is generated from performing invalid
+    # transitions can be localized.  The following default translations are used:
+    # 
+    #   en:
+    #     activerecord:
+    #       errors:
+    #         messages:
+    #           invalid: "is invalid"
+    #           invalid_event: "cannot transition when {{state}}"
+    #           invalid_transition: "cannot transition via {{event}}"
+    # 
+    # You can override these for a specific model like so:
+    # 
+    #   en:
+    #     activerecord:
+    #       errors:
+    #         models:
+    #           user:
+    #             invalid: "is not valid"
+    # 
+    # In addition to the above, you can also provide translations for the
+    # various states / events in each state machine.  Using the Vehicle example,
+    # state translations will be looked for using the following keys:
+    # * <tt>activerecord.state_machines.vehicle.state.states.parked</tt>
+    # * <tt>activerecord.state_machines.state.states.parked
+    # * <tt>activerecord.state_machines.states.parked</tt>
+    # 
+    # Event translations will be looked for using the following keys:
+    # * <tt>activerecord.state_machines.vehicle.state.events.ignite</tt>
+    # * <tt>activerecord.state_machines.state.events.ignite
+    # * <tt>activerecord.state_machines.events.ignite</tt>
+    # 
+    # An example translation configuration might look like so:
+    # 
+    #   es:
+    #     activerecord:
+    #       state_machines:
+    #         states:
+    #           parked: 'estacionado'
+    #         events:
+    #           park: 'estacionarse'
     module ActiveRecord
       # The default options to use for state machines using this integration
       class << self; attr_reader :defaults; end
@@ -285,7 +329,9 @@ module StateMachine
       # state value actually changed
       def write(object, attribute, value)
         result = super
-        object.send("#{self.attribute}_will_change!") if attribute == :state && object.respond_to?("#{self.attribute}_will_change!")
+        if attribute == :state && object.respond_to?("#{self.attribute}_will_change!") && !object.send("#{self.attribute}_changed?")
+          object.send("#{self.attribute}_will_change!")
+        end
         result
       end
       
@@ -294,10 +340,26 @@ module StateMachine
         attribute = self.attribute(attribute)
         
         if Object.const_defined?(:I18n)
-          options = values.inject({}) {|options, (key, value)| options[key] = value; options}
-          object.errors.add(attribute, message, options.merge(
-            :default => @messages[message]
-          ))
+          klasses =
+            if ::ActiveRecord::VERSION::MAJOR >= 3
+              object.class.lookup_ancestors
+            elsif ::ActiveRecord::VERSION::MINOR == 3 && ::ActiveRecord::VERSION::TINY >= 2
+              object.class.self_and_descendants_from_active_record
+            else
+              object.class.self_and_descendents_from_active_record
+            end
+          
+          options = values.inject({}) do |options, (key, value)|
+            # Generate all possible translation keys
+            group = key.to_s.pluralize
+            translations = klasses.map {|klass| :"#{klass.model_name.underscore}.#{name}.#{group}.#{value}"}
+            translations.concat([:"#{name}.#{group}.#{value}", :"#{group}.#{value}", value.to_s])
+            
+            options[key] = I18n.translate(translations.shift, :default => translations, :scope => [:activerecord, :state_machines])
+            options
+          end
+          
+          object.errors.add(attribute, message, options.merge(:default => @messages[message]))
         else
           object.errors.add(attribute, generate_message(message, values))
         end
@@ -330,13 +392,21 @@ module StateMachine
             
             # Hooks in to attribute initialization to set the states *prior*
             # to the attributes being set
-            def attributes=(*args)
+            def attributes=(new_attributes, *args)
               if new_record? && !@initialized_state_machines
                 @initialized_state_machines = true
                 
-                initialize_state_machines(:dynamic => false)
+                if new_attributes
+                  attributes = new_attributes.dup
+                  attributes.stringify_keys!
+                  ignore = remove_attributes_protected_from_mass_assignment(attributes).keys
+                else
+                  ignore = []
+                end
+                
+                initialize_state_machines(:dynamic => false, :ignore => ignore)
                 super
-                initialize_state_machines(:dynamic => true)
+                initialize_state_machines(:dynamic => true, :ignore => ignore)
               else
                 super
               end
@@ -387,15 +457,16 @@ module StateMachine
         # Creates a scope for finding records *with* a particular state or
         # states for the attribute
         def create_with_scope(name)
-          attribute = self.attribute
           define_scope(name, lambda {|values| {:conditions => {attribute => values}}})
         end
         
         # Creates a scope for finding records *without* a particular state or
         # states for the attribute
         def create_without_scope(name)
-          attribute = self.attribute
-          define_scope(name, lambda {|values| {:conditions => ["#{attribute} NOT IN (?)", values]}})
+          define_scope(name, lambda {|values|
+            connection = owner_class.connection
+            {:conditions => ["#{connection.quote_table_name(owner_class.table_name)}.#{connection.quote_column_name(attribute)} NOT IN (?)", values]}
+          })
         end
         
         # Runs a new database transaction, rolling back any changes by raising
@@ -424,20 +495,26 @@ module StateMachine
         # state names can be translated to their associated values and so that
         # inheritance is respected properly.
         def define_scope(name, scope)
-          name = name.to_sym
-          machine_name = self.name
-          
-          # Create the scope and then override it with state translation
-          owner_class.named_scope(name)
-          owner_class.scopes[name] = lambda do |klass, *states|
-            machine_states = klass.state_machine(machine_name).states
-            values = states.flatten.map {|state| machine_states.fetch(state).value}
+          if ::ActiveRecord::VERSION::MAJOR <= 2
+            if owner_class.respond_to?(:named_scope)
+              name = name.to_sym
+              machine_name = self.name
+              
+              # Create the scope and then override it with state translation
+              owner_class.named_scope(name)
+              owner_class.scopes[name] = lambda do |klass, *states|
+                machine_states = klass.state_machine(machine_name).states
+                values = states.flatten.map {|state| machine_states.fetch(state).value}
+                
+                ::ActiveRecord::NamedScope::Scope.new(klass, scope.call(values))
+              end
+            end
             
-            ::ActiveRecord::NamedScope::Scope.new(klass, scope.call(values))
+            # Prevent the Machine class from wrapping the scope
+            false
+          else
+            lambda {|klass, values| klass.where(scope.call(values)[:conditions])}
           end
-          
-          # Prevent the Machine class from wrapping the scope
-          false
         end
         
         # Notifies observers on the given object that a callback occurred

data/lib/state_machine/integrations/active_record/observer.rb

@@ -29,7 +29,11 @@ module StateMachine
         # Allows additional arguments other than the object to be passed to the
         # observed methods
         def update_with_multiple_args(observed_method, object, *args) #:nodoc:
-          send(observed_method, object, *args) if respond_to?(observed_method)
+          if args.any?
+            send(observed_method, object, *args) if respond_to?(observed_method)
+          else
+            update_without_multiple_args(observed_method, object)
+          end
         end
       end
     end

data/lib/state_machine/integrations/data_mapper.rb

@@ -257,9 +257,10 @@ module StateMachine
         result = super
         if attribute == :state && owner_class.properties.detect {|property| property.name == self.attribute}
           if ::DataMapper::VERSION =~ /^(0\.\d\.)/ # Match anything < 0.10
-            object.original_values[self.attribute] = "#{value}-ignored"
+            object.original_values[self.attribute] = "#{value}-ignored" if object.original_values[self.attribute] == value
           else
-            object.original_attributes[owner_class.properties[self.attribute]] = "#{value}-ignored"
+            property = owner_class.properties[self.attribute]
+            object.original_attributes[property] = "#{value}-ignored" unless object.original_attributes.include?(property)
           end
         end
         result
@@ -281,6 +282,25 @@ module StateMachine
           @supports_validations ||= ::DataMapper.const_defined?('Validate')
         end
         
+        # Pluralizes the name using the built-in inflector
+        def pluralize(word)
+          Extlib::Inflection.pluralize(word.to_s)
+        end
+        
+        # Defines an initialization hook into the owner class for setting the
+        # initial state of the machine *before* any attributes are set on the
+        # object
+        def define_state_initializer
+          @instance_helper_module.class_eval <<-end_eval, __FILE__, __LINE__
+            def initialize(attributes = {}, *args)
+              ignore = attributes ? attributes.keys : []
+              initialize_state_machines(:dynamic => false, :ignore => ignore)
+              super
+              initialize_state_machines(:dynamic => true, :ignore => ignore)
+            end
+          end_eval
+        end
+        
         # Skips defining reader/writer methods since this is done automatically
         def define_state_accessor
           owner_class.property(attribute, String) unless owner_class.properties.detect {|property| property.name == attribute}
@@ -308,14 +328,12 @@ module StateMachine
         # Creates a scope for finding records *with* a particular state or
         # states for the attribute
         def create_with_scope(name)
-          attribute = self.attribute
           lambda {|resource, values| resource.all(attribute => values)}
         end
         
         # Creates a scope for finding records *without* a particular state or
         # states for the attribute
         def create_without_scope(name)
-          attribute = self.attribute
           lambda {|resource, values| resource.all(attribute.to_sym.not => values)}
         end
         

data/lib/state_machine/integrations/sequel.rb

@@ -253,13 +253,14 @@ module StateMachine
           @instance_helper_module.class_eval <<-end_eval, __FILE__, __LINE__
             # Hooks in to attribute initialization to set the states *prior*
             # to the attributes being set
-            def set(*args)
+            def set(hash, *args)
               if new? && !@initialized_state_machines
                 @initialized_state_machines = true
                 
-                initialize_state_machines(:dynamic => false)
+                ignore = setter_methods(nil, nil).map {|setter| setter.chop.to_sym} & (hash ? hash.keys.map {|attribute| attribute.to_sym} : [])
+                initialize_state_machines(:dynamic => false, :ignore => ignore)
                 result = super
-                initialize_state_machines(:dynamic => true)
+                initialize_state_machines(:dynamic => true, :ignore => ignore)
                 result
               else
                 super
@@ -291,15 +292,13 @@ module StateMachine
         # Creates a scope for finding records *with* a particular state or
         # states for the attribute
         def create_with_scope(name)
-          attribute = self.attribute
-          lambda {|model, values| model.filter(attribute.to_sym => values)}
+          lambda {|model, values| model.filter(:"#{owner_class.table_name}__#{attribute}" => values)}
         end
         
         # Creates a scope for finding records *without* a particular state or
         # states for the attribute
         def create_without_scope(name)
-          attribute = self.attribute
-          lambda {|model, values| model.filter(~{attribute.to_sym => values})}
+          lambda {|model, values| model.filter(~{:"#{owner_class.table_name}__#{attribute}" => values})}
         end
         
         # Runs a new database transaction, rolling back any changes if the

data/lib/state_machine/machine.rb

@@ -1258,21 +1258,16 @@ module StateMachine
         :path => '.',
         :format => 'png',
         :font => 'Arial',
-        :orientation => 'portrait',
-        :output => true
+        :orientation => 'portrait'
       }.merge(options)
-      assert_valid_keys(options, :name, :path, :format, :font, :orientation, :output)
+      assert_valid_keys(options, :name, :path, :format, :font, :orientation)
       
       begin
         # Load the graphviz library
         require 'rubygems'
         require 'graphviz'
         
-        graph = GraphViz.new('G',
-          :output => options[:format],
-          :file => File.join(options[:path], "#{options[:name]}.#{options[:format]}"),
-          :rankdir => options[:orientation] == 'landscape' ? 'LR' : 'TB'
-        )
+        graph = GraphViz.new('G', :rankdir => options[:orientation] == 'landscape' ? 'LR' : 'TB')
         
         # Add nodes
         states.by_priority.each do |state|
@@ -1287,7 +1282,20 @@ module StateMachine
         end
         
         # Generate the graph
-        graph.output if options[:output]
+        graphvizVersion = Constants::RGV_VERSION.split('.')
+        
+        if graphvizVersion[0] == '0' && (graphvizVersion[1] < '9' || graphvizVersion[1] == '9' && graphvizVersion[2] == '0')
+          outputOptions = {
+            :output => options[:format],
+            :file => File.join(options[:path], "#{options[:name]}.#{options[:format]}")
+          }
+        else
+          outputOptions = {
+            options[:format] => File.join(options[:path], "#{options[:name]}.#{options[:format]}")
+          }
+        end
+        
+        graph.output(outputOptions)
         graph
       rescue LoadError
         $stderr.puts 'Cannot draw the machine. `gem install ruby-graphviz` and try again.'
@@ -1408,7 +1416,7 @@ module StateMachine
       # automatically determined by either calling +pluralize+ on the attribute
       # name or adding an "s" to the end of the name.
       def define_scopes(custom_plural = nil)
-        plural = custom_plural || (name.to_s.respond_to?(:pluralize) ? name.to_s.pluralize : "#{name}s")
+        plural = custom_plural || pluralize(name)
         
         [name, plural].uniq.each do |name|
           [:with, :without].each do |kind|
@@ -1426,6 +1434,17 @@ module StateMachine
         end
       end
       
+      # Pluralizes the given word using #pluralize (if available) or simply
+      # adding an "s" to the end of the word 
+      def pluralize(word)
+        word = word.to_s
+        if word.respond_to?(:pluralize)
+          word.pluralize
+        else
+          "#{name}s"
+        end
+      end
+      
       # Creates a scope for finding objects *with* a particular value or values
       # for the attribute.
       #