call_center 0.0.3 → 0.0.4

data/README.md

@@ -9,58 +9,64 @@ Call Center streamlines the process of defining multi-party call workflows in yo
 
 [Twilio](http://www.twilio.com/docs) provides a two-part API for managing phone calls, and is mostly driven by callbacks. Call Center DRYs up the application logic dealing with a callback driven API so you can focus on the business logic of your call center.
 
-### Not DRY
-Twilio requests your application to return [TwiML](http://www.twilio.com/docs/api/twiml/) that describes the call workflow. TwiML contains commands which Twilio then executes. It is essentially an application-to-application API, synonymous to making a REST call.
-
-In the context of "[Skinny Controller, Fat Model](http://weblog.jamisbuck.org/2006/10/18/skinny-controller-fat-model)", outgoing REST calls for the function of business logic are not a view concern but a model concern. Therefore, so is TwiML.
-
-Twilio supports callbacks URLs and redirects to URLs that also render TwiML as a method of modifying live calls. Incoming callbacks are handled by the controller first, but the response is still a model concern.
-
-Terminology
------------
-
-* **Call** - An application resource of yours that encapsulates a phone call. Phone calls are then acted on: answered, transferred, declined, etc.
-* **Event** - Is something that happens outside or inside your application in relation to a **Call**. Someone picks up, hangs up, presses a button, etc. But overall, it's anything that can be triggered by Twilio callbacks.
-* **State** - Is the status a **Call** is in which is descriptive of what's happened so far and what are the next things that should happen. (e.g. a call on hold is waiting for the agent to return)
-* **CallFlow** - Is a definition of the process a **Call** goes through. **Events** drive the flow between **States**. (e.g. a simple workflow is when noone answers the call, send the call to voicemail)
-* **Render** - Is the ability of the **CallFlow** to return TwiML to bring the call into the **State** or modify the live call through a **Redirect**.
-* **Redirect** - Is a way of modifying a live call outside of a TwiML response (e.g. background jobs)
-
 Usage
 -----
 
     class Call
       include CallCenter
 
-      call_flow :state, :intial => :answered do
-        state :answered do
-          event :incoming_call, :to => :voicemail, :if => :not_during_business_hours?
-          event :incoming_call, :to => :sales
+      call_flow :state, :intial => :incoming do
+        actor :customer do |call, event|
+          "/voice/calls/flow?event=#{event}&actor=customer&call_id=#{call.id}"
         end
 
-        state :voicemail do
-          event :customer_hangs_up, :to => :voicemail_completed
+        state :incoming do
+          response do |x|
+            x.Gather :numDigits => '1', :action => customer(:wants_voicemail) do
+              x.Say "Hello World"
+              x.Play some_nice_music, :loop => 100
+            end
+            # <?xml version="1.0" encoding="UTF-8" ?>
+            # <Response>
+            #   <Gather numDigits="1" action="/voice/calls/flow?event=wants_voicemail&actor=customer&call_id=5000">
+            #     <Say>Hello World</Say>
+            #     <Play loop="100">http://some.nice.music.com/1.mp3</Play>
+            #   </Gather>
+            # </Response>
+          end
+
+          event :called, :to => :routing, :if => :agents_available?
+          event :called, :to => :voicemail
+          event :wants_voicemail, :to => :voicemail
+          event :customer_hangs_up, :to => :cancelled
         end
 
-        on_render(:sales) do |call, x|
-          x.Say "This is Sales!"
+        state :voicemail do
+          response do |x|
+            x.Say "Please leave a message"
+            x.Record(:action => customer(:voicemail_complete))
+            # <?xml version="1.0" encoding="UTF-8" ?>
+            # <Response>
+            #   <Say>Please leave a message</Say>
+            #   <Record action="/voice/calls/flow?event=voicemail_complete&actor=customer&call_id=5000"/>
+            # </Response>
+          end
+
+          event :voicemail_complete, :to => :voicemail_completed
+          event :customer_hangs_up, :to => :cancelled
         end
 
-        on_render(:voicemail) do |call, x|
-          x.Say "Leave a voicemail!"
-        end
+        state :routing do
 
-        on_flow_to(:voicemail) do |call, transition|
-          call.notify(:voicemail)
         end
       end
     end
 
 Benefits of **CallCenter** is that it's backed by [state_machine](https://github.com/pluginaweek/state_machine). Which means you can interact with events the same you do in `state_machine`.
 
-    @call.incoming_call!
-    @call.voicemail?
-    @call.sales?
+    @call.called!
+    @call.wants_voicemail!
+    @call.routing?
     @call.render # See Rendering
 
 Flow
@@ -96,63 +102,69 @@ Rendering
 
 Rendering is your way of interacting with Twilio. Thus, it provides two facilities: access to an XML builder and access to your call.
 
-    on_render(:sales) do |the_call, xml_builder|
-      xml_builder.Say "This is Sales!"
-
-      the_call.flag! # You can access the call explicitly
-      flag!          # Or access it implicitly
+    state :sales do
+      response do |xml_builder, the_call|
+        xml_builder.Say "This is #{the_call.agent.name}!" # Or agent.name, you can access he call implicitly
+      end
     end
 
 Renders with `@call.render` if the current state is :sales:
 
     <?xml version="1.0" encoding="UTF-8"?>
     <Response>
-      <Say>This is Sales!</Say>
+      <Say>This is Henry!</Say>
     </Response>
 
 Callbacks
 ---------
 
-If you ever want to do something special after entering a state, but only if it's a new transition (e.g. NOT from :voicemail => :voicemail), you can do this:
+You have control over what you want to happen before/after state transitions:
 
-    on_flow_to(:voicemail) do |the_call, the_transition|
-      the_call.notify(transition.event) # Explicitly
-      notify(transition.event) # Implicitly
-    end
+    state :voicemail do
+      before(:always) { # Invokes before any transition }
+      before(:always, :uniq => true) { # Invokes before transitions to a different state }
 
-Redirects
----------
+      after(:always) { # Invokes after any transition }
+      after(:success) { # Invokes after any successful transition }
+      after(:failure) { # Invokes after any failed transition (those not covered in your call flow) }
 
-Redirects are a request made to the [Twilio REST API](http://www.twilio.com/docs/api/rest/) that points to a callback URL which returns TwiML to be executed on a call. It is up to you how you want to perform this (e.g. with your favority http libraries, or with [Twilio Libraries](http://www.twilio.com/docs/libraries/)).
+      after(:always, :uniq => true) { # Invokes after any transition to a different state }
+      after(:success, :uniq => true) { # Successful unique transitions }
+      after(:failure, :uniq => true) { # Failed unique transitions }
+    end
 
-Redirect to events look like this:
+For example,
 
-    ...
-    call_flow :state, :intial => :answered do
-      state :answered do
-        ...
-      end
+    state :voicemail do
+      before(:always) { log_start_event }
 
-      state :ending_call do
-        event :end_call, :to => :ended_call
-      end
+      after(:always) { log_end_event }
+      after(:failure) { notify_airbrake }
 
-      on_render(:ending_call) do
-        redirect_and_end_call!(:status => 'completed')
-      end
+      after(:success, :uniq => true) { notify_browser }
+      after(:failure, :uniq => true) { notify_cleanup_browser }
     end
-    ...
 
-For your **Call** to support this syntax, it must adhere to the following API:
+Motivation
+----------
 
-    class Call
-      def redirect_to(event, *args)
-        # where:
-        #   event #=> :end_call
-        #   args  #=> [:status => 'completed]
-        @account.calls.get(self.sid).update({:url => "http://myapp.com/call_flow?event=#{event}"})
-      end
-    end
+### Not DRY
+Twilio requests your application to return [TwiML](http://www.twilio.com/docs/api/twiml/) that describes the call workflow. TwiML contains commands which Twilio then executes. It is essentially an application-to-application API, synonymous to making a REST call.
+
+In the context of "[Skinny Controller, Fat Model](http://weblog.jamisbuck.org/2006/10/18/skinny-controller-fat-model)", outgoing REST calls for the function of business logic are not a view concern but a model concern. Therefore, so is TwiML.
+
+Twilio supports callbacks URLs and redirects to URLs that also render TwiML as a method of modifying live calls. Incoming callbacks are handled by the controller first, but the response is still a model concern.
+
+
+Terminology
+-----------
+
+* **Call** - An application resource of yours that encapsulates a phone call. Phone calls are then acted on: answered, transferred, declined, etc.
+* **Event** - Is something that happens outside or inside your application in relation to a **Call**. Someone picks up, hangs up, presses a button, etc. But overall, it's anything that can be triggered by Twilio callbacks.
+* **State** - Is the status a **Call** is in which is descriptive of what's happened so far and what are the next things that should happen. (e.g. a call on hold is waiting for the agent to return)
+* **CallFlow** - Is a definition of the process a **Call** goes through. **Events** drive the flow between **States**. (e.g. a simple workflow is when noone answers the call, send the call to voicemail)
+* **Render** - Is the ability of the **CallFlow** to return TwiML to bring the call into the **State** or modify the live call through a **Redirect**.
+* **Redirect** - Is a way of modifying a live call outside of a TwiML response (e.g. background jobs)
 
 Tools
 -----

data/Rakefile

@@ -37,7 +37,7 @@ Rcov::RcovTask.new do |test|
   test.libs << 'test'
   test.pattern = 'test/**/*_test.rb'
   test.verbose = true
-  test.rcov_opts << '--exclude "gems/*"'
+  test.rcov_opts << '--exclude "gems/*,lib/call_center/core_ext/object_instance_exec.rb"'
 end
 
 task :default => :test

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/call_center.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{call_center}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Henry Hsu"]
-  s.date = %q{2011-09-29}
+  s.date = %q{2011-10-23}
   s.description = %q{Support for describing call center workflows}
   s.email = %q{hhsu@zendesk.com}
   s.extra_rdoc_files = [
@@ -30,6 +30,7 @@ Gem::Specification.new do |s|
     "init.rb",
     "lib/call_center.rb",
     "lib/call_center/core_ext/object_instance_exec.rb",
+    "lib/call_center/flow_callback.rb",
     "lib/call_center/state_machine_ext.rb",
     "lib/call_center/test/dsl.rb",
     "test/call_center_test.rb",

data/lib/call_center.rb

@@ -1,6 +1,7 @@
 require 'call_center/core_ext/object_instance_exec'
 require 'state_machine'
 require 'call_center/state_machine_ext'
+require 'call_center/flow_callback'
 
 module CallCenter
   def self.included(base)
@@ -21,6 +22,15 @@ module CallCenter
     self.cached_state_machines["#{klass.name}_#{state_machine_name}"]
   end
 
+  def self.render_twiml
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xml.Response do
+      yield(xml)
+    end
+    xml.target!
+  end
+
   module ClassMethods
     attr_accessor :call_flow_state_machine_name
 
@@ -32,12 +42,7 @@ module CallCenter
       if state_machine = CallCenter.cached(self, state_machine_name)
         state_machine = state_machine.duplicate_to(self)
       else
-        state_machine = state_machine(*args, &blk)
-        state_machine.instance_eval do
-          after_transition any => any do |call, transition|
-            call.flow_to(transition) if transition.from_name != transition.to_name
-          end
-        end
+        state_machine = state_machine(*args, &blk).setup_call_flow(self)
         CallCenter.cache(self, state_machine)
       end
       self.call_flow_state_machine_name ||= state_machine.name
@@ -50,40 +55,27 @@ module CallCenter
   end
 
   module InstanceMethods
-    def render(state_machine_name = self.class.call_flow_state_machine_name)
-      xml = Builder::XmlMarkup.new
-      render_block = current_block_accessor(:render_blocks, state_machine_name)
-
-      xml.instruct!
-      xml.Response do
-        self.instance_exec(self, xml, &render_block) if render_block
+    def render(name = nil)
+      name ||= self.class.call_flow_state_machine_name
+      return unless name
+      CallCenter.render_twiml do |xml|
+        if render_block = state_machine_for_name(name).block_accessor(:response_blocks, current_state(name))
+          render_block.arity == 2 ? self.instance_exec(xml, self, &render_block) : self.instance_exec(xml, &render_block)
+        end
       end
-      xml.target!
-    end
-
-    def flow_to(transition, state_machine_name = self.class.call_flow_state_machine_name)
-      block = current_block_accessor(:flow_to_blocks, state_machine_name)
-      self.instance_exec(self, transition, &block) if block
     end
 
     def draw_call_flow(*args)
-      current_state_machine.draw(*args)
+      self.class.current_state_machine.draw(*args)
     end
 
     private
 
-    def current_block_accessor(accessor, state_machine_name)
-      csm = self.class.state_machines[state_machine_name]
-      return unless csm.respond_to?(accessor)
-      blocks, name = csm.send(accessor), csm.name
-      blocks[current_flow_state(state_machine_name)] if blocks
-    end
-
-    def current_state_machine
-      self.class.current_state_machine
+    def state_machine_for_name(state_machine_name)
+      self.class.state_machines[state_machine_name]
     end
 
-    def current_flow_state(state_machine_name)
+    def current_state(state_machine_name)
       send(state_machine_name).to_sym
     end
 

data/lib/call_center/flow_callback.rb

@@ -0,0 +1,69 @@
+module CallCenter
+  class FlowCallback
+    attr_reader :state_name, :scope, :block
+
+    def self.create(state_name, scope, options, block)
+      case scope
+      when :success
+        FlowCallback.new(state_name, scope, options, block).extend(SuccessFlowCallback)
+      when :failure
+        FlowCallback.new(state_name, scope, options, block).extend(FailureFlowCallback)
+      else
+        FlowCallback.new(state_name, scope, options, block).extend(AlwaysFlowCallback)
+      end
+    end
+
+    def initialize(state_name, scope, options, block)
+      raise "Invalid scope: #{scope} for flow callback" unless [:always, :success, :failure].include?(scope)
+      @state_name, @scope, @block = state_name, scope, block
+      extend(UniqueFlowCallback) if options[:uniq]
+    end
+
+    def run(flow, transition)
+      @transition = transition
+      flow.instance_exec(transition, &block) if should_run?
+    end
+
+    def setup(context)
+      callback = self
+      context.before_transition(transition_parameters(context)) do |call, transition|
+        callback.run(call, transition)
+      end
+    end
+
+    private
+
+    def transition_parameters(context)
+      { context.any => @state_name }
+    end
+
+    def should_run?
+      true
+    end
+  end
+
+  module AlwaysFlowCallback
+    def success; true; end
+    def failure; true; end
+  end
+
+  module SuccessFlowCallback
+    def success; true; end
+    def failure; false; end
+  end
+
+  module FailureFlowCallback
+    def success; false; end
+    def failure; true; end
+  end
+
+  module UniqueFlowCallback
+    def should_run?
+      !@transition.loopback?
+    end
+
+    def transition_parameters(context)
+      { context.any - @state_name => @state_name }
+    end
+  end
+end

data/lib/call_center/state_machine_ext.rb

@@ -1,26 +1,98 @@
 # Extension for StateMachine::Machine to store and provide render blocks
 class StateMachine::Machine
-  attr_accessor :render_blocks
-  attr_accessor :flow_to_blocks
+  attr_accessor :response_blocks
+  attr_accessor :before_blocks
+  attr_accessor :after_blocks
+  attr_accessor :flow_actor_blocks
 
-  def on_render(state_name, &blk)
-    @render_blocks ||= {}
-    @render_blocks[state_name] = blk
+  def response(state_name, &blk)
+    @response_blocks ||= {}
+    @response_blocks[state_name] = blk
   end
 
-  def on_flow_to(state_name, &blk)
-    @flow_to_blocks ||= {}
-    @flow_to_blocks[state_name] = blk
+  def before(state_name, scope, options, &blk)
+    @before_blocks ||= []
+    @before_blocks << CallCenter::FlowCallback.create(state_name, :always, options, blk)
+  end
+
+  def after(state_name, scope, options, &blk)
+    @after_blocks ||= []
+    @after_blocks << CallCenter::FlowCallback.create(state_name, scope, options, blk)
+  end
+
+  def block_accessor(accessor, for_state)
+    return unless respond_to?(accessor)
+    blocks = send(accessor)
+    blocks[for_state] if blocks
+  end
+
+  def flow_actors(name, &blk)
+    @flow_actor_blocks ||= {}
+    @flow_actor_blocks[name] = blk
+  end
+
+  def setup_call_flow(flow)
+    setup_before_blocks
+    setup_after_blocks
+    setup_flow_actor_blocks(flow)
+    self
+  end
+
+  def setup_before_blocks
+    return unless @before_blocks
+    @before_blocks.each { |callback| callback.setup(self) }
+  end
+
+  def setup_after_blocks
+    return unless @after_blocks
+    @after_blocks.select(&:success).each { |callback| callback.setup(self) }
+
+    event_names = events.map(&:name)
+    event_names.each do |event_name|
+      after_failure :on => event_name do |call, transition|
+        callbacks = @after_blocks.select { |callback| callback.state_name == transition.to_name && callback.failure } || []
+        callbacks.each { |callback| callback.run(call, transition) }
+      end
+    end
+  end
+
+  def setup_flow_actor_blocks(flow_class)
+    return unless @flow_actor_blocks
+    @flow_actor_blocks.each do |actor, block|
+      flow_class.send(:define_method, actor) do |event|
+        self.instance_exec(self, event, &block) if block
+      end
+    end
   end
 end
 
 # Extension for StateMachine::AlternateMachine to provide render blocks inside a state definition
 class StateMachine::AlternateMachine
-  def on_render(state_name = nil, &blk)
+  def response(state_name = nil, &blk)
     if @from_state
-      @queued_sends << [[:on_render, @from_state], blk]
+      @queued_sends << [[:response, @from_state], blk]
     else
-      @queued_sends << [[:on_render, state_name], blk]
+      @queued_sends << [[:response, state_name], blk]
+    end
+  end
+
+  def before(scope, options = {}, &blk)
+    if @from_state
+      @queued_sends << [[:before, @from_state, scope, options], blk]
+    end
+  end
+
+  def after(scope, options = {}, &blk)
+    if @from_state
+      @queued_sends << [[:after, @from_state, scope, options], blk]
+    end
+  end
+
+  def actor(name, &blk)
+    (class << self; self; end).send(:define_method, name.to_sym) do |event_name, options|
+      event_name = :"#{name}_#{event_name}"
+      event(event_name, options)
     end
+    @queued_sends << [[:flow_actors, name], blk]
   end
 end

data/test/call_center_test.rb

@@ -16,7 +16,6 @@ class CallCenterTest < Test::Unit::TestCase
         klass = call_type.to_s.gsub('_', ' ').titleize.gsub(' ', '').constantize
         @call = klass.new
         @call.stubs(:notify)
-        @call.stubs(:flow_url).returns('the_flow')
       end
 
       context "agents available" do
@@ -99,21 +98,28 @@ class CallCenterTest < Test::Unit::TestCase
       @call = Call.new
     end
 
-    should  "render xml for initial state" do
+    should "render xml for initial state" do
       @call.expects(:notify).with(:rendering_initial)
       body @call.render
       assert_select "Response>Say", "Hello World"
     end
 
-    should  "render xml for voicemail state" do
+    should "return customer url for event" do
+      assert_equal("/voice/calls/flow?event=voicemail_complete&actor=customer", @call.customer(:voicemail_complete))
+    end
+
+    should "return agent url for event" do
+      assert_equal("/voice/calls/flow?event=voicemail_complete&actor=agent", @call.agent(:voicemail_complete))
+    end
+
+    should "render xml for voicemail state" do
       @call.stubs(:agents_available?).returns(false)
       @call.incoming_call!
       @call.expects(:notify).with(:rendering_voicemail)
-      @call.expects(:flow_url).with(:voicemail_complete).returns('the_flow')
 
       body @call.render
       assert_select "Response>Say"
-      assert_select "Response>Record[action=the_flow]"
+      assert_select "Response>Record[action=/voice/calls/flow?event=voicemail_complete&actor=customer]"
     end
 
     should "render noop when no render block" do
@@ -124,15 +130,24 @@ class CallCenterTest < Test::Unit::TestCase
       assert_select "Response"
     end
 
-    should "respond when flow to state (once)" do
-      @call.state = 'routing'
-      @call.expects(:notify).with(:cancelled).once
-      @call.customer_hangs_up!
-      assert @call.cancelled?
-      @call.customer_hangs_up!
-      assert @call.cancelled?
-      @call.customer_hangs_up!
-      assert @call.cancelled?
+    should "execute before callbacks" do
+      @call.state = 'cancelled'
+
+      @call.expects(:notify).with(:before_always).times(3)
+      @call.expects(:notify).with(:before_always_uniq).times(1)
+
+      @call.expects(:notify).with(:after_always).times(4)
+      @call.expects(:notify).with(:after_success).times(3)
+      @call.expects(:notify).with(:after_failure).times(1)
+
+      @call.expects(:notify).with(:after_always_uniq).times(1)
+      @call.expects(:notify).with { |notification, transition| notification == :after_success_uniq && transition.kind_of?(StateMachine::Transition) }.times(1)
+      @call.expects(:notify).with(:after_failure_uniq).times(0)
+
+      @call.customer_end!
+      @call.customer_end!
+      @call.customer_end!
+      assert(!@call.customer_hangs_up)
     end
 
     should "asynchronously perform event" do
@@ -166,10 +181,10 @@ class CallCenterTest < Test::Unit::TestCase
       should_flow :on => :incoming_call, :initial => :voicemail, :when => Proc.new {
         @call.stubs(:agents_available?).returns(false)
         @call.stubs(:notify)
-        @call.stubs(:flow_url).returns('the_flow')
+        @call.stubs(:customer).returns('the_flow')
       } do
         should_also { assert_received(@call, :notify) { |e| e.with(:rendering_voicemail) } }
-        and_also { assert_received(@call, :flow_url) { |e| e.with(:voicemail_complete) } }
+        and_also { assert_received(@call, :customer) { |e| e.with(:voicemail_complete) } }
         and_render { "Response>Say" }
         and_render { "Response>Record[action=the_flow]" }
       end

data/test/examples/call.rb

@@ -3,44 +3,63 @@ class Call
   include CommonCallMethods
 
   call_flow :state, :initial => :initial do
+    actor :customer do |call, event|
+      "/voice/calls/flow?event=#{event}&actor=customer"
+    end
+    actor :agent do |call, event|
+      "/voice/calls/flow?event=#{event}&actor=agent"
+    end
+
     state :initial do
+      response do |x, call| # To allow defining render blocks within a state
+        call.notify(:rendering_initial)
+        x.Say "Hello World"
+      end
+
       event :incoming_call, :to => :voicemail, :unless => :agents_available?
       event :incoming_call, :to => :routing, :if => :agents_available?
       event :something_crazy_happens, :to => :uh_oh
     end
 
     state :voicemail do
-      event :customer_hangs_up, :to => :voicemail_completed
+      response do |x| # To allow defining render blocks outside a state
+        notify(:rendering_voicemail)
+        x.Say "Hello World"
+        x.Record :action => customer(:voicemail_complete)
+      end
+
+      customer :hangs_up, :to => :voicemail_completed
     end
 
     state :routing do
-      event :customer_hangs_up, :to => :cancelled
+      customer :hangs_up, :to => :cancelled
       event :start_conference, :to => :in_conference
     end
 
     state :cancelled do
-      event :customer_hangs_up, :to => same
-    end
-
-    # =================
-    # = Render Blocks =
-    # =================
+      after(:success, :uniq => true) { notify(:cancelled) }
 
-    state :initial do
-      on_render do |call, x| # To allow defining render blocks within a state
-        call.notify(:rendering_initial)
-        x.Say "Hello World"
-      end
+      customer :hangs_up, :to => same
+      customer :end, :to => :ended
     end
 
-    on_render(:voicemail) do |call, x| # To allow defining render blocks outside a state
-      notify(:rendering_voicemail)
-      x.Say "Hello World"
-      x.Record :action => flow_url(:voicemail_complete)
+    response(:cancelled) do |x, call|
+      # Just for sake of comparison
     end
 
-    on_flow_to(:cancelled) do |call, transition|
-      notify(:cancelled)
+    state :ended do
+      after(:always) { notify(:after_always) }
+      after(:success) { notify(:after_success) }
+      after(:failure) { notify(:after_failure) }
+
+      after(:always, :uniq => true) { notify(:after_always_uniq) }
+      after(:success, :uniq => true) { |transition| notify(:after_success_uniq, transition) }
+      after(:failure, :uniq => true) { notify(:after_failure_uniq) }
+
+      before(:always) { notify(:before_always) }
+      before(:always, :uniq => true) { notify(:before_always_uniq) }
+
+      customer :end, :to => same
     end
   end
 end

data/test/examples/multiple_flow_call.rb

@@ -4,7 +4,7 @@ class MultipleFlowCall
   call_flow :status, :initial => :ready do
     state :ready do
       event :go, :to => :done
-      on_render do |call, x|
+      response do |x|
         x.Say "Hello World"
       end
     end
@@ -13,7 +13,7 @@ class MultipleFlowCall
   call_flow :outgoing_status, :initial => :outgoing_ready do
     state :outgoing_ready do
       event :outgoing_go, :to => :outgoing_done
-      on_render do |call, x|
+      response do |x|
         x.Say "Hello Outgoing World"
       end
     end

data/test/examples/non_standard_call.rb

@@ -4,7 +4,7 @@ class NonStandardCall
   call_flow :status, :initial => :ready do
     state :ready do
       event :go, :to => :done
-      on_render do |call, x|
+      response do |x|
         x.Say "Hello World"
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: call_center
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Henry Hsu
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-29 00:00:00 -07:00
+date: 2011-10-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -231,6 +231,7 @@ files:
 - init.rb
 - lib/call_center.rb
 - lib/call_center/core_ext/object_instance_exec.rb
+- lib/call_center/flow_callback.rb
 - lib/call_center/state_machine_ext.rb
 - lib/call_center/test/dsl.rb
 - test/call_center_test.rb