state_flow 0.1.0 → 0.2.0

data/spec/state_flow/state_spec.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), '../spec_helper')
+
+describe StateFlow::State do
+  
+  describe "with Order" do
+    describe "from waiting_settling" do
+      describe ":cash_on_delivery" do
+        before do
+          StateFlow::Log.delete_all
+          Order.delete_all
+          @order = Order.new
+          @order.product_name = "Beautiful Code"
+          @order.payment_type = :cash_on_delivery
+          @order.status_key = :waiting_settling
+          @order.save!
+          Order.count == 1
+
+          @flow = Order.state_flow_for(:status_cd)
+          @state = @flow.origin
+          @state.name.should == :waiting_settling
+
+          @context = @flow.prepare_context(@order)
+        end
+
+        it "should recieve guard process" do
+          g0 = @state.guards[0] # :pay_cash_on_delivery?
+          g0.should_receive(:process).with(@context).and_return{|order| g0.action.process(order)}
+          @order.process_status_cd(@context)
+          @order.status_key.should == :stock_error
+        end
+        
+        it "should recieve action process #0" do
+          g0 = @state.guards[0] # :pay_cash_on_delivery?
+          a0 = g0.action # :reserve_point
+          a0.should_receive(:process).with(@context).and_return{|order| a0.action.process(order)}
+          @order.process_status_cd(@context)
+          @order.status_key.should == :stock_error
+        end
+        
+        it "should recieve action process #1" do
+          g0 = @state.guards[0] # :pay_cash_on_delivery?
+          a0 = g0.action # :reserve_point
+          a1 = a0.action # :reserve_stock
+          a1.should_receive(:process).with(@context).and_return{|order| a1.events[0].process(order)}
+          @order.process_status_cd(@context)
+          @order.status_key.should == :deliver_preparing
+        end
+
+        describe "action event invocation" do
+          before do
+            g0 = @state.guards[0] # :pay_cash_on_delivery?
+            a0 = g0.action # :reserve_point
+            @a1 = a0.action # :reserve_stock
+          end
+
+          it "should recieve action events_for_action" do
+            @order.should_receive(:reserve_stock).and_return(nil)
+            @a1.should_receive(:event_for_action_result).and_return(@a1.events[0])
+            @order.process_status_cd(@context)
+            @order.status_key.should == :deliver_preparing
+          end
+
+          it "should recieve action events_for_action" do
+            @order.should_receive(:reserve_stock).and_return(:reserve_stock_ok)
+            @a1.should_receive(:event_for_action_result).and_return(@a1.events[1])
+            @order.process_status_cd(@context)
+            @order.status_key.should == :stock_error
+          end
+        end
+
+        it "should recieve action event update_to_destination" do
+          @order.should_receive(:reserve_stock).and_return(:reserve_stock_ok)
+          @order.process_status_cd(@context)
+          @order.status_key.should == :deliver_preparing
+        end
+                
+        it "should recieve action event update_to_destination #2" do
+          @order.should_receive(:reserve_stock).and_return(nil)
+          @order.process_status_cd(@context)
+          @order.status_key.should == :stock_error
+        end
+      end
+
+      describe ":credit_card" do
+        before do
+          StateFlow::Log.delete_all
+          Order.delete_all
+          @order = Order.new
+          @order.product_name = "Beautiful Code"
+          @order.payment_type = :credit_card
+          @order.status_key = :waiting_settling
+          @order.save!
+          Order.count == 1
+
+          @flow = Order.state_flow_for(:status_cd)
+          @state = @flow.origin
+          @state.name.should == :waiting_settling
+
+          @context = @flow.prepare_context(@order)
+        end
+
+        describe ":reserve_stock_ok" do
+          before do
+            @order.should_receive(:reserve_stock).and_return(:reserve_stock_ok)
+          end
+
+          it "should recieve guard process" do
+            g1 = @state.guards[1]
+            g1.should_receive(:process).with(@context).and_return{|order| g1.action.process(order)}
+            @order.process_status_cd(@context)
+          end
+
+          it "should recieve action event_for_action_result" do
+            g1 = @state.guards[1]
+            a0 = g1.action
+            a1 = a0.action
+            a1.event_for_action_result(:reserve_stock_ok).should == a1.events[0]
+            a1.should_receive(:event_for_action_result).and_return(a1.events[0])
+            @order.process_status_cd(@context)
+          end
+
+          it "should recieve evnet process" do
+            g1 = @state.guards[1]
+            a0 = g1.action
+            a1 = a0.action
+            e0 = a1.events[0]
+            e0.should_receive(:process).with(@context).and_return{|order| e0.guards[1].process(order)}
+            @order.process_status_cd(@context)
+          end
+
+          it "should recieve evnet process" do
+            g1 = @state.guards[1]
+            a0 = g1.action
+            a1 = a0.action
+            e0 = a1.events[0]
+            g1 = e0.guards[1]
+            g1.should_receive(:process).with(@context).and_return{|order| g1.update_to_destination(order)}
+            @order.process_status_cd(@context)
+          end
+        end
+        
+        
+      end
+    
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: state_flow
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Takeshi Akima
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-27 00:00:00 +09:00
+date: 2009-11-04 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -31,21 +31,30 @@ files:
 - install.rb
 - lib/state_flow.rb
 - lib/state_flow/action.rb
