call_center 0.0.7 → 0.0.8

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/call_center.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{call_center}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Henry Hsu"]
@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
     "init.rb",
     "lib/call_center.rb",
     "lib/call_center/core_ext/object_instance_exec.rb",
+    "lib/call_center/deferred_callbacks.rb",
     "lib/call_center/flow_callback.rb",
     "lib/call_center/state_machine_ext.rb",
     "lib/call_center/test/dsl.rb",

data/lib/call_center.rb

@@ -2,6 +2,7 @@ require 'call_center/core_ext/object_instance_exec'
 require 'state_machine'
 require 'call_center/state_machine_ext'
 require 'call_center/flow_callback'
+require 'call_center/deferred_callbacks'
 
 module CallCenter
   def self.included(base)
@@ -75,6 +76,10 @@ module CallCenter
       self.class.state_machines[state_machine_name]
     end
 
+    def call_flow_state_machine_name
+      self.class.call_flow_state_machine_name
+    end
+
     def current_state(state_machine_name)
       send(state_machine_name).to_sym
     end

data/lib/call_center/deferred_callbacks.rb

@@ -0,0 +1,37 @@
+module CallCenter
+  module DeferredCallbacks
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :call_flow_dfd_callbacks
+
+        def call_flow_callbacks_deferred?
+          true
+        end
+
+        def call_flow_defer_callback(callback, transition)
+          @call_flow_dfd_callbacks ||= {}
+          @call_flow_dfd_callbacks[call_flow_state_machine_name] ||= {}
+          @call_flow_dfd_callbacks[call_flow_state_machine_name][:before_transition] ||= []
+          @call_flow_dfd_callbacks[call_flow_state_machine_name][:after_transition] ||= []
+          @call_flow_dfd_callbacks[call_flow_state_machine_name][:after_failure] ||= []
+
+
+          @call_flow_dfd_callbacks[call_flow_state_machine_name][:before_transition] << [callback, transition] if callback.before
+          @call_flow_dfd_callbacks[call_flow_state_machine_name][:after_transition] << [callback, transition] if callback.after && callback.success
+          @call_flow_dfd_callbacks[call_flow_state_machine_name][:after_failure] << [callback, transition] if callback.after && callback.failure
+        end
+
+        def call_flow_run_deferred(group)
+          return unless all_callbacks = @call_flow_dfd_callbacks
+          return unless callbacks_groups = @call_flow_dfd_callbacks[call_flow_state_machine_name]
+          return unless callbacks = callbacks_groups[group]
+          callbacks.each do |set|
+            callback, transition = set
+            callback.run(self, transition)
+          end
+          callbacks_groups[group] = []
+        end
+      end
+    end
+  end
+end

data/lib/call_center/flow_callback.rb

@@ -24,10 +24,17 @@ module CallCenter
       flow.instance_exec(transition, &block) if should_run?
     end
 
+    def run_deferred?(call, transition)
+      if call.respond_to?(:call_flow_callbacks_deferred?) && call.call_flow_callbacks_deferred?
+        call.call_flow_defer_callback(self, transition)
+        true
+      end
+    end
+
     def setup(context)
       callback = self
       context.send(transition_hook, transition_parameters(context)) do |call, transition|
-        callback.run(call, transition)
+        callback.run(call, transition) unless callback.run_deferred?(call, transition)
       end
     end
 

data/lib/call_center/state_machine_ext.rb

@@ -48,7 +48,7 @@ class StateMachine::Machine
     event_names.each do |event_name|
       after_failure :on => event_name do |call, transition|
         callbacks = @callback_blocks.select { |callback| callback.after && callback.state_name == transition.to_name && callback.failure } || []
-        callbacks.each { |callback| callback.run(call, transition) }
+        callbacks.each { |callback| callback.run(call, transition) unless callback.run_deferred?(call, transition) }
       end
     end
   end

data/lib/call_center/test/dsl.rb

@@ -31,6 +31,11 @@ module CallCenter
               @call.send(:"#{state_field}=", from.to_s)
               @call.send(:"#{event}")
               assert_equal to, @call.send(:"#{state_field}_name"), "status should be :#{to}, not :#{@call.send(state_field)}"
+              if @call.respond_to?(:call_flow_run_deferred)
+                @call.call_flow_run_deferred(:before_transition)
+                @call.call_flow_run_deferred(:after_transition)
+                @call.call_flow_run_deferred(:after_failure)
+              end
             end
 
             if block.present?
@@ -40,6 +45,11 @@ module CallCenter
                   @call.send(:"#{state_field}=", from.to_s)
                   @call.send(:"#{event}")
                   body(@call.render) if @call.respond_to?(:render)
