simple_state_machine 0.5.2 → 0.6.1

data/lib/simple_state_machine/active_record.rb

@@ -4,73 +4,11 @@ module SimpleStateMachine::ActiveRecord
   include SimpleStateMachine::Extendable
   include SimpleStateMachine::Inheritable
 
-  class Decorator < SimpleStateMachine::Decorator
-
-    # decorates subject with:
-    # * {event_name}_and_save
-    # * {event_name}_and_save!
-    # * {event_name}!
-    def decorate transition
-      super transition
-      event_name = transition.event_name.to_s
-      event_name_and_save = "#{event_name}_and_save"
-      unless @subject.method_defined?(event_name_and_save)
-        @subject.send(:define_method, event_name_and_save) do |*args|
-          old_state = self.send(self.class.state_machine_definition.state_method)
-          send "with_managed_state_#{event_name}", *args
-          if !self.errors.entries.empty?
-            self.send("#{self.class.state_machine_definition.state_method}=", old_state)
-            return false
-          else
-            if save
-              return true
-            else
-              self.send("#{self.class.state_machine_definition.state_method}=", old_state)
-              return false
-            end
-          end
-        end
-      end
-      event_name_and_save_bang = "#{event_name_and_save}!"
-      unless @subject.method_defined?(event_name_and_save_bang)
-        @subject.send(:define_method, event_name_and_save_bang) do |*args|
-          old_state = self.send(self.class.state_machine_definition.state_method)
-          send "with_managed_state_#{event_name}", *args
-          if !self.errors.entries.empty?
-            self.send("#{self.class.state_machine_definition.state_method}=", old_state)
-            raise ActiveRecord::RecordInvalid.new(self)
-          end
-          begin
-            save!
-          rescue ActiveRecord::RecordInvalid
-            self.send("#{self.class.state_machine_definition.state_method}=", old_state)
-            raise #re raise
-          end
-        end
-        @subject.send :alias_method, "#{transition.event_name}!", event_name_and_save_bang
-      end
-    end
-
-    protected
-
-      def alias_event_methods event_name
-        @subject.send(:define_method, "cannot_call_#{event_name}") do |*args|
-          raise "You cannot call #{event_name}. Use #{event_name}! instead"
-        end
-        @subject.send :alias_method, "without_managed_state_#{event_name}", event_name
-        @subject.send :alias_method, event_name, "cannot_call_#{event_name}"
-      end
-
-      def define_state_setter_method; end
-
-      def define_state_getter_method; end
-
-  end
-
   def state_machine_definition
     unless @state_machine_definition
       @state_machine_definition = SimpleStateMachine::StateMachineDefinition.new
-      @state_machine_definition.lazy_decorator = lambda { Decorator.new(self) }
+      @state_machine_definition.decorator_class = SimpleStateMachine::Decorator::ActiveRecord
+      @state_machine_definition.subject = self
     end
     @state_machine_definition
   end

data/lib/simple_state_machine/decorator/active_record.rb

@@ -0,0 +1,68 @@
+module SimpleStateMachine
+  module Decorator
+    class ActiveRecord < SimpleStateMachine::Decorator::Default
+
+      # decorates subject with:
+      # * {event_name}_and_save
+      # * {event_name}_and_save!
+      # * {event_name}!
+      # * {event_name}
+      def decorate transition
+        super transition
+        event_name = transition.event_name.to_s
+        decorate_save  event_name
+        decorate_save! event_name
+      end
+
+      protected
+
+        def decorate_save event_name
+          event_name_and_save = "#{event_name}_and_save"
+          unless @subject.method_defined?(event_name_and_save)
+            @subject.send(:define_method, event_name_and_save) do |*args|
+              old_state = self.send(self.class.state_machine_definition.state_method)
+              send "#{event_name}_with_managed_state", *args
+              if self.errors.entries.empty? && save
+                true
+              else
+                self.send("#{self.class.state_machine_definition.state_method}=", old_state)
+                false
+              end
+            end
+            @subject.send :alias_method, "#{event_name}", event_name_and_save
+          end
+        end
+
+        def decorate_save! event_name
+          event_name_and_save_bang = "#{event_name}_and_save!"
+          unless @subject.method_defined?(event_name_and_save_bang)
+            @subject.send(:define_method, event_name_and_save_bang) do |*args|
+              old_state = self.send(self.class.state_machine_definition.state_method)
+              send "#{event_name}_with_managed_state", *args
+              if self.errors.entries.empty?
+                begin
+                  save!
+                rescue ::ActiveRecord::RecordInvalid
+                  self.send("#{self.class.state_machine_definition.state_method}=", old_state)
+                  raise #re raise
+                end
+              else
+                self.send("#{self.class.state_machine_definition.state_method}=", old_state)
+                raise ::ActiveRecord::RecordInvalid.new(self)
+              end
+            end
+            @subject.send :alias_method, "#{event_name}!", event_name_and_save_bang
+          end
+        end
+
+        def alias_event_methods event_name
+          @subject.send :alias_method, "#{event_name}_without_managed_state", event_name
+        end
+
+        def define_state_setter_method; end
+
+        def define_state_getter_method; end
+
+    end
+  end
+end

data/lib/simple_state_machine/decorator/default.rb

@@ -0,0 +1,91 @@
+module SimpleStateMachine
+  module Decorator
+    ##
+    # Decorates @subject with methods to access the state machine
+    class Default
+
+      attr_writer :subject
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def decorate transition
+        define_state_machine_method
+        define_state_getter_method
+        define_state_setter_method
+
+        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
+          unless any_method_defined?("state_machine")
+            @subject.send(:define_method, "state_machine") do
+              @state_machine ||= StateMachine.new(self)
+            end
+          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?("#{event_name}_with_managed_state")
+            @subject.send(:define_method, "#{event_name}_with_managed_state") do |*args|
+              return state_machine.transition(event_name) do
+                send("#{event_name}_without_managed_state", *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, "#{event_name}_without_managed_state", event_name
+          @subject.send :alias_method, event_name, "#{event_name}_with_managed_state"
+        end
+
+        def state_method
+          @subject.state_machine_definition.state_method
+        end
+    end
+  end
+end

data/lib/simple_state_machine/railtie.rb

@@ -4,7 +4,7 @@ require 'rails'
 module SimpleStateMachine
   class Railtie < Rails::Railtie
     rake_tasks do
-      load "tasks/graphiz.rake"
+      load "tasks/graphviz.rake"
     end
   end
 end

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