dm-is-state_machine 0.9.4

data/History.txt

@@ -0,0 +1 @@
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 David James
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,31 @@
+History.txt
+LICENSE
+Manifest.txt
+README.txt
+Rakefile
+TODO
+lib/dm-is-state_machine.rb
+lib/dm-is-state_machine/is/data/event.rb
+lib/dm-is-state_machine/is/data/machine.rb
+lib/dm-is-state_machine/is/data/state.rb
+lib/dm-is-state_machine/is/dsl/event_dsl.rb
+lib/dm-is-state_machine/is/dsl/state_dsl.rb
+lib/dm-is-state_machine/is/state_machine.rb
+lib/dm-is-state_machine/is/version.rb
+spec/examples/invalid_events.rb
+spec/examples/invalid_states.rb
+spec/examples/invalid_transitions_1.rb
+spec/examples/invalid_transitions_2.rb
+spec/examples/traffic_light.rb
+spec/integration/invalid_events_spec.rb
+spec/integration/invalid_states_spec.rb
+spec/integration/invalid_transitions_spec.rb
+spec/integration/traffic_light_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/unit/data/event_spec.rb
+spec/unit/data/machine_spec.rb
+spec/unit/data/state_spec.rb
+spec/unit/dsl/event_dsl_spec.rb
+spec/unit/dsl/state_dsl_spec.rb
+spec/unit/state_machine_spec.rb

data/README.txt

@@ -0,0 +1,12 @@
+= dm-state-machine
+
+DataMapper plugin that adds state machine functionality.
+
+== Installation
+
+Download dm-more and install dm-is-state_machine. Require it in your app.
+
+== Getting started
+
+Please refer to the integration specs in spec/integration, which refer to
+spec/examples.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'spec'
+require 'spec/rake/spectask'
+require 'pathname'
+
+ROOT = Pathname(__FILE__).dirname.expand_path
+require ROOT + 'lib/dm-is-state_machine/is/version'
+
+AUTHOR = "David James"
+EMAIL  = "djwonk [a] collectiveinsight [d] net"
+GEM_NAME = "dm-is-state_machine"
+GEM_VERSION = DataMapper::Is::StateMachine::VERSION
+GEM_DEPENDENCIES = [["dm-core", GEM_VERSION]]
+GEM_CLEAN = ["log", "pkg"]
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO ] }
+
+PROJECT_NAME = "datamapper"
+PROJECT_URL  = "http://github.com/sam/dm-more/tree/master/dm-is-state_machine"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY = "DataMapper plugin for creating state machines"
+
+require ROOT.parent + 'tasks/hoe'
+
+task :default => [ :spec ]
+
+WIN32 = (RUBY_PLATFORM =~ /win32|mingw|cygwin/) rescue nil
+SUDO  = WIN32 ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
+task :install => [ :package ] do
+  sh "#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources", :verbose => false
+end
+
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION} (default ruby)"
+task :uninstall => [ :clobber ] do
+  sh "#{SUDO} gem uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x", :verbose => false
+end
+
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.spec_files = Pathname.glob(Pathname.new(__FILE__).dirname + 'spec/**/*_spec.rb')
+
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+end

data/TODO

@@ -0,0 +1,11 @@
+TODO
+====
+
+* Should skipping to a new state automatically trigger :enter Proc?
+* Add loopback checking (i.e. when transitioning from a state back to itself)
+* Add support for callbacks
+* Consider using DataMapper's Enum type.
+* Consider trying out a nested state machine.
+* Not real happy with spec/unit/dsl:
+  - specs are brittle
+  - specs don't actually test much

data/lib/dm-is-state_machine.rb