+- lib/state_flow/action_client.rb
+- lib/state_flow/action_event.rb
 - lib/state_flow/base.rb
-- lib/state_flow/builder.rb
-- lib/state_flow/entry.rb
+- lib/state_flow/context.rb
+- lib/state_flow/element.rb
+- lib/state_flow/element_visitable.rb
 - lib/state_flow/event.rb
+- lib/state_flow/event_client.rb
+- lib/state_flow/exception_handler.rb
+- lib/state_flow/exception_handler_client.rb
+- lib/state_flow/guard.rb
+- lib/state_flow/guard_client.rb
 - lib/state_flow/log.rb
-- lib/state_flow/named_action.rb
+- lib/state_flow/named_event.rb
+- lib/state_flow/named_guard.rb
+- lib/state_flow/state.rb
 - spec/.gitignore
-- spec/base_spec.rb
-- spec/concurrency_spec.rb
 - spec/database.yml
-- spec/page_spec.rb
-- spec/resources/models/page.rb
+- spec/order_spec.rb
+- spec/resources/models/order.rb
 - spec/schema.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/state_flow/state_spec.rb
 - tasks/state_flow_tasks.rake
 - uninstall.rb
 has_rdoc: true
@@ -77,9 +86,8 @@ signing_key:
 specification_version: 3
 summary: state_flow provides a DSL for State Transition
 test_files: 
-- spec/base_spec.rb
-- spec/concurrency_spec.rb
-- spec/page_spec.rb
-- spec/resources/models/page.rb
+- spec/order_spec.rb
+- spec/resources/models/order.rb
 - spec/schema.rb
 - spec/spec_helper.rb
+- spec/state_flow/state_spec.rb

data/lib/state_flow/builder.rb

