simple_state_machine 0.5.3 → 0.6.2

data/lib/simple_state_machine/simple_state_machine.rb

@@ -1,17 +1,12 @@
 module SimpleStateMachine
 
-  require 'cgi'
-
-  class IllegalStateTransitionError < ::RuntimeError
-  end
-
   ##
   # Allows class to mount a state_machine
   module Mountable
     def state_machine_definition
       unless @state_machine_definition
         @state_machine_definition = StateMachineDefinition.new
-        @state_machine_definition.lazy_decorator = lambda { Decorator.new(self) }
+        @state_machine_definition.subject = self
       end
       @state_machine_definition
     end
@@ -22,22 +17,22 @@ module SimpleStateMachine
         state_machine_definition.decorator.decorate(transition)
       end
     end
+
+    def mount_state_machine mountable_class
+      self.state_machine_definition = mountable_class.new
+      self.state_machine_definition.subject = self
+      self.state_machine_definition.add_events
+    end
   end
   include Mountable
 
   ##
   # Adds state machine methods to the extended class
   module Extendable
-
     # mark the method as an event and specify how the state should transition
     def event event_name, state_transitions
-      state_transitions.each do |froms, to|
-        [froms].flatten.each do |from|
-          state_machine_definition.add_transition(event_name, from, to)
-        end
-      end
+      state_machine_definition.define_event event_name, state_transitions
     end
-
   end
   include Extendable
 
@@ -54,242 +49,4 @@ module SimpleStateMachine
   end
   include Inheritable
 
-  ##
-  # Defines state machine transitions
-  class StateMachineDefinition
-
-    attr_writer :state_method, :decorator, :lazy_decorator
-
-    def decorator
-      @decorator ||= @lazy_decorator.call
-    end
-
-    def transitions
-      @transitions ||= []
-    end
-
-    def add_transition event_name, from, to
-      transition = Transition.new(event_name, from, to)
-      transitions << transition
-      decorator.decorate(transition)
-    end
-
-    def state_method
-      @state_method ||= :state
-    end
-
-    # Human readable format: old_state.event! => new_state
-    def to_s
-      transitions.map(&:to_s).join("\n")
-    end
-
-    # Graphiz dot format for rendering as a directional graph
-    def to_graphiz_dot
-      transitions.map { |t| t.to_graphiz_dot }.join(";")
-    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
-      "http://chart.googleapis.com/chart?cht=gv&chl=digraph{#{::CGI.escape to_graphiz_dot}}"
-    end
-  end
-
-  ##
-  # Defines the state machine used by the instance
-  class StateMachine
-
-    def initialize(subject)
-      @subject = subject
-    end
-
-    # Returns the next state for the subject for event_name
-    def next_state(event_name)
-      transition = transitions.select{|t| t.is_transition_for?(event_name, @subject.send(state_method))}.first
-      transition ? transition.to : nil
-    end
-
-    # Returns the error state for the subject for event_name and error
-    def error_state(event_name, error)
-      transition = transitions.select{|t| t.is_error_transition_for?(event_name, error) }.first
-      transition ? transition.to : nil
-    end
-
-    # Transitions to the next state if next_state exists.
-    # Calls illegal_event_callback event_name if no next_state is found
-    def transition(event_name)
-      if to = next_state(event_name)
-        begin
-          result = yield
-        rescue => e
-          if error_state = error_state(event_name, e)
-            @subject.send("#{state_method}=", error_state)
-            return result
-          else
-            raise
-          end
-        end
-        # TODO refactor out to AR module
-        if defined?(::ActiveRecord) && @subject.is_a?(::ActiveRecord::Base)
-          if @subject.errors.entries.empty?
-            @subject.send("#{state_method}=", to)
-            return true
-          else
-            return false
-          end
-        else
-          @subject.send("#{state_method}=", to)
-          return result
-        end
-      else
-        illegal_event_callback event_name
-      end
-    end
-
-    private
-
-      def state_machine_definition
-        @subject.class.state_machine_definition
-      end
-
-      def transitions
-        state_machine_definition.transitions
-      end
-
-      def state_method
-        state_machine_definition.state_method
-      end
-
-      # override with your own implementation, like setting errors in your model
-      def illegal_event_callback event_name
-        raise IllegalStateTransitionError.new("You cannot '#{event_name}' when state is '#{@subject.send(state_method)}'")
-      end
-
-  end
-
-  ##
-  # 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
-    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) && error.class == from
-    end
-
-    def to_s
-      "#{from}.#{event_name}! => #{to}"
-    end
-
-    def to_graphiz_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
-
-  ##
-  # Decorates @subject with methods to access the state machine
-  class Decorator
-
-    attr_writer :subject
-    def initialize(subject)
-      @subject = subject
-      define_state_machine_method
-      define_state_getter_method
-      define_state_setter_method
-    end
-
-    def decorate transition
-      define_state_helper_method(transition.from)
-      define_state_helper_method(transition.to)
-      define_event_method(transition.event_name)
-      decorate_event_method(transition.event_name)
-    end
-
-    private
-
-      def define_state_machine_method
-        @subject.send(:define_method, "state_machine") do
-          @state_machine ||= StateMachine.new(self)
-        end
-      end
-
-      def define_state_helper_method state
-        unless any_method_defined?("#{state.to_s}?")
-          @subject.send(:define_method, "#{state.to_s}?") do
-            self.send(self.class.state_machine_definition.state_method) == state.to_s
-          end
-        end
-      end
-
-      def define_event_method event_name
-        unless any_method_defined?("#{event_name}")
-          @subject.send(:define_method, "#{event_name}") {}
-        end
-      end
-
-      def decorate_event_method event_name
-        # TODO put in transaction for activeRecord?
-        unless @subject.method_defined?("with_managed_state_#{event_name}")
-          @subject.send(:define_method, "with_managed_state_#{event_name}") do |*args|
-            return state_machine.transition(event_name) do
-              send("without_managed_state_#{event_name}", *args)
-            end
-          end
-          alias_event_methods event_name
-        end
-      end
-
-      def define_state_setter_method
-        unless any_method_defined?("#{state_method}=")
-          @subject.send(:define_method, "#{state_method}=") do |new_state|
-            instance_variable_set(:"@#{self.class.state_machine_definition.state_method}", new_state)
-          end
-        end
-      end
-
-      def define_state_getter_method
-        unless any_method_defined?(state_method)
-          @subject.send(:attr_reader, state_method)
-        end
-      end
-
-      def any_method_defined?(method)
-        @subject.method_defined?(method) ||
-        @subject.protected_method_defined?(method) ||
-        @subject.private_method_defined?(method)
-      end
-
-    protected
-
-      def alias_event_methods event_name
-        @subject.send :alias_method, "without_managed_state_#{event_name}", event_name
-        @subject.send :alias_method, event_name, "with_managed_state_#{event_name}"
-      end
-
-      def state_method
-        @subject.state_machine_definition.state_method
-      end
-  end
-
 end

