simple_state_machine 0.6.0.pre → 0.6.0

data/lib/simple_state_machine/simple_state_machine.rb

@@ -1,10 +1,5 @@
 module SimpleStateMachine
 
-  require 'cgi'
-
-  class IllegalStateTransitionError < ::RuntimeError
-  end
-
   ##
   # Allows class to mount a state_machine
   module Mountable
@@ -34,12 +29,10 @@ module SimpleStateMachine
   ##
   # 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_machine_definition.define_event event_name, state_transitions
     end
-
   end
   include Extendable
 
@@ -56,339 +49,4 @@ module SimpleStateMachine
   end
   include Inheritable
 
-  ##
-  # 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
-    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 Graphviz
-      # Graphviz dot format for rendering as a directional graph
-      def to_graphviz_dot
-        transitions.map { |t| t.to_graphviz_dot }.sort.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_graphviz_dot}}"
-      end
-    end
-    include Graphviz
-
-    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
-    include Inspector
-
-    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
-
-  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
-
-  ##
-  # 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) && from.is_a?(Class) && error.is_a?(from)
-    end
-
-    def to_s
-      "#{from}.#{event_name}! => #{to}"
-    end
-
-    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
-
-  ##
-  # Decorates @subject with methods to access the state machine
-  class Decorator
-
-    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?("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