+                  if @call.respond_to?(:call_flow_run_deferred)
+                    @call.call_flow_run_deferred(:before_transition)
+                    @call.call_flow_run_deferred(:after_transition)
+                    @call.call_flow_run_deferred(:after_failure)
+                  end
                 end
 
                 self.instance_eval(&block)

data/lib/call_center/test/minitest/dsl.rb

@@ -130,6 +130,11 @@ module CallCenter
               subject.send(:"#{state_field}=", from)
               subject.send(:"#{event}!")
               subject.send(state_field).must_equal(to)
+              if subject.respond_to?(:call_flow_run_deferred)
+                subject.call_flow_run_deferred(:before_transition)
+                subject.call_flow_run_deferred(:after_transition)
+                subject.call_flow_run_deferred(:after_failure)
+              end
             end
           end
 

data/test/call_center_test.rb

@@ -166,6 +166,54 @@ class CallCenterTest < Test::Unit::TestCase
       @call.customer_end!
     end
 
+    should "defer callbacks" do
+      (class << @call; self; end).class_eval do
+        include CallCenter::DeferredCallbacks
+      end
+      @call.state = 'cancelled'
+
+      @call.expects(:notify).with(:before_always).never
+      @call.expects(:notify).with(:before_always_uniq).never
+
+      @call.expects(:notify).with(:after_always).never
+      @call.expects(:notify).with(:after_success).never
+      @call.expects(:notify).with(:after_failure).never
+
+      @call.expects(:notify).with(:after_always_uniq).never
+      @call.expects(:notify).with(:after_success_uniq, anything).never
+
+      @call.customer_end!
+      assert(!@call.customer_hangs_up)
+
+      # Ready for deferred callbacks
+
+      seq = sequence('callback_sequence')
+
+      @call.expects(:notify).with(:before_always)
+      @call.expects(:notify).with(:before_always_uniq)
+
+      @call.call_flow_run_deferred(:before_transition)
+
+      @call.expects(:notify).with(:after_always).times(2)
+      @call.expects(:notify).with(:after_success)
+
+      @call.expects(:notify).with(:after_always_uniq)
+      @call.expects(:notify).with(:after_success_uniq, anything)
+
+      @call.call_flow_run_deferred(:after_transition)
+
+      @call.expects(:notify).with(:after_always).times(2)
+      @call.expects(:notify).with(:after_failure)
+      @call.expects(:notify).with(:after_always_uniq)
+
+      @call.call_flow_run_deferred(:after_failure)
+
+      # Empty
+      @call.call_flow_run_deferred(:before_transition)
+      @call.call_flow_run_deferred(:after_transition)
+      @call.call_flow_run_deferred(:after_failure)
+    end
+
     should "asynchronously perform event" do
       @call.stubs(:agents_available?).returns(true)
       @call.incoming_call!
@@ -228,6 +276,48 @@ class CallCenterTest < Test::Unit::TestCase
         end
       end
     end
+
+    context "deferred and using test DSL:" do
+      setup do
+        (class << @call; self; end).class_eval do
+          include CallCenter::DeferredCallbacks
+        end
+      end
+
+      should_flow :on => :incoming_call, :initial => :voicemail, :when => Proc.new {
+        @call.stubs(:agents_available?).returns(false)
+        @call.stubs(:notify)
+        @call.stubs(:customer).returns('the_flow')
+      } do
+        should_also { assert_received(@call, :notify) { |e| e.with(:rendering_voicemail) } }
+        and_also { assert_received(@call, :customer) { |e| e.with(:voicemail_complete) } }
+        and_render { "Response>Say" }
+        and_render { "Response>Record[action=the_flow]" }
+      end
+
+      should_flow :on => :incoming_call, :initial => :routing, :when => Proc.new {
+        @call.stubs(:agents_available?).returns(true)
+      } do
+        should_render { "Response" }
+      end
+
+      should_flow :on => :customer_hangs_up, :routing => :cancelled, :when => Proc.new {
+        @call.stubs(:notify)
+      } do
+        should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } }
+        and_also { assert @call.cancelled? }
+
+        should_flow :on => :customer_hangs_up, :cancelled => :cancelled do
+          should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } } # For above
+          and_also { assert @call.cancelled? }
+
+          should_flow :on => :customer_hangs_up, :cancelled => :cancelled do
+            should_also { assert_received(@call, :notify) { |e| e.with(:cancelled).once } } # For above
+            and_also { assert @call.cancelled? }
+          end
+        end
+      end
+    end
   end
 
   context "non-standard call" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: call_center
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Henry Hsu
@@ -276,6 +276,7 @@ files:
 - init.rb
 - lib/call_center.rb
 - lib/call_center/core_ext/object_instance_exec.rb
+- lib/call_center/deferred_callbacks.rb
 - lib/call_center/flow_callback.rb
 - lib/call_center/state_machine_ext.rb
 - lib/call_center/test/dsl.rb