@@ -1,5 +1,7 @@ == master +* Allow multiple state machines on the same class to target the same attribute +* Use :attribute to customize the attribute target and remove :as, assuming the name is the first argument of #state_machine * Add support for customizing generated methods like #{attribute}_name using :as instead of always prefixing with the attribute name * Simplify reading from / writing to machine-related attributes on objects * Fix locale for ActiveRecord getting added to the i18n load path multiple times [Reiner Dieterich] CHANGELOG.rdoc @@ -5,10 +5,12 @@ require 'state_machine/machine' # functionality on any Ruby class. module StateMachine module MacroMethods - # Creates a new state machine for the given attribute. The default - # attribute, if not specified, is <tt>:state</tt>. + # Creates a new state machine with the given name. The default name, if not + # specified, is <tt>:state</tt>. # # Configuration options: + # * <tt>:attribute</tt> - The name of the attribute to store the state value + # in. By default, this is the same as the name of the machine. # * <tt>:initial</tt> - The initial state of the attribute. This can be a # static state or a lambda block which will be evaluated at runtime # (e.g. lambda {|vehicle| vehicle.speed == 0 ? :parked : :idling}). @@ -16,10 +18,6 @@ module StateMachine # * <tt>:action</tt> - The instance method to invoke when an object # transitions. Default is nil unless otherwise specified by the # configured integration. - # * <tt>:as</tt> - The name to use for prefixing all generated machine - # instance / class methods (e.g. if the attribute is +state_id+, then - # "state" would generate :state_name, :state_transitions, etc. instead of - # :state_id_name and :state_id_transitions) # * <tt>:namespace</tt> - The name to use for namespacing all generated # state / event instance methods (e.g. "heater" would generate # :turn_on_heater and :turn_off_heater for the :turn_on/:turn_off events). @@ -54,7 +52,7 @@ module StateMachine # # == Examples # - # With the default attribute and no configuration: + # With the default name/attribute and no configuration: # # class Vehicle # state_machine do @@ -64,13 +62,14 @@ module StateMachine # end # end # - # The above example will define a state machine for the +state+ attribute - # on the class. Every vehicle will start without an initial state. + # The above example will define a state machine named "state" that will + # store the value in the +state+ attribute. Every vehicle will start + # without an initial state. # - # With a custom attribute: + # With a custom name / attribute: # # class Vehicle - # state_machine :status do + # state_machine :status, :attribute => :status_value do # ... # end # end @@ -94,7 +93,8 @@ module StateMachine # == Instance Methods # # The following instance methods will be automatically generated by the - # state machine. Any existing methods will not be overwritten. + # state machine based on the *name* of the machine. Any existing methods + # will not be overwritten. # * <tt>state</tt> - Gets the current value for the attribute # * <tt>state=(value)</tt> - Sets the current value for the attribute # * <tt>state?(name)</tt> - Checks the given state name against the current @@ -295,55 +295,11 @@ module StateMachine # see StateMachine::Machine#before_transition and # StateMachine::Machine#after_transition. # - # == Attribute aliases - # - # When a state machine is defined, several methods are generated scoped by - # the name of the attribute, such as (if the attribute were "state"): - # * <tt>state_name</tt> - # * <tt>state_event</tt> - # * <tt>state_transitions</tt> - # * etc. - # - # If the attribute for the machine were something less common, such as - # "state_id" or "state_value", this makes for more awkward scoped methods. - # - # Rather than scope based on the attribute, these methods can be customized - # using the <tt>:as</tt> option as essentially an alias. - # - # For example, - # - # class Vehicle - # state_machine :state_id, :as => :state do - # event :turn_on do - # transition all => :on - # end - # - # event :turn_off do - # transition all => :off - # end - # - # state :on, :value => 1 - # state :off, :value => 2 - # end - # end - # - # ...will generate the following methods: - # * <tt>state_name</tt> - # * <tt>state_event</tt> - # * <tt>state_transitions</tt> - # - # ...instead of: - # * <tt>state_id_name</tt> - # * <tt>state_id_event</tt> - # * <tt>state_id_transitions</tt> - # - # However, it will continue to read and write to the +state_id+ attribute. - # # == Namespaces # # When a namespace is configured for a state machine, the name provided # will be used in generating the instance methods for interacting with - # events/states in the machine. This is particularly useful when a class + # states/events in the machine. This is particularly useful when a class # has multiple state machines and it would be difficult to differentiate # between the various states / events. # lib/state_machine.rb @@ -84,14 +84,14 @@ module StateMachine # you can build two state machines (one public and one protected) like so: # # class Vehicle < ActiveRecord::Base - # alias_attribute :public_state # Allow both machines to share the same state # attr_protected :state_event # Prevent access to events in the first machine # # state_machine do # # Define private events here # end # - # state_machine :public_state do + # # Public machine targets the same state as the private machine + # state_machine :public_state, :attribute => :state do # # Define public events here # end # end @@ -310,8 +310,10 @@ module StateMachine # Skips defining reader/writer methods since this is done automatically def define_state_accessor + name = self.name + owner_class.validates_each(attribute) do |record, attr, value| - machine = record.class.state_machine(attr) + machine = record.class.state_machine(name) machine.invalidate(record, attr, :invalid) unless machine.states.match(record) end end @@ -321,13 +323,12 @@ module StateMachine # *anything* is set for the attribute's value def define_state_predicate name = self.name - attribute = self.attribute # Still use class_eval here instance of define_instance_method since # we need to be able to call +super+ @instance_helper_module.class_eval do define_method("#{name}?") do |*args| - args.empty? ? super(*args) : self.class.state_machine(attribute).states.matches?(self, *args) + args.empty? ? super(*args) : self.class.state_machine(name).states.matches?(self, *args) end end end @@ -388,17 +389,18 @@ module StateMachine # inheritance is respected properly. def define_scope(name, scope) name = name.to_sym - attribute = self.attribute + machine_name = self.name - # Created the scope and then override it with state translation + # 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(attribute).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 + # Prevent the Machine class from wrapping the scope false end @@ -409,10 +411,10 @@ module StateMachine # * #{type}_#{qualified_event}_from_#{from} # * #{type}_#{qualified_event}_to_#{to} # * #{type}_#{qualified_event} - # * #{type}_transition_#{attribute}_from_#{from}_to_#{to} - # * #{type}_transition_#{attribute}_from_#{from} - # * #{type}_transition_#{attribute}_to_#{to} - # * #{type}_transition_#{attribute} + # * #{type}_transition_#{machine_name}_from_#{from}_to_#{to} + # * #{type}_transition_#{machine_name}_from_#{from} + # * #{type}_transition_#{machine_name}_to_#{to} + # * #{type}_transition_#{machine_name} # * #{type}_transition # # This will always return true regardless of the results of the lib/state_machine/integrations/active_record.rb @@ -2,6 +2,7 @@ :activerecord => { :errors => { :messages => { + :invalid => StateMachine::Machine.default_messages[:invalid], :invalid_event => StateMachine::Machine.default_messages[:invalid_event] % ['{{state}}'], :invalid_transition => StateMachine::Machine.default_messages[:invalid_transition] % ['{{event}}'] } lib/state_machine/integrations/active_record/locale.rb @@ -94,16 +94,13 @@ module StateMachine # include DataMapper::Resource # ... # - # # Allow both machines to share the same state - # alias_method :public_state, :state - # alias_method :public_state=, :state= - # # state_machine do # # Define private events here # end # protected :state_event= # Prevent access to events in the first machine # - # state_machine :public_state do + # # Allow both machines to share the same state + # state_machine :public_state, :attribute => :state do # # Define public events here # end # end @@ -112,7 +109,7 @@ module StateMachine # # By default, the use of transactions during an event transition is # turned off to be consistent with DataMapper. This means that if - # changes are made to the database during a before callback, but the the + # changes are made to the database during a before callback, but the # transition fails to complete, those changes will *not* be rolled back. # # For example, @@ -274,9 +271,9 @@ module StateMachine owner_class.property(attribute, String) unless owner_class.properties.has_property?(attribute) if supports_validations? - attribute = self.attribute + name = self.name owner_class.validates_with_block(attribute) do - machine = self.class.state_machine(attribute) + machine = self.class.state_machine(name) machine.states.match(self) ? true : [false, machine.generate_message(:invalid)] end end lib/state_machine/integrations/data_mapper.rb @@ -109,19 +109,19 @@ module StateMachine # state machines for each observed class. def add_transition_callback(type, *args, &block) if args.any? && !args.first.is_a?(Hash) - # Specific attribute(s) being targeted - attributes = args + # Specific machine(s) being targeted + names = args args = args.last.is_a?(Hash) ? [args.pop] : [] else # Target all state machines - attributes = nil + names = nil end # Add the transition callback to each class being observed observing.each do |klass| state_machines = - if attributes - attributes.map {|attribute| klass.state_machines.fetch(attribute)} + if names + names.map {|name| klass.state_machines.fetch(name)} else klass.state_machines.values end lib/state_machine/integrations/data_mapper/observer.rb @@ -84,17 +84,14 @@ module StateMachine # you can build two state machines (one public and one protected) like so: # # class Vehicle < Sequel::Model - # # Allow both machines to share the same state - # alias_method :public_state, :state - # alias_method :public_state=, :state= - # # set_restricted_columns :state_event # Prevent access to events in the first machine # # state_machine do # # Define private events here # end # - # state_machine :public_state do + # # Allow both machines to share the same state + # state_machine :public_state, :attribute => :state do # # Define public events here # end # end @@ -242,8 +239,9 @@ module StateMachine protected # Skips defining reader/writer methods since this is done automatically def define_state_accessor + name = self.name owner_class.validates_each(attribute) do |record, attr, value| - machine = record.class.state_machine(attr) + machine = record.class.state_machine(name) machine.invalidate(record, attr, :invalid) unless machine.states.match(record) end end lib/state_machine/integrations/sequel.rb @@ -113,14 +113,14 @@ module StateMachine # # Callbacks are supported for hooking before and after every possible # transition in the machine. Each callback is invoked in the order in which - # it was defined. See StateMachine::Machine#before_transition - # and StateMachine::Machine#after_transition for documentation - # on how to define new callbacks. + # it was defined. See StateMachine::Machine#before_transition and + # StateMachine::Machine#after_transition for documentation on how to define + # new callbacks. # - # *Note* that callbacks only get executed within the context of an event. - # As a result, if a class has an initial state when it's created, any - # callbacks that would normally get executed when the object enters that - # state will *not* get triggered. + # *Note* that callbacks only get executed within the context of an event. As + # a result, if a class has an initial state when it's created, any callbacks + # that would normally get executed when the object enters that state will + # *not* get triggered. # # For example, # @@ -229,7 +229,7 @@ module StateMachine # # [Vehicle, Switch, Project].each do |klass| # klass.state_machines.each do |attribute, machine| - # machine.before_transition klass.method(:before_transition) + # machine.before_transition StateMachineObserver.method(:before_transition) # end # end # @@ -300,10 +300,10 @@ module StateMachine # in the new owner class (the original will remain unchanged). def find_or_create(owner_class, *args, &block) options = args.last.is_a?(Hash) ? args.pop : {} - attribute = args.first || :state + name = args.first || :state # Find an existing machine - if owner_class.respond_to?(:state_machines) && machine = owner_class.state_machines[attribute] + if owner_class.respond_to?(:state_machines) && machine = owner_class.state_machines[name] # Only create a new copy if changes are being made to the machine in # a subclass if machine.owner_class != owner_class && (options.any? || block_given?) @@ -316,7 +316,7 @@ module StateMachine machine.instance_eval(&block) if block_given? else # No existing machine: create a new one - machine = new(owner_class, attribute, options, &block) + machine = new(owner_class, name, options, &block) end machine @@ -347,7 +347,7 @@ module StateMachine end # Draw each of the class's state machines - klass.state_machines.each do |name, machine| + klass.state_machines.each_value do |machine| machine.draw(options) end end @@ -365,9 +365,6 @@ module StateMachine # The class that the machine is defined in attr_accessor :owner_class - # The attribute for which the machine is being defined - attr_reader :attribute - # The name of the machine, used for scoping methods generated for the # machine as a whole (not states or events) attr_reader :name @@ -406,7 +403,7 @@ module StateMachine # Creates a new state machine for the given attribute def initialize(owner_class, *args, &block) options = args.last.is_a?(Hash) ? args.pop : {} - assert_valid_keys(options, :as, :initial, :action, :plural, :namespace, :integration, :messages, :use_transactions) + assert_valid_keys(options, :attribute, :initial, :action, :plural, :namespace, :integration, :messages, :use_transactions) # Find an integration that matches this machine's owner class if integration = options[:integration] ? StateMachine::Integrations.find(options[:integration]) : StateMachine::Integrations.match(owner_class) @@ -418,8 +415,8 @@ module StateMachine options = {:use_transactions => true}.merge(options) # Set machine configuration - @attribute = args.first || :state - @name = options[:as] || @attribute + @name = args.first || :state + @attribute = options[:attribute] || @name @events = EventCollection.new(self) @states = StateCollection.new(self) @callbacks = {:before => [], :after => []} @@ -472,10 +469,9 @@ module StateMachine include instance_helper_module end - # Record this machine as matched to the attribute in the current owner - # class. This will override any machines mapped to the same attribute - # in any superclasses. - owner_class.state_machines[attribute] = self + # Record this machine as matched to the name in the current owner class. + # This will override any machines mapped to the same name in any superclasses. + owner_class.state_machines[name] = self end # Sets the initial state of the machine. This can be either the static name @@ -505,11 +501,11 @@ module StateMachine # machine.states.match(object) # end def define_instance_method(method, &block) - attribute = self.attribute + name = self.name @instance_helper_module.class_eval do define_method(method) do |*args| - block.call(self.class.state_machine(attribute), self, *args) + block.call(self.class.state_machine(name), self, *args) end end end @@ -525,11 +521,11 @@ module StateMachine # machine.states.keys # end def define_class_method(method, &block) - attribute = self.attribute + name = self.name @class_helper_module.class_eval do define_method(method) do |*args| - block.call(self.state_machine(attribute), self, *args) + block.call(self.state_machine(name), self, *args) end end end @@ -626,7 +622,7 @@ module StateMachine # end # # class Vehicle < ActiveRecord::Base - # state_machine :state_id, :as => 'state', :initial => :parked do + # state_machine :attribute => :state_id, :initial => :parked do # event :ignite do # transition :parked => :idling # end @@ -852,7 +848,7 @@ module StateMachine ivar ? object.instance_variable_get("@#{attribute}") : object.send(attribute) end - # Sets a new value in the given object's state. + # Sets a new value in the given object's attribute. # # For example, # @@ -862,9 +858,11 @@ module StateMachine # end # end # - # vehicle = Vehicle.new # => #<Vehicle:0xb7d94ab0 @state="parked"> - # Vehicle.state_machine.write(vehicle, 'idling') - # vehicle.state # => "idling" + # vehicle = Vehicle.new # => #<Vehicle:0xb7d94ab0 @state="parked"> + # Vehicle.state_machine.write(vehicle, :state, 'idling') # => Equivalent to vehicle.state = 'idling' + # Vehicle.state_machine.write(vehicle, :event, 'park') # => Equivalent to vehicle.state_event = 'park' + # vehicle.state # => "idling" + # vehicle.event # => "park" def write(object, attribute, value) object.send("#{self.attribute(attribute)}=", value) end @@ -1124,12 +1122,12 @@ module StateMachine # # class Vehicle # # Only specifies one parameter (the object being transitioned) - # before_transition :to => :parked do |vehicle| + # before_transition all => :parked do |vehicle| # vehicle.set_alarm # end # # # Specifies 2 parameters (object being transitioned and actual transition) - # before_transition :to => :parked do |vehicle, transition| + # before_transition all => :parked do |vehicle, transition| # vehicle.set_alarm(transition) # end # end @@ -1155,7 +1153,7 @@ module StateMachine # before_transition [:first_gear, :idling] => :parked, :on => :park, :do => :take_off_seatbelt # # # With conditional callback: - # before_transition :to => :parked, :do => :take_off_seatbelt, :if => :seatbelt_on? + # before_transition all => :parked, :do => :take_off_seatbelt, :if => :seatbelt_on? # # # Using helpers: # before_transition all - :stalled => same, :on => any - :crash, :do => :update_dashboard @@ -1217,7 +1215,7 @@ module StateMachine # # Configuration options: # * <tt>:name</tt> - The name of the file to write to (without the file extension). - # Default is "#{owner_class.name}_#{attribute}" + # Default is "#{owner_class.name}_#{name}" # * <tt>:path</tt> - The path to write the graph file to. Default is the # current directory ("."). # * <tt>:format</tt> - The image format to generate the graph in. @@ -1229,7 +1227,7 @@ module StateMachine # * <tt>:output</tt> - Whether to generate the output of the graph def draw(options = {}) options = { - :name => "#{owner_class.name}_#{attribute}", + :name => "#{owner_class.name}_#{name}", :path => '.', :format => 'png', :font => 'Arial', @@ -1322,8 +1320,6 @@ module StateMachine # Add helpers for interacting with the action if action - name = self.name - # Tracks the event / transition to invoke when the action is called event_attribute = attribute(:event) event_transition_attribute = attribute(:event_transition) @@ -1348,7 +1344,7 @@ module StateMachine action = self.action private_method = owner_class.private_method_defined?(action_hook) - if (owner_class.method_defined?(action_hook) || private_method) && !owner_class.state_machines.any? {|attribute, machine| machine.action == action && machine != self} + if (owner_class.method_defined?(action_hook) || private_method) && !owner_class.state_machines.any? {|name, machine| machine.action == action && machine != self} # Action is defined and hasn't already been overridden by another machine @instance_helper_module.class_eval do # Override the default action to invoke the before / after hooks lib/state_machine/machine.rb @@ -5,7 +5,7 @@ module StateMachine # values are only set if the machine's attribute doesn't already exist # (which must mean the defaults are being skipped) def initialize_states(object) - each do |attribute, machine| + each_value do |machine| value = machine.read(object, :state) machine.write(object, :state, machine.initial_state(object).value) if value.nil? || value.respond_to?(:empty?) && value.empty? end @@ -17,19 +17,19 @@ module StateMachine run_action = [true, false].include?(events.last) ? events.pop : true # Generate the transitions to run for each event - transitions = events.collect do |name| + transitions = events.collect do |event_name| # Find the actual event being run event = nil - detect do |attribute, machine| - event = machine.events[name, :qualified_name] + detect do |name, machine| + event = machine.events[event_name, :qualified_name] end - raise InvalidEvent, "#{name.inspect} is an unknown state machine event" unless event + raise InvalidEvent, "#{event_name.inspect} is an unknown state machine event" unless event # Get the transition that will be performed for the event unless transition = event.transition_for(object) machine = event.machine - machine.invalidate(object, machine.attribute, :invalid_transition, [[:event, name]]) + machine.invalidate(object, :state, :invalid_transition, [[:event, event_name]]) end transition @@ -107,7 +107,7 @@ module StateMachine # vehicle.state_event_transition # => #<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling> def fire_event_attributes(object, action, complete = true) # Get the transitions to fire for each applicable machine - transitions = map {|attribute, machine| machine.action == action ? machine.events.attribute_transition_for(object, true) : nil}.compact + transitions = map {|name, machine| machine.action == action ? machine.events.attribute_transition_for(object, true) : nil}.compact return yield if transitions.empty? # The value generated by the yielded block (the actual action) @@ -122,7 +122,7 @@ module StateMachine action_value = yield end rescue Exception - # Revert attribute modifications + # Revert object modifications transitions.each do |transition| transition.machine.write(object, :event, transition.event) transition.machine.write(object, :event_transition, nil) if complete lib/state_machine/machine_collection.rb @@ -156,11 +156,11 @@ module StateMachine # a new module will be included in the owner class. def context(&block) owner_class = machine.owner_class - attribute = machine.attribute + machine_name = machine.name name = self.name # Evaluate the method definitions - context = ConditionProxy.new(owner_class, lambda {|object| object.class.state_machine(attribute).states.matches?(object, name)}) + context = ConditionProxy.new(owner_class, lambda {|object| object.class.state_machine(machine_name).states.matches?(object, name)}) context.class_eval(&block) context.instance_methods.each do |method| methods[method.to_sym] = context.instance_method(method) @@ -168,7 +168,7 @@ module StateMachine # Calls the method defined by the current state of the machine context.class_eval <<-end_eval, __FILE__, __LINE__ def #{method}(*args, &block) - self.class.state_machine(#{attribute.inspect}).states.match!(self).call(self, #{method.inspect}, *args, &block) + self.class.state_machine(#{machine_name.inspect}).states.match!(self).call(self, #{method.inspect}, *args, &block) end end_eval end lib/state_machine/state.rb @@ -262,14 +262,14 @@ class EventCollectionWithValidationsTest < Test::Unit::TestCase end end -class EventCollectionWithCustomMachineNameTest < Test::Unit::TestCase +class EventCollectionWithCustomMachineAttributeTest < Test::Unit::TestCase def setup @klass = Class.new do def save end end - @machine = StateMachine::Machine.new(@klass, :state_id, :as => 'state', :initial => :parked, :action => :save) + @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id, :initial => :parked, :action => :save) @events = StateMachine::EventCollection.new(@machine) @machine.event :ignite test/unit/event_collection_test.rb @@ -367,6 +367,60 @@ begin end end + class MachineWithOwnerSubclassTest < ActiveRecord::TestCase + def setup + @model = new_model + @machine = StateMachine::Machine.new(@model, :state) + + @subclass = Class.new(@model) + @subclass_machine = @subclass.state_machine(:state) {} + @subclass_machine.state :parked, :idling, :first_gear + end + + def test_should_only_include_records_with_subclass_states_in_with_scope + parked = @subclass.create :state => 'parked' + idling = @subclass.create :state => 'idling' + + assert_equal [parked, idling], @subclass.with_states(:parked, :idling) + end + + def test_should_only_include_records_without_subclass_states_in_without_scope + parked = @subclass.create :state => 'parked' + idling = @subclass.create :state => 'idling' + first_gear = @subclass.create :state => 'first_gear' + + assert_equal [parked, idling], @subclass.without_states(:first_gear) + end + end + + class MachineWithCustomAttributeTest < ActiveRecord::TestCase + def setup + @model = new_model + @machine = StateMachine::Machine.new(@model, :status, :attribute => :state) + @machine.state :parked + + @record = @model.new + end + + def test_should_add_validation_errors_to_custom_attribute + @record.state = 'invalid' + + assert !@record.valid? + assert_equal ['State is invalid'], @record.errors.full_messages + + @record.state = 'parked' + assert @record.valid? + end + + def test_should_check_custom_attribute_for_predicate + @record.state = nil + assert !@record.status?(:parked) + + @record.state = 'parked' + assert @record.status?(:parked) + end + end + class MachineWithCallbacksTest < ActiveRecord::TestCase def setup @model = new_model test/unit/integrations/active_record_test.rb @@ -232,6 +232,32 @@ begin end end + class MachineWithOwnerSubclassTest < BaseTestCase + def setup + @resource = new_resource + @machine = StateMachine::Machine.new(@resource, :state) + + @subclass = Class.new(@resource) + @subclass_machine = @subclass.state_machine(:state) {} + @subclass_machine.state :parked, :idling, :first_gear + end + + def test_should_only_include_records_with_subclass_states_in_with_scope + parked = @subclass.create :state => 'parked' + idling = @subclass.create :state => 'idling' + + assert_equal [parked, idling], @subclass.with_states(:parked, :idling) + end + + def test_should_only_include_records_without_subclass_states_in_without_scope + parked = @subclass.create :state => 'parked' + idling = @subclass.create :state => 'idling' + first_gear = @subclass.create :state => 'first_gear' + + assert_equal [parked, idling], @subclass.without_states(:first_gear) + end + end + class MachineWithCallbacksTest < BaseTestCase def setup @resource = new_resource @@ -572,6 +598,26 @@ begin end end + class MachineWithValidationsAndCustomAttributeTest < BaseTestCase + def setup + @resource = new_resource + @machine = StateMachine::Machine.new(@resource, :status, :attribute => :state) + @machine.state :parked + + @record = @resource.new + end + + def test_should_add_validation_errors_to_custom_attribute + @record.state = 'invalid' + + assert !@record.valid? + assert_equal ['is invalid'], @record.errors.on(:state) + + @record.state = 'parked' + assert @record.valid? + end + end + class MachineWithStateDrivenValidationsTest < BaseTestCase def setup @resource = new_resource do test/unit/integrations/data_mapper_test.rb @@ -252,6 +252,52 @@ begin end end + class MachineWithOwnerSubclassTest < BaseTestCase + def setup + @model = new_model + @machine = StateMachine::Machine.new(@model, :state) + + @subclass = Class.new(@model) + @subclass_machine = @subclass.state_machine(:state) {} + @subclass_machine.state :parked, :idling, :first_gear + end + + def test_should_only_include_records_with_subclass_states_in_with_scope + parked = @subclass.create :state => 'parked' + idling = @subclass.create :state => 'idling' + + assert_equal [parked, idling], @subclass.with_states(:parked, :idling).all + end + + def test_should_only_include_records_without_subclass_states_in_without_scope + parked = @subclass.create :state => 'parked' + idling = @subclass.create :state => 'idling' + first_gear = @subclass.create :state => 'first_gear' + + assert_equal [parked, idling], @subclass.without_states(:first_gear).all + end + end + + class MachineWithCustomAttributeTest < BaseTestCase + def setup + @model = new_model + @machine = StateMachine::Machine.new(@model, :status, :attribute => :state) + @machine.state :parked + + @record = @model.new + end + + def test_should_add_validation_errors_to_custom_attribute + @record.state = 'invalid' + + assert !@record.valid? + assert_equal ['is invalid'], @record.errors.on(:state) + + @record.state = 'parked' + assert @record.valid? + end + end + class MachineWithCallbacksTest < BaseTestCase def setup @model = new_model test/unit/integrations/sequel_test.rb @@ -151,22 +151,22 @@ class MachineByDefaultTest < Test::Unit::TestCase end end -class MachineWithCustomAttributeTest < Test::Unit::TestCase +class MachineWithCustomNameTest < Test::Unit::TestCase def setup @klass = Class.new @machine = StateMachine::Machine.new(@klass, :status) @object = @klass.new end - def test_should_use_custom_attribute_for_name + def test_should_use_custom_name assert_equal :status, @machine.name end - def test_should_use_custom_attribute + def test_should_use_custom_name_for_attribute assert_equal :status, @machine.attribute end - def test_should_prefix_custom_attributes_with_custom_attribute + def test_should_prefix_custom_attributes_with_custom_name assert_equal :status_event, @machine.attribute(:event) end @@ -1486,6 +1486,40 @@ class MachineWithExistingMachinesOnOwnerClassTest < Test::Unit::TestCase end end +class MachineWithExistingMachinesWithSameAttributesOnOwnerClassTest < Test::Unit::TestCase + def setup + @klass = Class.new + @machine = StateMachine::Machine.new(@klass, :initial => :parked) + @second_machine = StateMachine::Machine.new(@klass, :public_state, :attribute => :state) + @object = @klass.new + end + + def test_should_track_each_state_machine + expected = {:state => @machine, :public_state => @second_machine} + assert_equal expected, @klass.state_machines + end + + def test_should_initialize_based_on_first_available_initial_state + assert_equal 'parked', @object.state + end + + def test_should_allow_transitions_on_both_machines + @machine.event :ignite do + transition :parked => :idling + end + + @second_machine.event :park do + transition :idling => :parked + end + + @object.ignite + assert_equal 'idling', @object.state + + @object.park + assert_equal 'parked', @object.state + end +end + class MachineWithNamespaceTest < Test::Unit::TestCase def setup @klass = Class.new @@ -1532,7 +1566,7 @@ class MachineWithNamespaceTest < Test::Unit::TestCase end end -class MachineWithCustomNameTest < Test::Unit::TestCase +class MachineWithCustomAttributeTest < Test::Unit::TestCase def setup StateMachine::Integrations.const_set('Custom', Module.new do class << self; attr_reader :defaults; end @@ -1548,7 +1582,7 @@ class MachineWithCustomNameTest < Test::Unit::TestCase end) @klass = Class.new - @machine = StateMachine::Machine.new(@klass, :state_id, :as => 'state', :initial => :active, :integration => :custom) do + @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id, :initial => :active, :integration => :custom) do event :ignite do transition :parked => :idling end @@ -1556,12 +1590,12 @@ class MachineWithCustomNameTest < Test::Unit::TestCase @object = @klass.new end - def test_should_not_define_a_reader_attribute_for_the_attribute - assert !@object.respond_to?(:state) + def test_should_define_a_reader_attribute_for_the_attribute + assert @object.respond_to?(:state_id) end - def test_should_not_define_a_writer_attribute_for_the_attribute - assert !@object.respond_to?(:state=) + def test_should_define_a_writer_attribute_for_the_attribute + assert @object.respond_to?(:state_id=) end def test_should_define_a_predicate_for_the_attribute @@ -1596,6 +1630,11 @@ class MachineWithCustomNameTest < Test::Unit::TestCase assert @klass.respond_to?(:without_states) end + def test_should_define_state_machines_reader + expected = {:state => @machine} + assert_equal expected, @klass.state_machines + end + def teardown StateMachine::Integrations.send(:remove_const, 'Custom') end test/unit/machine_test.rb @@ -197,10 +197,10 @@ class TransitionWithNamespaceTest < Test::Unit::TestCase end end -class TransitionWithCustomMachineNameTest < Test::Unit::TestCase +class TransitionWithCustomMachineAttributeTest < Test::Unit::TestCase def setup @klass = Class.new - @machine = StateMachine::Machine.new(@klass, :state_id, :as => 'state') + @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id) @machine.state :off, :value => 1 @machine.state :active, :value => 2 @machine.event :activate test/unit/transition_test.rb 77a11b85e35a35ee679bf079d831772f519b14b1 Aaron Pfeifer aaron.pfeifer@gmail.com http://github.com/pluginaweek/state_machine/commit/5f8cd2f9c25044f9df716be3818e3a146f7c0a24 5f8cd2f9c25044f9df716be3818e3a146f7c0a24 2009-06-14T10:31:45-07:00 2009-06-14T10:31:45-07:00 Use :attribute to customize the attribute target and remove :as, assuming the name is the first argument of #state_machine Allow multiple state machines on the same class to target the same attribute 2706667debddea8dd8f6b373e44f2c20134b01e3 Aaron Pfeifer aaron.pfeifer@gmail.com