simple_state_machine 0.5.2 → 0.6.1

data/lib/simple_state_machine/tools/graphviz.rb

@@ -0,0 +1,21 @@
+module SimpleStateMachine
+  module Tools
+    require 'cgi'
+    module Graphviz
+      # Graphviz dot format for rendering as a directional graph
+      def to_graphviz_dot
+        "digraph G {\n" +
+          transitions.map { |t| t.to_graphviz_dot }.sort.join(";\n") +
+          "\n}"
+      end
+
+      # Generates a url that renders states and events as a directional graph.
+      # See http://code.google.com/apis/chart/docs/gallery/graphviz.html
+      def google_chart_url
+        graph = transitions.map { |t| t.to_graphviz_dot }.sort.join(";")
+        puts graph
+        "http://chart.googleapis.com/chart?cht=gv&chl=digraph{#{::CGI.escape graph}}"
+      end
+    end
+  end
+end

data/lib/simple_state_machine/tools/inspector.rb

@@ -0,0 +1,44 @@
+module SimpleStateMachine
+  module Tools
+    module Inspector
+      def begin_states
+        from_states - to_states
+      end
+
+      def end_states
+        to_states - from_states
+      end
+
+      def states
+        (to_states + from_states).uniq
+      end
+
+      private
+
+        def from_states
+          to_uniq_sym(sample_transitions.map(&:from))
+        end
+
+        def to_states
+          to_uniq_sym(sample_transitions.map(&:to))
+        end
+
+        def to_uniq_sym(array)
+          array.map { |state| state.is_a?(String) ? state.to_sym : state }.uniq
+        end
+
+        def sample_transitions
+          (@subject || sample_subject).state_machine_definition.send :transitions
+        end
+
+        def sample_subject
+          self_class = self.class
+          sample = Class.new do
+            extend SimpleStateMachine::Mountable
+            mount_state_machine self_class
+          end
+          sample
+        end
+    end
+  end
+end

data/lib/simple_state_machine/transition.rb