@@ -0,0 +1,27 @@
+# Needed to import datamapper and other gems
+require 'rubygems'
+require 'pathname'
+
+# Add all external dependencies for the plugin here
+gem 'dm-core', '=0.9.4'
+require 'dm-core'
+
+# Require plugin-files
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-state_machine' / 'is' / 'state_machine'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-state_machine' / 'is' / 'data' / 'event'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-state_machine' / 'is' / 'data' / 'machine'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-state_machine' / 'is' / 'data' / 'state'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-state_machine' / 'is' / 'dsl' / 'event_dsl'
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-state_machine' / 'is' / 'dsl' / 'state_dsl'
+
+# Include the plugin in Resource
+module DataMapper
+  module Resource
+    module ClassMethods
+      include DataMapper::Is::StateMachine
+    end # module ClassMethods
+  end # module Resource
+end # module DataMapper
+
+# An alternative way to do the same thing as above:
+# DataMapper::Model.append_extensions DataMapper::Is::StateMachine

data/lib/dm-is-state_machine/is/data/event.rb

@@ -0,0 +1,25 @@
+module DataMapper
+  module Is
+    module StateMachine
+      module Data
+
+        class Event
+
+          attr_reader :name, :machine, :transitions
+
+          def initialize(name, machine)
+            @name        = name
+            @machine     = machine
+            @transitions = []
+          end
+
+          def add_transition(from, to)
+            @transitions << { :from => from, :to => to }
+          end
+
+        end
+
+      end # Data
+    end # StateMachine
+  end # Is
+end # DataMapper

data/lib/dm-is-state_machine/is/data/machine.rb

@@ -0,0 +1,69 @@
+module DataMapper
+  module Is
+    module StateMachine
+      module Data
+
+        # Represents one state machine
+        class Machine
+
+          attr_reader :column, :initial
+          attr_accessor :current_state_name
+          attr_accessor :events, :states
+
+          def initialize(column, initial)
+            @column, @initial   = column, initial
+            @events, @states    = [], []
+            @current_state_name = initial
+          end
+
+          # Fire (activate) the event with name +event_name+
+          #
+          # @api public
+          def fire_event(event_name, resource)
+            unless event = find_event(event_name)
+              raise InvalidEvent, "Could not find event (#{event_name.inspect})"
+            end
+            transition = event.transitions.find do |t|
+               t[:from].to_s == @current_state_name.to_s
+            end
+            unless transition
+              raise InvalidEvent, "Event (#{event_name.inspect}) does " +
+              "not exist for current state (#{@current_state_name.inspect})"
+            end
+            @current_state_name = transition[:to]
+
+            # ===== Call :enter Proc if present =====
+            return unless enter_proc = current_state.options[:enter]
+            enter_proc.call(resource)
+          end
+
+          # Return the current state
+          #
+          # @api public
+          def current_state
+            find_state(@current_state_name)
+            # TODO: add caching, i.e. with `@current_state ||= ...`
+          end
+
+          # Find event whose name is +event_name+
+          #
+          # @api semipublic
+          def find_event(event_name)
+            @events.find { |event| event.name.to_s == event_name.to_s }
+            # TODO: use a data structure that prevents duplicates
+          end
+
+          # Find state whose name is +event_name+
+          #
+          # @api semipublic
+          def find_state(state_name)
+            @states.find { |state| state.name.to_s == state_name.to_s }
+            # TODO: use a data structure that prevents duplicates
+          end
+
+        end
+
+      end # Data
+    end # StateMachine
+  end # Is
+end # DataMapper

data/lib/dm-is-state_machine/is/data/state.rb

@@ -0,0 +1,21 @@
+module DataMapper
+  module Is
+    module StateMachine
+      module Data
+
+        class State
+
+          attr_reader :name, :machine, :options
+
+          def initialize(name, machine, options = {})
+            @name    = name
+            @options = options
+            @machine = machine
+          end
+
+        end
+
+      end # Data
+    end # StateMachine
+  end # Is
+end # DataMapper

data/lib/dm-is-state_machine/is/dsl/event_dsl.rb

