state_flow 0.1.0 → 0.2.0

data/lib/state_flow/exception_handler.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+require 'state_flow'
+module StateFlow
+
+  class ExceptionHandler < Event
+    attr_reader :exceptions
+    attr_reader :recovering, :rolling_back, :logging_error
+    
+    def initialize(origin, *exceptions, &block)
+      options = exceptions.extract_options!
+      @exceptions = exceptions
+      super(origin, &block)
+      @recovering = options[:recovering] || false
+      @rolling_back = options[:rolling_back] || options[:rollback] || false
+      @logging_error = options[:logging]
+    end
+    
+    def match?(exception)
+      prepare_exceptions
+      exceptions.any?{|klass| exception.is_a?(klass)}
+    end
+
+    def process(context)
+      context.recovered_exceptions << context.exceptions.last if recovering
+      context.transaction_rollback if rolling_back
+      context.record_reload_if_possible
+      super
+    end
+
+    private
+    def prepare_exceptions
+      return if exceptions.all?{|ex| ex.is_a?(Class)}
+      @exceptions = exceptions.map do |ex|
+        ex.is_a?(Class) ? ex : ex.to_s.constantize
+      end
+    end
+  end
+
+end

data/lib/state_flow/exception_handler_client.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+require 'state_flow'
+module StateFlow
+
+  module ExceptionHandlerClient
+    def exception_handling(context)
+      begin
+        yield
+      rescue Exception => exception
+        context.exceptions << exception
+        context.trace(exception)
+        handlers = events.select{|ev| ev.is_a?(ExceptionHandler)}
+        handlers.each do |handler|
+          next unless handler.match?(exception)
+          handler.process(context)
+          break
+        end
+        raise exception unless context.recovered?(exception)
+      end
+    end
+
+  end
+
+
+end

data/lib/state_flow/guard.rb

@@ -0,0 +1,21 @@
+require 'state_flow'
+module StateFlow
+
+  class Guard < Element
+    include EventClient
+    include ActionClient
+
+    def match?(context)
+      true
+    end
+
+    def process(context)
+      exception_handling(context) do
+        action.process(context) if action
+        update_to_destination(context)
+      end
+    end
+
+  end
+
+end

data/lib/state_flow/guard_client.rb

@@ -0,0 +1,28 @@
+require 'state_flow'
+module StateFlow
+
+  module GuardClient
+    def guards
+      @guards ||= []
+    end
+
+    def guard(method_name, &block)
+      result = NamedGuard.new(self, method_name, &block)
+      guards << result
+      result
+    end
+
+    def guard_else(&block)
+      result = Guard.new(self, &block)
+      guards << result
+      result
+    end
+    
+    def guard_for(context)
+      guards.detect{|guard| guard.match?(context)}
+    end
+    
+  end
+
+end
+

data/lib/state_flow/named_event.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+require 'state_flow'
+module StateFlow
+
+  class NamedEvent < Event
+    attr_reader :name
+    def initialize(origin, name, &block)
+      @name = name
+      super(origin, &block)
+    end
+
+    def process(context)
+      block = state.ancestors_exception_handled_proc(context) do
+        super
+      end
+      block.call
+    end
+
+    class << self
+      def build_event_methods(flow)
+        named_events = []
+        flow.all_states.each do |state_name, state|
+          state.visit do |event|
+            named_events << event if event.is_a?(NamedEvent)
+            [:events, :guards, :action]
+          end
+        end
+        method_name_to_events = {}
+        named_events.each do |ev|
+          method_name_to_events[ev.name] ||= []
+          method_name_to_events[ev.name] << ev
+        end
+        method_name_to_events.each do |name, events|
+          flow.klass.module_eval do
+            # イベントを通知するときに呼び出されるメソッド
+            define_method(name) do |*args|
+              result = nil
+              events.each do |event|
+                if event.state.include?(self.send(flow.attr_key_name))
+                  context = flow.prepare_context(self, args.first)
+                  result = context.process(event)
+                  break
+                end
+              end
+              result # return
+            end
+
+          end
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/state_flow/named_guard.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+require 'state_flow'
+module StateFlow
+
+  class NamedGuard < Guard
+    attr_reader :name
+    def initialize(origin, name, &block)
+      @name = name
+      super(origin, &block)
+    end
+
+    def match?(context)
+      context.record_send(name)
+    end
+  end
+
+end