@@ -0,0 +1,40 @@
+module SimpleStateMachine
+  # Defines transitions for events
+  class Transition
+    attr_reader :event_name, :from, :to
+    def initialize(event_name, from, to)
+      @event_name = event_name.to_s
+      @from       = from.is_a?(Class) ? from : from.to_s
+      @to         = to.to_s
+    end
+
+    # returns true if it's a transition for event_name and subject_state
+    def is_transition_for?(event_name, subject_state)
+      is_same_event?(event_name) && is_same_from?(subject_state)
+    end
+
+    # returns true if it's a error transition for event_name and error
+    def is_error_transition_for?(event_name, error)
+      is_same_event?(event_name) && from.is_a?(Class) && error.is_a?(from)
+    end
+
+    def to_s
+      "#{from}.#{event_name}! => #{to}"
+    end
+
+    # TODO move to Graphiz module
+    def to_graphviz_dot
+      %("#{from}"->"#{to}"[label=#{event_name}])
+    end
+
+    private
+
+      def is_same_event?(event_name)
+        self.event_name == event_name.to_s
+      end
+
+      def is_same_from?(subject_from)
+        from.to_s == 'all' || subject_from.to_s == from.to_s
+      end
+  end
+end

data/lib/simple_state_machine/version.rb

@@ -1,3 +1,3 @@
 module SimpleStateMachine
-  VERSION = "0.5.2"
+  VERSION = "0.6.1"
 end

data/lib/simple_state_machine.rb

@@ -1,4 +1,14 @@
 require 'simple_state_machine/simple_state_machine'
-require 'simple_state_machine/active_record'
-require "simple_state_machine/railtie" if defined?(Rails::Railtie)
-
+require 'simple_state_machine/state_machine'
+require 'simple_state_machine/tools/graphviz'
+require 'simple_state_machine/tools/inspector'
+require 'simple_state_machine/state_machine_definition'
+require 'simple_state_machine/transition'
+require 'simple_state_machine/decorator/default'
+if defined?(ActiveRecord)
+  require 'simple_state_machine/active_record'
+  require 'simple_state_machine/decorator/active_record'
+end
+if defined?(Rails::Railtie)
+  require "simple_state_machine/railtie"
+end

data/lib/tasks/graphviz.rake

@@ -0,0 +1,31 @@
+namespace :ssm do
+  namespace :graph do
+
+    desc 'Outputs a dot file. You must specify class=ClassNAME'
+    task :dot => :environment do
+      if clazz = ENV['class']
+        puts clazz.constantize.state_machine_definition.to_graphviz_dot
+      else
+        puts "Missing argument: class. Please specify class=ClassName"
+      end
+    end
+
+    desc 'Generate a url for a google chart. You must specify class=ClassName'
+    task :url => :environment do
+      if clazz = ENV['class']
+        puts clazz.constantize.state_machine_definition.google_chart_url
+      else
+        puts "Missing argument: class. Please specify class=ClassName"
+      end
+    end
+
+    desc 'Opens the google chart in your browser. You must specify class=ClassNAME'
+    task :open => :environment do
+      if clazz = ENV['class']
+        `open '#{::CGI.unescape(clazz.constantize.state_machine_definition.google_chart_url)}'`
+      else
+        puts "Missing argument: class. Please specify class=ClassName"
+      end
+    end
+  end
+end

data/simple_state_machine.gemspec

@@ -3,29 +3,19 @@ $:.push File.expand_path("../lib", __FILE__)
 require "simple_state_machine/version"   
 
 Gem::Specification.new do |s|
-  s.name = %q{simple_state_machine}
-  s.version     = SimpleStateMachine::VERSION
-  s.platform    = Gem::Platform::RUBY
-
-  s.authors = ["Marek de Heus", "Petrik de Heus"]
-  s.description = %q{Simple State Machine is a state machine that focuses on events instead of states}
-  s.email = ["FIX@example.com"]
-  s.homepage = %q{http://github.com/mdh/ssm}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files         = `git ls-files`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{A simple DSL to decorate existing methods with logic that guards state transitions.}
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.add_development_dependency "rake"
-  s.add_development_dependency "ZenTest"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "activerecord", "~>2.3.5"
-  s.add_development_dependency "sqlite3-ruby"
+  s.name             = %q{simple_state_machine}
+  s.version          = SimpleStateMachine::VERSION
+  s.platform         = Gem::Platform::RUBY
+  s.authors          = ["Marek de Heus", "Petrik de Heus"]
+  s.description      = %q{A simple DSL to decorate existing methods with state transition guards.}
+  s.email            = ["FIX@example.com"]
+  s.homepage         = %q{http://github.com/mdh/ssm}
+  s.extra_rdoc_files = ["LICENSE","README.rdoc"]
+  s.files            = `git ls-files`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_paths    = ["lib"]
+  s.summary          = %q{A simple DSL to decorate existing methods with logic that guards state transitions.}
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
 end
 

data/spec/active_record_spec.rb

@@ -1,213 +1,250 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-require "rubygems"
-require "bundler"
-Bundler.require
-#Bundler.setup(:test)#, :activerecord)
-require 'active_record'
-require 'examples/user'
-
-ActiveRecord::Base.logger = Logger.new "test.log"
-ActiveRecord::Base.establish_connection(:adapter  => "sqlite3",
-                                        :database => ":memory:")
-
-def setup_db
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :users do |t|
-      t.column :id,               :integer
-      t.column :name,             :string
-      t.column :state,            :string
-      t.column :activation_code,  :string
-      t.column :created_at,       :datetime
-      t.column :updated_at,       :datetime
+require 'spec_helper'
+require 'logger'
+
+if defined? ActiveRecord
+  ActiveRecord::Base.logger = Logger.new "test.log"
+  ActiveRecord::Base.establish_connection('adapter' => RUBY_PLATFORM == 'java' ? 'jdbcsqlite3' : 'sqlite3', 'database' => ':memory:')
+
+  def setup_db
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :users do |t|
+        t.column :name,             :string
+        t.column :state,            :string
+        t.column :activation_code,  :string
+        t.column :created_at,       :datetime
+        t.column :updated_at,       :datetime
+      end
+      create_table :tickets do |t|
+        t.column :ssm_state,  :string
+      end
     end
-    create_table :tickets do |t|
-      t.column :id,         :integer
-      t.column :ssm_state,  :string
-    end
-  end
-end
-
-def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
-  end
-end
-
-class Ticket < ActiveRecord::Base
-  extend SimpleStateMachine::ActiveRecord
-
-  state_machine_definition.state_method = :ssm_state
-
-  def after_initialize
-    self.ssm_state ||= 'open'
-  end
-
-  event :close, :open => :closed
-end
-
-describe ActiveRecord do
-
-  before do
-    setup_db
-  end
-
-  after do
-    teardown_db
   end
 
-  it "has a default state" do
-    User.new.should be_new
-  end
-
-  # TODO needs nesting/grouping, seems to have some duplication
-
-  describe "event_and_save" do
-    it "persists transitions" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save.should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
-    end
-
-    it "persist transitions even when state is attr_protected" do
-      user_class = Class.new(User)
-      user_class.instance_eval { attr_protected :state }
-      user = user_class.create!(:name => 'name', :state => 'x')
-      user.should be_new
-      user.invite_and_save
-      user.reload.should be_invited
-    end
-
-    it "persists transitions when using send and a symbol" do
-      user = User.create!(:name => 'name')
-      user.send(:invite_and_save).should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
+  def teardown_db
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
     end
+  end
 
-    it "raises an error if an invalid state_transition is called" do
-      user = User.create!(:name => 'name')
-      expect {
-        user.confirm_invitation_and_save 'abc'
-      }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
-                       "You cannot 'confirm_invitation' when state is 'new'")
-    end
+  class Ticket < ActiveRecord::Base
+    extend SimpleStateMachine::ActiveRecord
 
-    it "returns false and keeps state if record is invalid" do
-      user = User.new
-      user.should be_new
-      user.should_not be_valid
-      user.invite_and_save.should == false
-      user.should be_new
-    end
+    state_machine_definition.state_method = :ssm_state
 
-    it "returns false, keeps state and keeps errors if event adds errors" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save!
-      user.should be_invited
-      user.confirm_invitation_and_save('x').should == false
-      user.should be_invited
-      user.errors.entries.should == [['activation_code', 'is invalid']]
+    after_initialize :after_initialize
+    def after_initialize
+      self.ssm_state ||= 'open'
     end
 
+    event :close, :open => :closed
   end
 
-  describe "event_and_save!" do
+  describe ActiveRecord do
 
-    it "persists transitions" do
-      user = User.create!(:name => 'name')
-      user.invite_and_save!.should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
+    before do
+      setup_db
     end
 
-    it "persist transitions even when state is attr_protected" do
-      user_class = Class.new(User)
-      user_class.instance_eval { attr_protected :state }
-      user = user_class.create!(:name => 'name', :state => 'x')
-      user.should be_new
-      user.invite_and_save!
-      user.reload.should be_invited
+    after do
+      teardown_db
     end
 
-    it "raises an error if an invalid state_transition is called" do
-      user = User.create!(:name => 'name')
-      expect {
-        user.confirm_invitation_and_save! 'abc'
-      }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
-                       "You cannot 'confirm_invitation' when state is 'new'")
+    it "has a default state" do
+      expect(User.new).to be_new
     end
 
-    it "raises a RecordInvalid and keeps state if record is invalid" do
-      user = User.new
-      user.should be_new
-      user.should_not be_valid
-      expect {
-        user.invite_and_save!
-      }.to raise_error(ActiveRecord::RecordInvalid,
-                       "Validation failed: Name can't be blank")
-      user.should be_new
-    end
-
-    it "raises a RecordInvalid and keeps state if event adds errors" do
+    it "persists transitions when using send and a symbol" do
       user = User.create!(:name => 'name')
-      user.invite_and_save!
-      user.should be_invited
-      expect {
-        user.confirm_invitation_and_save!('x')
-      }.to raise_error(ActiveRecord::RecordInvalid,
-                       "Validation failed: Activation code is invalid")
-      user.should be_invited
-    end
-
-  end
-
-  describe "event" do
+      expect(user.send(:invite_and_save)).to eq(true)
+      expect(User.find(user.id)).to be_invited
+      expect(User.find(user.id).activation_code).not_to be_nil
+    end
+
+    # TODO needs nesting/grouping, seems to have some duplication
+
+    describe "event_and_save" do
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite_and_save).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
+
+      it "persists transitions when using send and a symbol" do
+        user = User.create!(:name => 'name')
+        expect(user.send(:invite_and_save)).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
+
+      it "raises an error if an invalid state_transition is called" do
+        user = User.create!(:name => 'name')
+        expect {
+          user.confirm_invitation_and_save 'abc'
+        }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
+                         "You cannot 'confirm_invitation' when state is 'new'")
+      end
+
+      it "returns false and keeps state if record is invalid" do
+        user = User.new
+        expect(user).to be_new
+        expect(user).not_to be_valid
+        expect(user.invite_and_save).to eq(false)
+        expect(user).to be_new
+      end
+
+      it "returns false, keeps state and keeps errors if event adds errors" do
+        user = User.create!(:name => 'name')
+        user.invite_and_save!
+        expect(user).to be_invited
+        expect(user.confirm_invitation_and_save('x')).to eq(false)
+        expect(user).to be_invited
+        expect(Array(user.errors[:activation_code])).to eq(['is invalid'])
+      end
+
+      it "rollsback if an exception is raised" do
+        user_class = Class.new(User)
+        user_class.instance_eval do
+          define_method :invite_without_managed_state do
+            User.create!(:name => 'name2') #this shouldn't be persisted
+            User.create! #this should raise an error
+          end
+        end
+        expect(user_class.count).to eq(0)
+        user = user_class.create!(:name => 'name')
+        expect {
+          user.transaction { user.invite_and_save }
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Name can't be blank")
+        expect(user_class.count).to eq(1)
+        expect(user_class.first.name).to eq('name')
+        expect(user_class.first).to be_new
+      end
+
+      it "raises an error if an invalid state_transition is called" do
+        user = User.create!(:name => 'name')
+        expect {
+          user.confirm_invitation_and_save! 'abc'
+        }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
+                         "You cannot 'confirm_invitation' when state is 'new'")
+      end
+    end
+
+    describe "event_and_save!" do
+
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite_and_save!).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
+
+      it "raises an error if an invalid state_transition is called" do
+        user = User.create!(:name => 'name')
+        expect {
+          user.confirm_invitation_and_save! 'abc'
+        }.to raise_error(SimpleStateMachine::IllegalStateTransitionError,
+                         "You cannot 'confirm_invitation' when state is 'new'")
+      end
+
+      it "raises a RecordInvalid and keeps state if record is invalid" do
+        user = User.new
+        expect(user).to be_new
+        expect(user).not_to be_valid
+        expect {
+          user.invite_and_save!
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Name can't be blank")
+        expect(user).to be_new
+      end
+
+      it "raises a RecordInvalid and keeps state if event adds errors" do
+        user = User.create!(:name => 'name')
+        user.invite_and_save!
+        expect(user).to be_invited
+        expect {
+          user.confirm_invitation_and_save!('x')
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Activation code is invalid")
+        expect(user).to be_invited
+      end
+
+      it "rollsback if an exception is raised" do
+        user_class = Class.new(User)
+        user_class.instance_eval do
+          define_method :invite_without_managed_state do
+            User.create!(:name => 'name2') #this shouldn't be persisted
+            User.create! #this should raise an error
+          end
+        end
+        expect(user_class.count).to eq(0)
+        user = user_class.create!(:name => 'name')
+        expect {
+          user.transaction { user.invite_and_save! }
+        }.to raise_error(ActiveRecord::RecordInvalid,
+                         "Validation failed: Name can't be blank")
+        expect(user_class.count).to eq(1)
+        expect(user_class.first.name).to eq('name')
+        expect(user_class.first).to be_new
+      end
+
+    end
+
+    describe "event" do
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
+
+      it "returns false, keeps state and keeps errors if event adds errors" do
+        user = User.create!(:name => 'name')
+        user.invite_and_save!
+        expect(user).to be_invited
+        expect(user.confirm_invitation('x')).to eq(false)
+        expect(user).to be_invited
+        expect(Array(user.errors[:activation_code])).to eq(['is invalid'])
+      end
 
-    it "raises an error" do
-      user = User.create!(:name => 'name')
-      expect { user.invite }.to raise_error(RuntimeError, "You cannot call invite. Use invite! instead")
     end
 
-  end
+    describe "event!" do
 
-  describe "event!" do
+      it "persists transitions" do
+        user = User.create!(:name => 'name')
+        expect(user.invite!).to eq(true)
+        expect(User.find(user.id)).to be_invited
+        expect(User.find(user.id).activation_code).not_to be_nil
+      end
 
-    it "persists transitions" do
-      user = User.create!(:name => 'name')
-      user.invite!.should == true
-      User.find(user.id).should be_invited
-      User.find(user.id).activation_code.should_not be_nil
-    end
+      it "raises a RecordInvalid and keeps state if record is invalid" do
+        user = User.new
+        expect(user).to be_new
+        expect(user).not_to be_valid
+        expect { user.invite! }.to raise_error(ActiveRecord::RecordInvalid, "Validation failed: Name can't be blank")
+        expect(user).to be_new
+      end
 
-    it "raises a RecordInvalid and keeps state if record is invalid" do
-      user = User.new
-      user.should be_new
-      user.should_not be_valid
-      expect { user.invite! }.to raise_error(ActiveRecord::RecordInvalid, "Validation failed: Name can't be blank")
-      user.should be_new
     end
 
-  end
+    describe 'custom state method' do
 
-  describe 'custom state method' do
+      it "persists transitions" do
+        ticket = Ticket.create!
+        expect(ticket.ssm_state).to eq('open')
+        expect(ticket.close!).to eq(true)
+        expect(ticket.ssm_state).to eq('closed')
+      end
 
-    it "persists transitions" do
-      ticket = Ticket.create!
-      ticket.should be_open
-      ticket.close!.should == true
-      ticket.should be_closed
-    end
+      it "persists transitions with !" do
+        ticket = Ticket.create!
+        expect(ticket.ssm_state).to eq('open')
+        ticket.close!
+        expect(ticket.ssm_state).to eq('closed')
+      end
 
-    it "persists transitions with !" do
-      ticket = Ticket.create!
-      ticket.should be_open
-      ticket.close!
-      ticket.should be_closed
     end
 
   end
-
 end
-