@@ -0,0 +1,73 @@
+module DataMapper
+  module Is
+    module StateMachine
+      # Event DSL (Domain Specific Language)
+      module EventDsl
+
+        # Define an event. This takes a block which describes all valid
+        # transitions for this event.
+        #
+        # Example:
+        #
+        #   class TrafficLight
+        #     include DataMapper::Resource
+        #     property :id, Serial
+        #     is :state_machine, :initial => :green, :column => :color do
+        #       # state definitions go here...
+        #
+        #       event :forward do
+        #         transition :from => :green,  :to => :yellow
+        #         transition :from => :yellow, :to => :red
+        #         transition :from => :red,    :to => :green
+        #       end
+        #     end
+        #   end
+        #
+        # +transition+ takes a hash where <tt>:to</tt> is the state to transition
+        # to and <tt>:from</tt> is a state (or Array of states) from which this
+        # event can be fired.
+        def event(name, &block)
+          unless state_machine_context?(:is)
+            raise InvalidContext, "Valid only in 'is :state_machine' block"
+          end
+
+          # ===== Setup context =====
+          machine = @is_state_machine[:machine]
+          event = Data::Event.new(name, machine)
+          machine.events << event
+          @is_state_machine[:event] = {
+            :name   => name,
+            :object => event
+          }
+          push_state_machine_context(:event)
+
+          # ===== Define methods =====
+          column = machine.column
+          define_method("#{name}!") do
+            machine.current_state_name = send(:"#{column}")
+            machine.fire_event(name, self)
+            send(:"#{column}=", machine.current_state_name)
+          end
+
+          yield if block_given?
+
+          # ===== Teardown context =====
+          pop_state_machine_context
+        end
+
+        def transition(options)
+          unless state_machine_context?(:event)
+            raise InvalidContext, "Valid only in 'event' block"
+          end
+          event_name   = @is_state_machine[:event][:name]
+          event_object = @is_state_machine[:event][:object]
+
+          from = options[:from]
+          to   = options[:to]
+          event_object.add_transition(from, to)
+        end
+
+      end # EventDsl
+    end # StateMachine
+  end # Is
+end # DataMapper

data/lib/dm-is-state_machine/is/dsl/state_dsl.rb

@@ -0,0 +1,40 @@
+module DataMapper
+  module Is
+    module StateMachine
+      # State DSL (Domain Specific Language)
+      module StateDsl
+
+        # Define a state of the system.
+        #
+        # Example:
+        #
+        #   class TrafficLight
+        #     include DataMapper::Resource
+        #     property :id, Serial
+        #     is :state_machine do
+        #       state :green,  :enter => Proc.new { |o| o.log("G") }
+        #       state :yellow, :enter => Proc.new { |o| o.log("Y") }
+        #       state :red,    :enter => Proc.new { |o| o.log("R") }
+        #
+        #       # event definitions go here...
+        #     end
+        #
+        #     def log(string)
+        #       Merb::Logger.info(string)
+        #     end
+        #   end
+        def state(name, options = {})
+          unless state_machine_context?(:is)
+            raise InvalidContext, "Valid only in 'is :state_machine' block"
+          end
+
+          # ===== Setup context =====
+          machine = @is_state_machine[:machine]
+          state = Data::State.new(name, machine, options)
+          machine.states << state
+        end
+
+      end # StateDsl
+    end # StateMachine
+  end # Is
+end # DataMapper

data/lib/dm-is-state_machine/is/state_machine.rb