@@ -1,193 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'state_flow'
-module StateFlow
-
-  module Builder
-    module ClientClassMethods
-      def state_flow_for(selectable_attr)
-        return nil unless @state_flows
-        @state_flows.detect{|flow| flow.attr_name == selectable_attr}
-      end
-
-      def state_flow(selectable_attr, options = nil, &block)
-        options = {
-          :attr_key_name => "#{self.enum_base_name(selectable_attr)}_key".to_sym
-        }.update(options || {})
-        flow = Base.new(self, selectable_attr, options[:attr_key_name])
-        flow.instance_eval(&block)
-        flow.setup_events
-        @state_flows ||= []
-        @state_flows << flow
-        flow
-      end
-    end
-
-    def new_entry(key)
-      @entry_hash = nil
-      result = Entry.new(self, key)
-      entries << result
-      result
-    end
-
-    def state(*args)
-      raise_invalid_state_argument if args.length > 2
-      if args.length == 2
-        # 引数が２個ならできるだけ一つのHashにまとめます。
-        case args.first
-        when Hash then 
-          return state(args.first.update(args.last))
-        when Symbol, String
-          return state({args.first => nil}.update(args.last))
-        else
-          raise_invalid_state_argument
-        end
-      end
-      # 引数が一つだけになってます
-      arg = args.first
-      case arg
-      when Symbol, String
-        return state({args.first => nil})
-      when Hash then
-        # through
-      else
-        raise_invalid_state_argument
-      end
-      # 引数がHash一つだけの場合
-      base_options = extract_common_options(arg)
-      arg.each do |key, value|
-        entry = new_entry(key)
-        build_entry(entry, value, base_options)
-      end
-    end
-
-    def action(name)
-      NamedAction.new(self, name)
-    end
-
-    def event(name)
-      Event.new(self, name)
-    end
-
-    def setup_events
-      event_defs = {}
-      entries.each do |entry|
-        origin_key = entry.key
-        entry.events.each do |event|
-          event_trans = event_defs[event.name] ||= {}
-          event_trans[origin_key] = [event.success_key, event.failure_key]
-        end
-      end
-      event_defs.each do |event_name, trans|
-        method_def = <<-"EOS"
-          def #{event_name}
-            @state_flow ||= self.class.state_flow_for(:#{attr_name})
-            @#{event_name}_transitions ||= #{trans.inspect}
-            @state_flow.process_with_log(self, 
-              *@#{event_name}_transitions[#{attr_key_name}])
-          end
-        EOS
-        if klass.instance_methods.include?(event_name)
-          klass.logger.warn("state_flow plugin was going to define #{event_name} but didn't do it because #{event_name} does exist.")
-        else
-          klass.module_eval(method_def, __FILE__, __LINE__)
-        end
-      end
-    end
-    
-    private
-    
-    def build_entry(entry, options_or_success_key, base_options)
-      if options_or_success_key.nil?
-        return null_action_entry(entry, base_options)
-      end
-      case options_or_success_key
-      when String, Symbol then
-        return null_action_entry(entry, base_options, options_or_success_key.to_sym)
-      when Action then
-        entry.action = setup_action(options_or_success_key, base_options)
-        return entry
-      when Hash then
-        options = options_or_success_key
-        prior_options = extract_common_options(options)
-        options_keys = options.keys
-        if options_keys.all?{|key| key.is_a?(Action)}
-          build_action(entry, options, base_options.merge(prior_options))
-        elsif options_keys.all?{|key| key.is_a?(Event)}
-          raise_invalid_state_argument unless entry.is_a?(Entry)
-          build_events(entry, options, base_options.merge(prior_options))
-        else
-          raise_invalid_state_argument
-        end
-      when Array then
-        options_or_success_key.each do |options|
-          each_base_options = base_options.merge(extract_common_options(options))
-          build_entry(entry, options, each_base_options)
-        end
-      else
-        raise_invalid_state_argument
-      end
-    end
-
-    def null_action_entry(entry, options, success_key = nil)
-      action = Action.new(self)
-      options = options.dup
-      entry.action = setup_action(action, options, success_key)
-      entry.options = options
-      entry
-    end
-
-    def build_action(entry, action_hash, options)
-      raise_invalid_state_argument unless action_hash.length == 1
-      options = options.dup
-      entry.action = setup_action(action_hash.keys.first, options, action_hash.values.first)
-      entry.options = options
-    end
-
-    def setup_action(action, options, success_key = nil)
-      action.success_key = success_key.to_sym if success_key
-      action.failure_key = options.delete(:failure)
-      action.lock = options.delete(:lock)
-      action.if = options.delete(:if)
-      action.unless = options.delete(:unless)
-      action
-    end
-
-
-    def build_events(entry, event_hash, options)
-      event_hash.each do |event, value|
-        build_entry(event, value, options)
-        entry.events << event
-      end
-    end
-
-    COMMON_OPTION_NAMES = [:lock, :if, :unless, :failure]
-
-    def extract_common_options(hash)
-      COMMON_OPTION_NAMES.inject({}) do |dest, name|
-        value = hash.delete(name)
-        dest[name] = value if value
-        dest
-      end
-    end
-
-    def raise_invalid_state_argument
-      raise ArgumentError, state_argument_pattern
-    end
-
-    def state_argument_pattern
-      descriptions = <<-"EOS"
-        state arguments pattern:
-          * state :<state_name>
-          * state :<state_name> => :<new_state_name>
-          * state :<state_name> => action(:<method_name>)
-          * state :<state_name> => { action(:<method_name>) => :<new_state_name>}
-          * state :<state_name> => { event(:<event_name1>) => :<new_state_name>, event(:<event_name2>) => :<new_state_name>}
-          * state :<state_name> => { event(:<event_name1>) => { action(:<method_name1>) => :<new_state_name>}, event(:<event_name2>) => {action(:<method_name1>) => :<new_state_name>} }
-        And you can append :lock, :if, :unless option in Hash
-      EOS
-      descriptions.split(/$/).map{|s| s.sub(/^\s{8}/, '')}.join("\n")
-    end
-    
-  end
-
-end

data/lib/state_flow/entry.rb

@@ -1,44 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'state_flow'
-module StateFlow
-
-  class Entry
-    include Action::Executable
-    attr_reader :flow, :key
-
-    def initialize(flow, key)
-      @flow = flow
-      @key = key.to_s.to_sym
-    end
-    
-    def events
-      @events ||= [];
-    end
-
-    def event_for(name)
-      events.detect{|event| event.name == name}
-    end
-
-    def process(&block)
-      value = flow.state_cd_by_key(key)
-      find_options = {
-        :order => "id asc",
-        :conditions => ["#{flow.attr_name} = ?", value]
-      }
-      find_options[:lock] = action.lock if action.lock
-      if record = flow.klass.find(:first, find_options)
-        action.process(record, &block) if action
-      end
-    end
-    
-    def inspect
-      result = "<#{self.class.name} @key=#{@key.inspect}"
-      result << " @action=#{@action.inspect}" if @action
-      if @events && !@events.empty?
-        result << " @events=#{@events.sort_by{|event|event.name.to_s}.inspect}"
-      end
-      result << ">"
-    end
-  end
-
-end

data/lib/state_flow/named_action.rb

@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'state_flow'
-module StateFlow
-
-  class NamedAction < Action
-    attr_reader :name
-    def initialize(flow, name)
-      super(flow)
-      @name = name.to_s.to_sym
-    end
-
-    def proceed
-      flow.process_with_log(self.record, success_key, failure_key) do
-        self.record.send(name)
-      end
-    end
-  end
-
-end