data/lib/simple_state_machine/state_machine.rb

@@ -0,0 +1,88 @@
+module SimpleStateMachine
+
+  class IllegalStateTransitionError < ::RuntimeError; end
+
+  ##
+  # Defines the state machine used by the instance
+  class StateMachine
+    attr_reader :raised_error
+
+    def initialize(subject)
+      @subject = subject
+    end
+
+    # Returns the next state for the subject for event_name
+    def next_state(event_name)
+      transition = transitions.select{|t| t.is_transition_for?(event_name, @subject.send(state_method))}.first
+      transition ? transition.to : nil
+    end
+
+    # Returns the error state for the subject for event_name and error
+    def error_state(event_name, error)
+      transition = transitions.select{|t| t.is_error_transition_for?(event_name, error) }.first
+      transition ? transition.to : nil
+    end
+
+    # Transitions to the next state if next_state exists.
+    # When an error occurs, it uses the error to determine next state.
+    # If no next state can be determined it transitions to the default error
+    # state if defined, otherwise the error is re-raised.
+    # Calls illegal_event_callback event_name if no next_state is found
+    def transition(event_name)
+      clear_raised_error
+      if to = next_state(event_name)
+        begin
+          result = yield
+        rescue => e
+          error_state = error_state(event_name, e) ||
+            state_machine_definition.default_error_state
+          if error_state
+            @raised_error = e
+            @subject.send("#{state_method}=", error_state)
+            return result
+          else
+            raise
+          end
+        end
+        # TODO refactor out to AR module
+        if defined?(::ActiveRecord) && @subject.is_a?(::ActiveRecord::Base)
+          if @subject.errors.entries.empty?
+            @subject.send("#{state_method}=", to)
+            return true
+          else
+            return false
+          end
+        else
+          @subject.send("#{state_method}=", to)
+          return result
+        end
+      else
+        illegal_event_callback event_name
+      end
+    end
+
+    private
+
+      def clear_raised_error
+        @raised_error = nil
+      end
+
+      def state_machine_definition
+        @subject.class.state_machine_definition
+      end
+
+      def transitions
+        state_machine_definition.transitions
+      end
+
+      def state_method
+        state_machine_definition.state_method
+      end
+
+      # override with your own implementation, like setting errors in your model
+      def illegal_event_callback event_name
+        raise IllegalStateTransitionError.new("You cannot '#{event_name}' when state is '#{@subject.send(state_method)}'")
+      end
+
+  end
+end

data/lib/simple_state_machine/state_machine_definition.rb

@@ -0,0 +1,72 @@
+module SimpleStateMachine
+  ##
+  # Defines state machine transitions
+  class StateMachineDefinition
+
+    attr_writer :default_error_state, :state_method, :subject, :decorator,
+                :decorator_class
+
+    def decorator
+      @decorator ||= decorator_class.new(@subject)
+    end
+
+    def decorator_class
+      @decorator_class ||= Decorator::Default
+    end
+
+    def default_error_state
+      @default_error_state && @default_error_state.to_s
+    end
+
+    def transitions
+      @transitions ||= []
+    end
+
+    def define_event event_name, state_transitions
+      state_transitions.each do |froms, to|
+        [froms].flatten.each do |from|
+          add_transition(event_name, from, to)
+        end
+      end
+    end
+
+    def add_transition event_name, from, to
+      transition = Transition.new(event_name, from, to)
+      transitions << transition
+      decorator.decorate(transition)
+    end
+
+    def state_method
+      @state_method ||= :state
+    end
+
+    # Human readable format: old_state.event! => new_state
+    def to_s
+      transitions.map(&:to_s).join("\n")
+    end
+
+    module Mountable
+      def event event_name, state_transitions
+        events << [event_name, state_transitions]
+      end
+
+      def events
+        @events ||= []
+      end
+
+      module InstanceMethods
+        def add_events
+          self.class.events.each do |event_name, state_transitions|
+            define_event event_name, state_transitions
+          end
+        end
+      end
+    end
+    extend Mountable
+    include Mountable::InstanceMethods
+
+    # TODO only include in rake task?
+    include ::SimpleStateMachine::Tools::Graphviz
+    include ::SimpleStateMachine::Tools::Inspector
+  end
+end

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.3"
+  VERSION = "0.6.2"
 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