@@ -0,0 +1,107 @@
+module DataMapper
+  module Is
+    module StateMachine
+
+      class InvalidContext  < RuntimeError; end
+      class InvalidState    < RuntimeError; end
+      class InvalidEvent    < RuntimeError; end
+      class EventConfusion  < RuntimeError; end
+      class DuplicateStates < RuntimeError; end
+      class NoInitialState  < RuntimeError; end
+
+      ##
+      # Makes a column ('state' by default) act as a state machine. It will
+      # define the property if it does not exist.
+      #
+      # @example [Usage]
+      #   is :state_machine
+      #   is :state_machine, :initial => :internal
+      #   is :state_machine, :column => :availability
+      #   is :state_machine, :column => :availability, :initial => :external
+      #
+      # @param options<Hash> a hash of options
+      #
+      # @option :column<Symbol> the name of the custom column
+      #
+      def is_state_machine(options = {}, &block)
+        extend DataMapper::Is::StateMachine::EventDsl
+        extend DataMapper::Is::StateMachine::StateDsl
+        include DataMapper::Is::StateMachine::InstanceMethods
+
+        # ===== Setup context =====
+        options = { :column => :state, :initial => nil }.merge(options)
+        column  = options[:column]
+        initial = options[:initial].to_s
+        unless properties.detect { |p| p.name == column }
+          property column, String, :default => initial
+        end
+        machine = Data::Machine.new(column, initial)
+        @is_state_machine = { :machine => machine }
+
+        # ===== Define callbacks =====
+        before :save do
+          if self.new_record?
+            # ...
+          else
+            # ...
+          end
+        end
+
+        before :destroy do
+          # Do we need to do anything here?
+        end
+
+        # ===== Setup context =====
+        push_state_machine_context(:is)
+
+        yield if block_given?
+
+        # ===== Teardown context =====
+        pop_state_machine_context
+      end
+
+      protected
+
+      def push_state_machine_context(label)
+        ((@is_state_machine ||= {})[:context] ||= []) << label
+
+        # Less DRY, though more readable to some
+        # @is_state_machine ||= {}
+        # @is_state_machine[:context] ||= []
+        # @is_state_machine[:context] << label
+      end
+
+      def pop_state_machine_context
+        @is_state_machine[:context].pop
+      end
+
+      def state_machine_context?(label)
+        (i = @is_state_machine) && (c = i[:context]) &&
+        c.respond_to?(:include?) && c.include?(label)
+      end
+
+      module InstanceMethods
+
+        def initialize(*args)
+          super
+          # ===== Call :enter Proc if present =====
+          return unless is_sm = self.class.instance_variable_get(:@is_state_machine)
+          return unless machine = is_sm[:machine]
+          return unless initial = machine.initial
+          return unless initial_state = machine.find_state(initial)
+          return unless enter_proc = initial_state.options[:enter]
+          enter_proc.call(self)
+        end
+
+      end # InstanceMethods
+
+    end # StateMachine
+  end # Is
+end # DataMapper
+
+# Notes
+# -----
+#
+# Since this gets mixed into a class, I try to keep the namespace pollution
+# down to a minimum.  This is why I only use the @is_state_machine instance
+# variable.

data/lib/dm-is-state_machine/is/version.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module Is
+    module StateMachine
+      VERSION = "0.9.4"
+    end
+  end
+end

data/spec/examples/invalid_events.rb

@@ -0,0 +1,20 @@
+# An invalid example.
+class InvalidEvents
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  is :state_machine do
+    state :day
+    state :night
+  end
+
+  # The next lines are intentionally incorrect.
+  #
+  # 'event' only makes sense in a block under 'is :state_machine'
+  event :sunrise
+  event :sunset
+
+end
+
+InvalidEvents.auto_migrate!

data/spec/examples/invalid_states.rb

@@ -0,0 +1,20 @@
+# An invalid example.
+class InvalidStates
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  is :state_machine do
+    event :sunrise
+    event :sunset
+  end
+
+  # The next lines are intentionally incorrect.
+  #
+  # 'state' only makes sense in a block under 'is :state_machine'
+  state :light
+  state :dark
+
+end
+
+InvalidStates.auto_migrate!

data/spec/examples/invalid_transitions_1.rb

@@ -0,0 +1,22 @@
+# An invalid example.
+class InvalidTransitions1
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  is :state_machine do
+    state :happy
+    state :sad
+
+    event :toggle
+
+    # The next lines are intentionally incorrect.
+    #
+    # 'transition' is only valid when nested beneath 'event'
+    transition :to => :happy, :from => :sad
+    transition :to => :sad,   :from => :happy
+  end
+
+end
+
+InvalidTransitions1.auto_migrate!

data/spec/examples/invalid_transitions_2.rb

@@ -0,0 +1,22 @@
+# An invalid example.
+class InvalidTransitions2
+  include DataMapper::Resource
+
+  property :id, Serial
+
+  is :state_machine do
+    state :happy
+    state :sad
+
+    event :toggle
+  end
+
+  # The next lines are intentionally incorrect.
+  #
+  # 'transition' is only valid when nested beneath 'event'
+  transition :to => :happy, :from => :sad
+  transition :to => :sad,   :from => :happy
+
+end
+
+InvalidTransitions2.auto_migrate!