data/lib/state_flow/state.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+require 'state_flow'
+module StateFlow
+
+  class State
+    include EventClient
+    include GuardClient
+    include ActionClient
+    include ElementVisitable
+
+    attr_reader :name, :flow, :parent
+    attr_accessor :termination
+    def initialize(flow_or_parent, name, &block)
+      @name = name
+      @parent = flow_or_parent if flow_or_parent.is_a?(State)
+      @flow = flow_or_parent.is_a?(State) ? flow_or_parent.flow : flow_or_parent
+      @concreate = @flow.state_cd_by_key(@name)
+      instance_eval(&block) if block
+    end
+    
+    def state(name, &block)
+      result = State.new(self, name, &block)
+      children << result
+      result
+    end
+    alias_method :from, :state
+    alias_method :group, :state
+    alias_method :state_group, :state
+
+    def termination(name = nil)
+      result = name ? state(name) : self
+      result.termination = true
+      result
+    end
+
+    def children
+      @children ||= []
+    end
+
+    def descendants
+      [self, children.map{|c|c.descendants}].flatten
+    end
+
+    def include?(state_or_name)
+      name = state_or_name.is_a?(State) ? state_or_name.name : state_or_name
+      descendants.any?{|state| state.name == name}
+    end
+
+    def concrete?
+      @concreate
+    end
+
+    private
+    # for EventClient
+    def origin
+      self
+    end
+
+    public
+    def process(context)
+      context.trace(self)
+      block = ancestors_exception_handled_proc(context) do
+        guard = guard_for(context)
+        return guard.process(context) if guard
+        return action.process(context) if action
+      end
+      block.call
+    end
+    
+    def ancestors_exception_handled_proc(context, &block)
+      result = Proc.new{ exception_handling(context, &block) }
+      parent ? parent.ancestors_exception_handled_proc(context, &result) : result
+    end
+
+    def name_path(separator = '>')
+      result = []
+      current = self
+      while current
+        result << current.name
+        current = current.parent
+      end
+      result.reverse.join(separator)
+    end
+
+    def inspect
+      "#<%s:%#x @name=%s>" % [self.class.name, self.object_id, name_path.inspect]
+    end
+    
+  end
+
+end

data/lib/state_flow.rb

@@ -1,19 +1,33 @@
 module StateFlow
   autoload :Base, 'state_flow/base'
-  autoload :Builder, 'state_flow/builder'
+  autoload :Context, 'state_flow/context'
+
+  autoload :State, 'state_flow/state'
+  
+  autoload :Element, 'state_flow/element'
+  autoload :ElementVisitable, 'state_flow/element_visitable'
+
   autoload :Action, 'state_flow/action'
-  autoload :NamedAction, 'state_flow/named_action'
+  autoload :ActionClient, 'state_flow/action_client'
+
+  autoload :Guard, 'state_flow/guard'
+  autoload :GuardClient, 'state_flow/guard_client'
+  autoload :NamedGuard, 'state_flow/named_guard'
+
   autoload :Event, 'state_flow/event'
-  autoload :Entry, 'state_flow/entry'
+  autoload :EventClient, 'state_flow/event_client'
+  autoload :NamedEvent, 'state_flow/named_event'
+  autoload :ActionEvent, 'state_flow/action_event'
+  autoload :ExceptionHandler, 'state_flow/exception_handler'
+  autoload :ExceptionHandlerClient, 'state_flow/exception_handler_client'
+
   autoload :Log, 'state_flow/log'
   
   # autoload :ActiveRecord, 'state_flow/active_record'
   
   def self.included(mod)
     mod.module_eval do
-      extend ::StateFlow::Builder::ClientClassMethods
-      extend ::StateFlow::Base::ClassMethods
-      # include ::StateFlow::ActiveRecord if mod.ancestors.map{|m| m.name}.include?('ActiveRecord::Base')
+      extend(Base::ClientClassMethods)
     end
   end
   

data/spec/database.yml

@@ -21,5 +21,3 @@ postgresql:
   host: localhost
   username: postgres
   password: 
-  allow_concurrency: true
-  pool: 30