data/spec/examples/traffic_light.rb

@@ -0,0 +1,44 @@
+# A valid example of a resource with a state machine.
+class TrafficLight
+  include DataMapper::Resource
+
+  property :id, Serial # see note 1
+
+  is :state_machine, :initial => :green, :column => :color do
+    state :green,  :enter => Proc.new { |o| o.log << "G" }
+    state :yellow, :enter => Proc.new { |o| o.log << "Y" }
+    state :red,    :enter => Proc.new { |o| o.log << "R" }
+
+    event :forward do
+      transition :from => :green,  :to => :yellow
+      transition :from => :yellow, :to => :red
+      transition :from => :red,    :to => :green
+    end
+
+    event :backward do
+      transition :from => :green,  :to => :red
+      transition :from => :yellow, :to => :green
+      transition :from => :red,    :to => :yellow
+    end
+  end
+
+  def log; @log ||= [] end
+
+  attr_reader :init
+  def initialize(*args)
+    (@init ||= []) << :init
+    super
+  end
+
+end
+
+TrafficLight.auto_migrate!
+
+# ===== Note 1 =====
+#
+# One would expect that these two would be the same:
+#   property :id, Serial
+#   property :id, Integer, :serial => true
+#
+# But on 2008-07-05, the 2nd led to problems with an in-memory SQLite
+# database.

data/spec/integration/invalid_events_spec.rb

@@ -0,0 +1,12 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe "InvalidEvents" do
+
+  it "should get InvalidContext when requiring" do
+    lambda {
+      require File.join( File.dirname(__FILE__), "..", "examples", "invalid_events" )
+    }.should raise_error(DataMapper::Is::StateMachine::InvalidContext)
+  end
+
+end

data/spec/integration/invalid_states_spec.rb

@@ -0,0 +1,12 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe "InvalidStates" do
+
+  it "should get InvalidContext when requiring" do
+    lambda {
+      require File.join( File.dirname(__FILE__), "..", "examples", "invalid_states" )
+    }.should raise_error(DataMapper::Is::StateMachine::InvalidContext)
+  end
+
+end

data/spec/integration/invalid_transitions_spec.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe "InvalidTransitions1" do
+
+  it "should get InvalidContext when requiring" do
+    lambda {
+      require File.join( File.dirname(__FILE__), "..", "examples", "invalid_transitions_1" )
+    }.should raise_error(DataMapper::Is::StateMachine::InvalidContext)
+  end
+
+end
+
+describe "InvalidTransitions2" do
+
+  it "should get InvalidContext when requiring" do
+    lambda {
+      require File.join( File.dirname(__FILE__), "..", "examples", "invalid_transitions_2" )
+    }.should raise_error(DataMapper::Is::StateMachine::InvalidContext)
+  end
+
+end

data/spec/integration/traffic_light_spec.rb

@@ -0,0 +1,150 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+require Pathname(__FILE__).dirname.expand_path.parent + 'examples/traffic_light'
+
+describe TrafficLight do
+
+  before(:each) do
+    @t = TrafficLight.new
+  end
+
+  it "should have an 'id' column" do
+    @t.attributes.should include(:id)
+  end
+
+  it "should have a 'color' column" do
+    @t.attributes.should include(:color)
+  end
+
+  it "should not have a 'state' column" do
+    @t.attributes.should_not include(:state)
+  end
+
+  it "should start off in the green state" do
+    @t.color.should == "green"
+  end
+
+  it "should allow the color to be set" do
+    @t.color = :yellow
+    @t.save
+    @t.color.should == "yellow"
+  end
+
+  it "should have called the :enter Proc" do
+    @t.log.should == %w(G)
+  end
+
+  it "should call the original initialize method" do
+    @t.init.should == [:init]
+  end
+
+  describe 'forward!' do
+
+    it "should respond to :forward!" do
+      @t.respond_to?(:forward!).should == true
+    end
+
+    it "should transition to :yellow, :red, :green" do
+      @t.color.should == "green"
+      @t.forward!
+      @t.color.should == "yellow"
+      @t.log.should == %w(G Y)
+      @t.forward!
+      @t.color.should == "red"
+      @t.log.should == %w(G Y R)
+      @t.forward!
+      @t.color.should == "green"
+      @t.log.should == %w(G Y R G)
+      @t.new_record?.should == true
+    end
+
+    it "should skip to :yellow then transition to :red, :green, :yellow" do
+      @t.color = :yellow
+      @t.color.should == "yellow"
+      @t.log.should == %w(G)
+      @t.forward!
+      @t.color.should == "red"
+      @t.log.should == %w(G R)
+      @t.forward!
+      @t.color.should == "green"
+      @t.log.should == %w(G R G)
+      @t.forward!
+      @t.color.should == "yellow"
+      @t.log.should == %w(G R G Y)
+      @t.new_record?.should == true
+    end
+
+    it "should skip to :red then transition to :green, :yellow, :red" do
+      @t.color = :red
+      @t.color.should == "red"
+      @t.log.should == %w(G)
+      @t.forward!
+      @t.color.should == "green"
+      @t.log.should == %w(G G)
+      @t.forward!
+      @t.color.should == "yellow"
+      @t.log.should == %w(G G Y)
+      @t.forward!
+      @t.color.should == "red"
+      @t.log.should == %w(G G Y R)
+      @t.new_record?.should == true
+    end
+
+  end
+
+  describe 'backward!' do
+
+    it "should respond to 'backward!'" do
+      @t.respond_to?(:backward!).should == true
+    end
+
+    it "should transition to :red, :yellow, :green" do
+      @t.color.should == "green"
+      @t.log.should == %w(G)
+      @t.backward!
+      @t.color.should == "red"
+      @t.log.should == %w(G R)
+      @t.backward!
+      @t.color.should == "yellow"
+      @t.log.should == %w(G R Y)
+      @t.backward!
+      @t.color.should == "green"
+      @t.log.should == %w(G R Y G)
+      @t.new_record?.should == true
+    end
+
+    it "should skip to :yellow then transition to :green, :red, :yellow" do
+      @t.color = :yellow
+      @t.color.should == "yellow"
+      @t.log.should == %w(G)
+      @t.backward!
+      @t.color.should == "green"
+      @t.log.should == %w(G G)
+      @t.backward!
+      @t.color.should == "red"
+      @t.log.should == %w(G G R)
+      @t.backward!
+      @t.color.should == "yellow"
+      @t.log.should == %w(G G R Y)
+      @t.new_record?.should == true
+    end
+
+    it "should skip to :red then transition to :yellow, :green, :red" do
+      @t.color = :red
+      @t.color.should == "red"
+      @t.log.should == %w(G)
+      @t.backward!
+      @t.color.should == "yellow"
+      @t.log.should == %w(G Y)
+      @t.backward!
+      @t.color.should == "green"
+      @t.log.should == %w(G Y G)
+      @t.backward!
+      @t.color.should == "red"
+      @t.log.should == %w(G Y G R)
+      @t.new_record?.should == true
+    end
+
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format specdoc
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+gem 'rspec', '>=1.1.3'
+require 'spec'
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'lib/dm-is-state_machine'
+
+def load_driver(name, default_uri)
+  return false if ENV['ADAPTER'] != name.to_s
+
+  lib = "do_#{name}"
+
+  begin
+    gem lib, '=0.9.4'
+    require lib
+    DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+    DataMapper::Repository.adapters[:default] = DataMapper::Repository.adapters[name]
+    true
+  rescue Gem::LoadError => e
+    warn "Could not load #{lib}: #{e}"
+    false
+  end
+end
+
+ENV['ADAPTER'] ||= 'sqlite3'
+
+HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
+HAS_MYSQL    = load_driver(:mysql,    'mysql://localhost/dm_core_test')
+HAS_POSTGRES = load_driver(:postgres, 'postgres://postgres@localhost/dm_core_test')

data/spec/unit/data/event_spec.rb

@@ -0,0 +1,28 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent.parent + 'spec_helper'
+
+module EventHelper
+  def new_event(*args)
+    DataMapper::Is::StateMachine::Data::Event.new(*args)
+  end
+end
+
+describe DataMapper::Is::StateMachine::Data::Event do
+  include EventHelper
+
+  before(:each) do
+    @machine = mock("machine")
+    @event = new_event(:ping, @machine)
+  end
+
+  it "#initialize should work" do
+    @event.name.should        == :ping
+    @event.machine.should     == @machine
+    @event.transitions.should == []
+  end
+
+  it "#add_transition should work" do
+    @event.add_transition(:nothing, :pinged)
+    @event.transitions.should == [{:from => :nothing, :to => :pinged }]
+  end
+end

data/spec/unit/data/machine_spec.rb

@@ -0,0 +1,97 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent.parent + 'spec_helper'
+
+module MachineHelper
+  def new_machine(*args)
+    DataMapper::Is::StateMachine::Data::Machine.new(*args)
+  end
+
+  def new_state(name, machine, options = {})
+    mock(name, :name => name, :machine => machine, :options => options)
+  end
+
+  def new_event(name, machine)
+    mock(name, :name => name, :machine => machine)
+  end
+end
+
+describe DataMapper::Is::StateMachine::Data::Machine do
+  include MachineHelper
+
+  describe "new Machine, no events" do
+    before(:each) do
+      @machine = new_machine(:power, :off)
+    end
+
+    it "#column should work" do
+      @machine.column.should == :power
+    end
+
+    it "#initial should work" do
+      @machine.initial.should == :off
+    end
+
+    it "#events should work" do
+      @machine.events.should == []
+    end
+
+    it "#states should work" do
+      @machine.states.should == []
+    end
+
+    it "#find_event should return nothing" do
+      @machine.find_event(:turn_on).should == nil
+    end
+
+    it "#fire_event should raise error" do
+      lambda {
+        @machine.fire_event(:turn_on, nil)
+      }.should raise_error(DataMapper::Is::StateMachine::InvalidEvent)
+    end
+  end
+
+  describe "new Machine, 2 states, 1 event" do
+    before(:each) do
+      @machine = new_machine(:power, :off)
+      @machine.states << (@off_state = new_state(:off, @machine))
+      @machine.states << (@on_state = new_state(:on, @machine))
+      @machine.events << (@turn_on = new_event(:turn_on, @machine))
+      @turn_on.stub!(:transitions).and_return([{ :from => :off, :to => :on }])
+    end
+
+    it "#column should work" do
+      @machine.column.should == :power
+    end
+
+    it "#initial should work" do
+      @machine.initial.should == :off
+    end
+
+    it "#events should work" do
+      @machine.events.should == [@turn_on]
+    end
+
+    it "#states should work" do
+      @machine.states.should == [@off_state, @on_state]
+    end
+
+    it "#current_state should work" do
+      @machine.current_state.should == @off_state
+    end
+
+    it "#current_state_name should work" do
+      @machine.current_state_name.should == :off
+    end
+
+    it "#find_event should return nothing" do
+      @machine.find_event(:turn_on).should == @turn_on
+    end
+
+    it "#fire_event should work" do
+      @machine.fire_event(:turn_on, nil)
+      @machine.current_state.should == @on_state
+      @machine.current_state_name.should == :on
+    end
+  end
+
+end

data/spec/unit/data/state_spec.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent.parent + 'spec_helper'
+
+module StateHelper
+  def new_state(*args)
+    DataMapper::Is::StateMachine::Data::State.new(*args)
+  end
+end
+
+describe DataMapper::Is::StateMachine::Data::State do
+  include StateHelper
+
+  before(:each) do
+    @machine = mock("machine")
+    @state = new_state(:off, @machine)
+  end
+
+  it "#initialize should work" do
+    @state.name.should    == :off
+    @state.machine.should == @machine
+  end
+end

data/spec/unit/dsl/event_dsl_spec.rb

@@ -0,0 +1,56 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent.parent + 'spec_helper'
+
+describe "EventDsl" do
+
+  describe "event" do
+
+    before(:each) do
+      class Earth
+        extend DataMapper::Is::StateMachine::EventDsl
+        stub!(:state_machine_context?).and_return(true)
+        stub!(:push_state_machine_context)
+        stub!(:pop_state_machine_context)
+      end
+      machine = mock("machine", :events => [], :column => :state)
+      Earth.instance_variable_set(:@is_state_machine, { :machine => machine })
+    end
+
+    it "declaration should succeed" do
+      class Earth
+        event :sunrise
+      end
+    end
+
+  end
+
+  describe "transition" do
+
+    before(:each) do
+
+      class Earth
+        extend DataMapper::Is::StateMachine::EventDsl
+
+        stub!(:state_machine_context?).and_return(true)
+        stub!(:push_state_machine_context)
+        stub!(:pop_state_machine_context)
+      end
+
+      machine = mock("machine", :events => [], :column => :state)
+      event = mock("sunrise_event")
+      event.stub!(:add_transition)
+      Earth.instance_variable_set(:@is_state_machine, {
+        :machine => machine,
+        :event   => { :name => :sunrise, :object => event }
+      })
+    end
+
+    it "transition definition should succeed" do
+      class Earth
+        transition :from => :night, :to => :day
+      end
+    end
+
+  end
+
+end

data/spec/unit/dsl/state_dsl_spec.rb

@@ -0,0 +1,25 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent.parent + 'spec_helper'
+
+describe "StateDsl" do
+
+  describe "state" do
+
+    before(:each) do
+      class Earth
+        extend DataMapper::Is::StateMachine::StateDsl
+        stub!(:state_machine_context?).and_return(true)
+      end
+      machine = mock("machine", :states => [])
+      Earth.instance_variable_set(:@is_state_machine, { :machine => machine })
+    end
+
+    it "declaration should succeed" do
+      class Earth
+        state :day
+      end
+    end
+
+  end
+
+end

data/spec/unit/state_machine_spec.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe "StateMachine" do
+
+  describe "is_state_machine" do
+
+    before(:each) do
+      class Earth
+        extend DataMapper::Is::StateMachine
+
+        stub!(:properties).and_return([])
+        stub!(:property)
+        stub!(:before)
+
+        stub!(:state_machine_context?).and_return(true)
+        stub!(:push_state_machine_context)
+        stub!(:pop_state_machine_context)
+      end
+    end
+
+    it "declaration should succeed" do
+      class Earth
+        is_state_machine
+      end
+    end
+
+  end
+end
+
+# is_state_machine
+# push_state_machine_context(label)
+# pop_state_machine_context
+# state_machine_context?(label)

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: dm-is-state_machine
+version: !ruby/object:Gem::Version 
+  version: 0.9.4
+platform: ruby
+authors: 
+- David James
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-21 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: DataMapper plugin for creating state machines
+email: 
+- djwonk [a] collectiveinsight [d] net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+- LICENSE
+- TODO
+files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO
+- lib/dm-is-state_machine.rb
+- lib/dm-is-state_machine/is/data/event.rb
+- lib/dm-is-state_machine/is/data/machine.rb
+- lib/dm-is-state_machine/is/data/state.rb
+- lib/dm-is-state_machine/is/dsl/event_dsl.rb
+- lib/dm-is-state_machine/is/dsl/state_dsl.rb
+- lib/dm-is-state_machine/is/state_machine.rb
+- lib/dm-is-state_machine/is/version.rb
+- spec/examples/invalid_events.rb
+- spec/examples/invalid_states.rb
+- spec/examples/invalid_transitions_1.rb
+- spec/examples/invalid_transitions_2.rb
+- spec/examples/traffic_light.rb
+- spec/integration/invalid_events_spec.rb
+- spec/integration/invalid_states_spec.rb
+- spec/integration/invalid_transitions_spec.rb
+- spec/integration/traffic_light_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/data/event_spec.rb
+- spec/unit/data/machine_spec.rb
+- spec/unit/data/state_spec.rb
+- spec/unit/dsl/event_dsl_spec.rb
+- spec/unit/dsl/state_dsl_spec.rb
+- spec/unit/state_machine_spec.rb
+has_rdoc: true
+homepage: http://github.com/sam/dm-more/tree/master/dm-is-state_machine
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: datamapper
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: DataMapper plugin for creating state machines
+test_files: []
+