larynx 0.1.2 → 0.1.3

data/README.rdoc

@@ -104,7 +104,7 @@ A more sophisticated example using the Form class
 
   Larynx.answer {|call| Guess.run(call) }
 
-The Form class wraps up many handy conventions into a pleasant DSL in which allows you to control the user
+The Form class wraps up many handy conventions into a pleasant DSL in which allows you to control the caller
 interaction more easily.
 
 Save your app into file and run larynx comand to start the app server ready to receive calls.
@@ -167,10 +167,6 @@ The class method initialises some things for you and then calls <tt>run</tt> on
 there its up to you. You can use all the commands directly rather than call them on the call
 instance.
 
-== Form Class
-
-
-
 == Event Hooks
 
 The Application and Form classes have a couple of useful event hook methods available which are
@@ -180,7 +176,7 @@ The Application and Form classes have a couple of useful event hook methods avai
     end
 
     def dtmf_received(input)
-      # input is the button the user just pushed
+      # input is the button the caller just pushed
     end
 
     def hungup
@@ -188,4 +184,62 @@ The Application and Form classes have a couple of useful event hook methods avai
     end
   end
 
+== Form Class
+
+The Form class is a sublcass of the Application class with some added goodness. You can use the field
+DSL to abstract away a lot of the reptitive work and more difficult asynchronous stuff you would have
+to handle yourself.
+
+When collection input from the caller you are usually needing to do one or more of a few things.
+
+These are:
+1. Set-up something before the caller is prompted for the information.
+2. Repeat the prompt for input if the caller doesn't enter anything or does not enter enough digits.
+3. Validate the input for constraints beyond length such as a range or finding a matching database record.
+4. Perform some task, perhaps say something, if the input is invalid but before the prompt is repeated.
+5. Handle the next action if the input is valid
+6. Handle the next action if the caller fails enter valid input after a number of attempts.
+
+You define these tasks as callbacks for each type of action, be it setup, validate, invalid, success or failure.
+These callbacks are run in the scope of the form class instance each time so that they can access user
+defined methods or instance variables you need.
+
+Each field defined becomes an attribute on the form class instance which you can use at any time. The value
+is set to the caller input after each prompt, just use the field attribute method to retrieve it. A form may
+have as many fields defined you as need. Though the idea would be to group fields with a particular purpose
+together and define another form for unrelated fields.
+
+Lets look at a simple Form class with empty callbacks in place.
+
+  class MyApp < Larynx::Form
+    field(:my_field, :attempts => 3, :length => 1) do
+      prompt :speak => 'Please enter a value.'
+
+      setup do
+        # run once when the field is starts
+      end
+
+      validate do
+        # run when the input is of a valid length
+      end
+
+      invalid do
+        # run when the input is not a valid length or the validate block returns false
+      end
+
+      success do
+        # run when the input is a valid length the validate block, if defined, returns true
+      end
+
+      failure do
+        # run when the maximum attempts has been reached and valid input has not been entered
+      end
+    end
+  end
+
+This form will do the following when run:
+* Define a field attribute method called <tt>my_field</tt>
+* Atempt to obtain the field value up to 3 times if the caller fails to successfully enter it
+* Accept a single digit value as complete and valid intput
+
 

data/Rakefile

@@ -16,7 +16,7 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   s.extra_rdoc_files = ["README.rdoc"]
   s.executables = ["larynx"]
-  s.summary = ""
+  s.summary = "An evented application framework for the FreeSWITCH telephony platform"
   s.description = s.summary
   s.author = "Adam Meehan"
   s.email = "adam.meehan@gmail.com"

data/lib/larynx/call_handler.rb

@@ -8,23 +8,16 @@ module Larynx
     # EM hook which is run when call is received
     def post_init
       @queue, @input, @timers = [], [], {}
-      connect {
-        @session = Session.new(@response.header)
-        log "Call received from #{caller_id}"
-        Larynx.fire_callback(:connect, self)
-        start_session
-      }
+      connect { start_session }
       send_next_command
     end
 
     def start_session
-      myevents {
-				linger
-				answer {
-					log 'Answered call'
-					Larynx.fire_callback(:answer, self)
-				}
-      }
+      @session = Session.new(@response.header)
+      log "Call received from #{caller_id}"
+      myevents
+      linger
+      Larynx.fire_callback(:connect, self)
     end
 
     def called_number
@@ -58,33 +51,35 @@ module Larynx
       command
     end
 
-    def timer(name, timeout, &block)
+    def add_timer(name, timeout, &block)
       @timers[name] = [RestartableTimer.new(timeout) {
-        if timer = @timers.delete(name)
-          timer[1].call if timer[1]
-          notify_observers :timed_out
-          send_next_command if @state == :ready
-        else
-          puts name
-        end
+        timer = @timers.delete(name)
+        timer[1].call if timer[1]
+        notify_observers :timed_out
+        send_next_command if @state == :ready
       }, block]
     end
 
     def cancel_timer(name)
-      if timer = @timers.delete(name)
+      if timer = @timers[name]
         timer[0].cancel
+        @timers.delete(name)
         send_next_command if @state == :ready
       end
     end
 
     def cancel_all_timers
       @timers.values.each {|t| t[0].cancel }
+      @timers = {}
     end
 
     def stop_timer(name)
-      if timer = @timers.delete(name)
-        timer[0].cancel
-        timer[1].call if timer[1]
+      if timer = @timers[name]
+        # only run callback if it was actually cancelled (i.e. returns false)
+        if timer[0].cancel == false && timer[1]
+          timer[1].call
+        end
+        @timers.delete(name)
         send_next_command if @state == :ready
       end
     end
@@ -97,29 +92,37 @@ module Larynx
 
     def receive_request(header, content)
       @response = Response.new(header, content)
+      handle_request
+    end
 
+    def handle_request
       case
-      when @response.reply? && current_command && !current_command.is_a?(AppCommand)
+      when @response.reply? && current_command.is_a?(CallCommand)
         log "Completed: #{current_command.name}"
         finalize_command
         @state = :ready
         send_next_command
+      when @response.answered?
+        log 'Answered call'
+        finalize_command
+        @state = :ready
+        Larynx.fire_callback(:answer, self)
+        send_next_command
       when @response.executing?
         log "Executing: #{current_command.name}"
-        run_command_setup
+        current_command.setup
         @state = :executing
       when @response.executed? && current_command
         this_command = current_command
         finalize_command
         unless this_command.interrupted?
-          current_command.fire_callback(:after) if this_command.command == 'break'
+          current_command.finalize if this_command.command == 'break'
           @state = :ready
           send_next_command
         end
       when @response.dtmf?
         log "Button pressed: #{@response.body[:dtmf_digit]}"
         handle_dtmf
-      when @response.speech?
       when @response.disconnect?
         log "Disconnected."
         cleanup
@@ -143,13 +146,9 @@ module Larynx
       end
     end
 
-    def run_command_setup
-      current_command.fire_callback :before
-    end
-
     def finalize_command
       if command = @queue.shift
-        command.fire_callback(:after) unless command.interrupted?
+        command.finalize unless command.interrupted?
         @last_command = command
       end
     end

data/lib/larynx/callbacks_with_async.rb

@@ -0,0 +1,60 @@
+module Larynx
+  # Allows you to set the :async flag on the back to the callback in with
+  # EM.defer method. Its useful for long running tasks like database calls.
+  module CallbacksWithAsync
+    def self.included(base)
+      base.extend ClassMethods
+      base.cattr_accessor :callback_options
+      base.callback_options = {}
+      base.class_eval do
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+
+      def define_callback(*callbacks)
+        options = callbacks.extract_options!
+        callbacks.each do |callback|
+          self.callback_options[callback] = options
+          class_eval <<-DEF
+            def #{callback}(mode=:sync, &block)
+              @callbacks ||= {}
+              @callbacks[:#{callback}] = [block, mode]
+              self
+            end
+          DEF
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      def fire_callback(callback)
+        if @callbacks && @callbacks[callback]
+          block, mode = *@callbacks[callback]
+          scope = self.class.callback_options[callback][:scope]
+          if mode == :async
+            EM.defer(scope_callback(block, scope), lambda {|result| callback_complete(callback, result) })
+          else
+            callback_complete(callback, scope_callback(block, scope).call)
+          end
+        else
+          callback_complete(callback, nil)
+        end
+      end
+
+      # Scope takes the callback block and a method symbol which is used
+      # to return an object that scopes the block evaluation.
+      def scope_callback(block, scope=nil)
+        scope ? lambda { send(scope).instance_eval(&block) } : block
+      end
+
+      def callback_complete(callback, result)
+        # Override in class to handle post callback result
+      end
+    end
+  end
+
+end

data/lib/larynx/command.rb

@@ -26,6 +26,14 @@ module Larynx
     def interrupted?
       @interrupted
     end
+
+    def setup
+      fire_callback :before
+    end
+
+    def finalize
+      fire_callback :after
+    end
   end
 
   class CallCommand < Command

data/lib/larynx/fields.rb

@@ -5,15 +5,18 @@ module Larynx
 
     def self.included(base)
       base.extend ClassMethods
-      base.send :include, InstanceMethods
+      base.class_eval do
+        include InstanceMethods
+        class_inheritable_accessor :field_definitions
+        self.field_definitions = []
+        attr_accessor :fields
+      end
     end
 
     module ClassMethods
-      attr_accessor :fields
 
       def field(name, options={}, &block)
-        @fields ||= []
-        @fields << Field.new(name, options, &block)
+        self.field_definitions <<  {:name => name, :options => options, :block => block}
         attr_accessor name
       end
 
@@ -21,73 +24,36 @@ module Larynx
 
     module InstanceMethods
 
+      def initialize(*args, &block)
+        @fields = self.class.field_definitions.map {|field| Field.new(field[:name], field[:options], &field[:block]) }
+        @current_field = 0
+        super
+      end
+
       def next_field(field_name=nil)
-        @current_field ||= 0
-        @current_field = index_of_field(field_name) if field_name
-        if field = self.class.fields[@current_field]
+        @current_field = field_index(field_name) if field_name
+        if field = @fields[@current_field]
           field.run(self)
           @current_field += 1
           field
         end
       end
 
-      def index_of_field(name)
-        field = self.class.fields.find {|f| f.name == name }
-        self.class.fields.index(field)
-      end
-
-    end
-
-    module CallbacksWithMode
-
-      def setup(mode=:sync, &block)
-        block = app_scope(block)
-        callback = (mode == :async) ? lambda { EM.defer(block, lambda { send_next_command } ) } : block
-        super &callback
-      end
-
-      def success(mode=:sync, &block)
-        block = app_scope(block)
-        callback = (mode == :async) ? lambda { EM.defer(block, lambda { send_next_command } ) } : block
-        super &callback
-      end
-
-      def failure(mode=:sync, &block)
-        block = app_scope(block)
-        callback = (mode == :async) ? lambda { EM.defer(block, lambda { send_next_command } ) } : block
-        super &callback
-      end
-
-      def validate(mode=:sync, &block)
-        block = app_scope(block)
-        if mode == :async
-          super &lambda { EM.defer(block, lambda {|result| evaluate_validity(result) } ) }
-        else
-          super &lambda { evaluate_validity(block.call) }
-        end
-      end
-
-      def invalid(mode=:sync, &block)
-        block = app_scope(block)
-        if mode == :async
-          super &lambda { EM.defer(block, lambda {|result| invalid_input } ) }
-        else
-          super &lambda { block.call; invalid_input }
-        end
+      def field_index(name)
+        field = @fields.find {|f| f.name == name }
+        @fields.index(field)
       end
 
     end
 
     class Field
-      include Callbacks
+      include CallbacksWithAsync
 
-      attr_reader :name
-      define_callback :setup, :validate, :invalid, :success, :failure
+      attr_reader :name, :app
+      define_callback :setup, :validate, :invalid, :success, :failure, :scope => :app
 
       def initialize(name, options, &block)
-        class_eval { include CallbacksWithMode }
-
-        @name, @callbacks = name, {}
+        @name = name
         @options = options.reverse_merge(:attempts => 3)
         @prompt_queue = []
 
@@ -105,19 +71,20 @@ module Larynx
       end
 
       def add_prompt(options)
+        options.assert_valid_keys(:play, :speak, :phrase, :bargein, :repeats, :interdigit_timeout, :timeout)
         repeats = options.delete(:repeats) || 1
-        options.merge!(@options.slice(:length, :min_length, :max_length))
+        options.merge!(@options.slice(:length, :min_length, :max_length, :interdigit_timeout, :timeout))
         @prompt_queue += ([options] * repeats)
       end
 
       def current_prompt
         options = (@prompt_queue[@attempt-1] || @prompt_queue.last).dup
-        method  = ([:play, :speak, :phrase] & options.keys).first
+        method  = command_from_options(options)
         message = options[method].is_a?(Symbol) ? @app.send(options[method]) : options[method]
         options[method] = message
 
-        Prompt.new(call, options) {|input|
-          set_instance_variables(input)
+        Prompt.new(call, options) {|input, result|
+          set_instance_variables(input, result)
           evaluate_input
         }
       end
@@ -131,24 +98,25 @@ module Larynx
         @attempt += 1
       end
 
-      def valid_length?
-        @value.size >= minimum_length
+      # hook called when callback is complete
+      def callback_complete(callback, result)
+        case callback
+        when :validate
+          result = result.nil? ? true : result
+          evaluate_validity(result)
+        when :invalid
+          invalid_input
+        when :success, :failure
+          finalize
+        end
       end
 
       def evaluate_input
-        if valid_length?
-          fire_callback(:validate) { evaluate_validity(true) }
-        else
-          fire_callback(:invalid) { invalid_input }
-        end
+        @valid_length ? fire_callback(:validate) : fire_callback(:invalid)
       end
 
       def evaluate_validity(result)
-        if result
-          fire_callback(:success) { send_next_command }
-        else
-          fire_callback(:invalid) { invalid_input }
-        end
+        result ? fire_callback(:success) : fire_callback(:invalid)
       end
 
       def invalid_input
@@ -156,7 +124,7 @@ module Larynx
           increment_attempts
           execute_prompt
         else
-          fire_callback(:failure) { send_next_command }
+          fire_callback(:failure)
         end
       end
 
@@ -164,22 +132,19 @@ module Larynx
         call.send_next_command if call.state == :ready
       end
 
-      def set_instance_variables(input)
-        @value = input
+      def set_instance_variables(input, result)
+        @value, @valid_length = input, result
         @app.send("#{@name}=", input)
       end
 
-      def maximum_length
-        @options[:max_length] || @options[:length]
-      end
-
-      def minimum_length
-        @options[:min_length] || @options[:length] || 1
+      def command_from_options(options)
+        ([:play, :speak, :phrase] & options.keys).first
       end
 
       def run(app)
         @app = app
         @attempt = 1
+        call.add_observer self
         fire_callback(:setup)
         execute_prompt
       end
@@ -188,17 +153,9 @@ module Larynx
         @app.call
       end
 
-      def app_scope(block)
-        lambda { @app.instance_eval(&block) }
-      end
-
-      # fire callback with a default block if callback not defined
-      def fire_callback(callback, *args, &block)
-        if @callbacks && @callbacks[callback]
-          @callbacks[callback].call(*args)
-        else
-          yield if block_given?
-        end
+      def finalize
+        call.remove_observer self
+        send_next_command
       end
 
     end

data/lib/larynx/prompt.rb

@@ -45,10 +45,22 @@ module Larynx
       @options[:termchar]
     end
 
+    def minimum_length
+      @options[:min_length] || @options[:length] || 1
+    end
+
     def maximum_length
       @options[:max_length] || @options[:length]
     end
 
+    def interdigit_timeout
+      @options[:interdigit_timeout]
+    end
+
+    def timeout
+      @options[:timeout]
+    end
+
     def command_name
       ([:play, :speak, :phrase] & @options.keys).first.to_s
     end
@@ -57,9 +69,15 @@ module Larynx
       @options[command_name.to_sym]
     end
 
+    def valid_length?
+      length = input.size
+      length >= minimum_length && length <= (maximum_length || length)
+    end
+
     def finalise
       call.remove_observer self
-      @block.call(input)
+      @block.arity == 2 ? @block.call(input, valid_length?) : @block.call(input)
+      call.clear_input
     end
 
     def dtmf_received(digit)
@@ -72,14 +90,14 @@ module Larynx
     end
 
     def add_digit_timer
-      call.timer(:digit, @options[:interdigit_timeout]) {
+      call.add_timer(:digit, interdigit_timeout) {
         call.cancel_timer :input
         finalise
       }
     end
 
     def add_input_timer
-      call.timer(:input, @options[:timeout]) {
+      call.add_timer(:input, timeout) {
         call.cancel_timer :digit
         finalise
       }

data/lib/larynx/response.rb

@@ -10,6 +10,10 @@ module Larynx
       end
     end
 
+    def answered?
+      executed? && command_name == 'answer' #event_name == 'CHANNEL_ANSWER'
+    end
+
     def reply?
       @header[:content_type] == 'command/reply'
     end

data/lib/larynx/version.rb

@@ -1,3 +1,3 @@
 module Larynx
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

data/lib/larynx.rb

@@ -8,6 +8,7 @@ require 'larynx/version'
 require 'larynx/logger'
 require 'larynx/observable'
 require 'larynx/callbacks'
+require 'larynx/callbacks_with_async'
 require 'larynx/session'
 require 'larynx/response'
 require 'larynx/command'
@@ -29,13 +30,13 @@ module Larynx
       @options = {
         :ip       => "0.0.0.0",
         :port     => 8084,
-        :pid_file => './larynx.pid',
-        :log_file => './larynx.log'
+        :pid_file => "./larynx.pid",
+        :log_file => "./larynx.log"
       }
       opts = OptionParser.new
       opts.banner = "Usage: larynx [options]"
       opts.separator ''
-      opts.separator "Larynx is a tool to develop FreeSWITCH IVR applications in Ruby."
+      opts.separator "Larynx is a framework to develop FreeSWITCH IVR applications in Ruby."
       opts.on('-i', '--ip IP',         'Listen for connections on this IP') {|ip| @options[:ip] = ip }
       opts.on('-p', '--port PORT',     'Listen on this port', Integer)      {|port| @options[:port] = port }
       opts.on('-d', '--daemonize',     'Run as daemon')                     { @options[:daemonize] = true }
@@ -53,7 +54,10 @@ module Larynx
     end
 
     def graceful_exit
-      LARYNX_LOGGER.info "Shutting down Larynx"
+      msg = "Shutting down Larynx"
+      $stderr.puts msg unless @options[:daemon]
+      LARYNX_LOGGER.info msg
+
       EM.stop_server @em_signature
       @em_signature = nil
       remove_pid_file if @options[:daemonize]
@@ -85,7 +89,10 @@ module Larynx
     end
 
     def start_server
-      LARYNX_LOGGER.info "Larynx starting up on #{@options[:ip]}:#{@options[:port]}"
+      msg = "Larynx starting up on #{@options[:ip]}:#{@options[:port]}"
+      $stderr.puts msg unless @options[:daemon]
+      LARYNX_LOGGER.info msg
+
       EM::run {
         @em_signature = EM::start_server @options[:ip], @options[:port], Larynx::CallHandler
       }
@@ -104,6 +111,9 @@ module Larynx
       !@em_signature.nil?
     end
   end
+
+  # Default connect callback is to answer call
+  connect {|call| call.answer }
 end
 
 Larynx.run unless defined?(TEST)

data/spec/fixtures/answered.rb

@@ -0,0 +1,131 @@
+RESPONSES[:answered] = {
+  :header  => [ "Content-Length: 5793", "Content-Type: text/event-plain" ],
+  :content => <<-DATA
+Event-Name: CHANNEL_EXECUTE_COMPLETE
+Core-UUID: 0a3bd7a4-2a47-11df-8f89-ddea2631ab78
+FreeSWITCH-Hostname: ubuntu
+FreeSWITCH-IPv4: 172.16.150.131
+FreeSWITCH-IPv6: %3A%3A1
+Event-Date-Local: 2010-03-07%2016%3A39%3A02
+Event-Date-GMT: Mon,%2008%20Mar%202010%2000%3A39%3A02%20GMT
+Event-Date-Timestamp: 1268008742244659
+Event-Calling-File: switch_core_session.c
+Event-Calling-Function: switch_core_session_exec
+Event-Calling-Line-Number: 1824
+Channel-State: CS_EXECUTE
+Channel-State-Number: 4
+Channel-Name: sofia/internal/1000%40172.16.150.131
+Unique-ID: f81a3fbc-2a4a-11df-8f9d-ddea2631ab78
+Call-Direction: inbound
+Presence-Call-Direction: inbound
+Channel-Presence-ID: 1000%40172.16.150.131
+Answer-State: answered
+Channel-Read-Codec-Name: GSM
+Channel-Read-Codec-Rate: 8000
+Channel-Write-Codec-Name: GSM
+Channel-Write-Codec-Rate: 8000
+Caller-Username: 1000
+Caller-Dialplan: XML
+Caller-Caller-ID-Name: FreeSWITCH
+Caller-Caller-ID-Number: 1000
+Caller-Network-Addr: 172.16.150.1
+Caller-ANI: 1000
+Caller-Destination-Number: 502
+Caller-Unique-ID: f81a3fbc-2a4a-11df-8f9d-ddea2631ab78
+Caller-Source: mod_sofia
+Caller-Context: default
+Caller-Channel-Name: sofia/internal/1000%40172.16.150.131
+Caller-Profile-Index: 1
+Caller-Profile-Created-Time: 1268008732274835
+Caller-Channel-Created-Time: 1268008732274835
+Caller-Channel-Answered-Time: 1268008732325458
+Caller-Channel-Progress-Time: 0
+Caller-Channel-Progress-Media-Time: 0
+Caller-Channel-Hangup-Time: 0
+Caller-Channel-Transfer-Time: 0
+Caller-Screen-Bit: true
+Caller-Privacy-Hide-Name: false
+Caller-Privacy-Hide-Number: false
+variable_uuid: f81a3fbc-2a4a-11df-8f9d-ddea2631ab78
+variable_sip_network_ip: 172.16.150.1
+variable_sip_network_port: 61230
+variable_sip_received_ip: 172.16.150.1
+variable_sip_received_port: 61230
+variable_sip_via_protocol: udp
+variable_sip_authorized: true
+variable_sip_number_alias: 1000
+variable_sip_auth_username: 1000
+variable_sip_auth_realm: 172.16.150.131
+variable_number_alias: 1000
+variable_user_name: 1000
+variable_domain_name: 172.16.150.131
+variable_toll_allow: domestic,international,local
+variable_accountcode: 1000
+variable_user_context: default
+variable_effective_caller_id_name: Extension%201000
+variable_effective_caller_id_number: 1000
+variable_outbound_caller_id_name: FreeSWITCH
+variable_outbound_caller_id_number: 0000000000
+variable_callgroup: techsupport
+variable_record_stereo: true
+variable_default_gateway: example.com
+variable_default_areacode: 918
+variable_transfer_fallback_extension: operator
+variable_sip_from_user: 1000
+variable_sip_from_uri: 1000%40172.16.150.131
+variable_sip_from_host: 172.16.150.131
+variable_sip_from_user_stripped: 1000
+variable_sofia_profile_name: internal
+variable_sip_full_via: SIP/2.0/UDP%20192.168.20.2%3A61230%3Brport%3D61230%3Bbranch%3Dz9hG4bKPjywNOvUq.sdNaFl0hFfl2j92kst3ChkRT%3Breceived%3D172.16.150.1
+variable_sip_req_user: 502
+variable_sip_req_uri: 502%40172.16.150.131
+variable_sip_req_host: 172.16.150.131
+variable_sip_to_user: 502
+variable_sip_to_uri: 502%40172.16.150.131
+variable_sip_to_host: 172.16.150.131
+variable_sip_contact_user: 1000
+variable_sip_contact_port: 61230
+variable_sip_contact_uri: 1000%40192.168.20.2%3A61230
+variable_sip_contact_host: 192.168.20.2
+variable_channel_name: sofia/internal/1000%40172.16.150.131
+variable_sip_user_agent: Telephone%200.14.3
+variable_sip_via_host: 192.168.20.2
+variable_sip_via_port: 61230
+variable_sip_via_rport: 61230
+variable_max_forwards: 70
+variable_presence_id: 1000%40172.16.150.131
+variable_switch_r_sdp: v%3D0%0D%0Ao%3D-%203476997537%203476997537%20IN%20IP4%20192.168.20.2%0D%0As%3Dpjmedia%0D%0Ac%3DIN%20IP4%20192.168.20.2%0D%0At%3D0%200%0D%0Aa%3DX-nat%3A0%0D%0Am%3Daudio%204010%20RTP/AVP%20103%20102%20104%20117%203%200%208%209%20101%0D%0Aa%3Drtpmap%3A103%20speex/16000%0D%0Aa%3Drtpmap%3A102%20speex/8000%0D%0Aa%3Drtpmap%3A104%20speex/32000%0D%0Aa%3Drtpmap%3A117%20iLBC/8000%0D%0Aa%3Dfmtp%3A117%20mode%3D30%0D%0Aa%3Drtpmap%3A3%20GSM/8000%0D%0Aa%3Drtpmap%3A0%20PCMU/8000%0D%0Aa%3Drtpmap%3A8%20PCMA/8000%0D%0Aa%3Drtpmap%3A9%20G722/8000%0D%0Aa%3Drtpmap%3A101%20telephone-event/8000%0D%0Aa%3Dfmtp%3A101%200-15%0D%0Aa%3Drtcp%3A4011%20IN%20IP4%20192.168.20.2%0D%0A
+variable_sip_use_codec_name: GSM
+variable_sip_use_codec_rate: 8000
+variable_sip_use_codec_ptime: 20
+variable_read_codec: GSM
+variable_read_rate: 8000
+variable_write_codec: GSM
+variable_write_rate: 8000
+variable_tts_engine: cepstral
+variable_tts_voice: allison
+variable_socket_host: 172.16.150.1
+variable_sip_local_sdp_str: v%3D0%0Ao%3DFreeSWITCH%201267985798%201267985799%20IN%20IP4%20172.16.150.131%0As%3DFreeSWITCH%0Ac%3DIN%20IP4%20172.16.150.131%0At%3D0%200%0Am%3Daudio%2022934%20RTP/AVP%203%20101%0Aa%3Drtpmap%3A3%20GSM/8000%0Aa%3Drtpmap%3A101%20telephone-event/8000%0Aa%3Dfmtp%3A101%200-16%0Aa%3DsilenceSupp%3Aoff%20-%20-%20-%20-%0Aa%3Dptime%3A20%0Aa%3Dsendrecv%0A
+variable_local_media_ip: 172.16.150.131
+variable_local_media_port: 22934
+variable_sip_use_pt: 3
+variable_rtp_use_ssrc: 2898819412
+variable_sip_nat_detected: true
+variable_endpoint_disposition: ANSWER
+variable_sip_to_tag: gDK3D6pXtFm3e
+variable_sip_from_tag: elWUmu5et-auCRPijiEAiLkCgci1M67D
+variable_sip_cseq: 14587
+variable_sip_call_id: bjGKd9gAHJVCxd1uVy9knG.iFWn-n2h4
+variable_sip_from_display: FreeSWITCH
+variable_sip_full_from: %22FreeSWITCH%22%20%3Csip%3A1000%40172.16.150.131%3E%3Btag%3DelWUmu5et-auCRPijiEAiLkCgci1M67D
+variable_sip_full_to: %3Csip%3A502%40172.16.150.131%3E%3Btag%3DgDK3D6pXtFm3e
+variable_remote_media_ip_reported: 192.168.20.2
+variable_remote_media_ip: 172.16.150.1
+variable_remote_media_port_reported: 4010
+variable_remote_media_port: 4010
+variable_rtp_auto_adjust: true
+variable_current_application: answer
+Application: answer
+Application-Response: _none_
+DATA
+}

data/spec/larynx/call_handler_spec.rb

@@ -64,9 +64,8 @@ describe Larynx::CallHandler do
     end
 
     it "should run app command before callback" do
-      call.speak('hello world').before { @callback = true }
+      call.speak('hello world').before &should_be_called
       call.send_response :execute
-      @callback.should be_true
     end
 
     it "should change state to executing" do
@@ -132,9 +131,19 @@ describe Larynx::CallHandler do
     end
 
     it "should fire global connect callback" do
-      Larynx.connect {|call| @callback = true }
+      with_global_callback(:connect, should_be_called) do
+        connect_call
+      end
+    end
+
+    it "should subscribe to myevents" do
+      call.should_receive(:myevents)
+      connect_call
+    end
+
+    it "should set event lingering on after filter events" do
+      call.should_receive(:linger)
       connect_call
-      @callback.should be_true
     end
 
     it "should start the call session" do
@@ -146,39 +155,36 @@ describe Larynx::CallHandler do
       call.send_response :channel_data
     end
 
-    after do
-      Larynx.connect {|call|}
-    end
   end
 
-  context "on session start" do
+  context "#session_start" do
     before do
       call.queue = []
       call.session = mock('session', :unique_id => '123')
+      call.response = mock('response', :header => {})
     end
 
-    it "should subscribe to myevents" do
+    it "should subscribe to events" do
       call.should_receive(:myevents)
       call.start_session
     end
 
-    it "should set event lingering on after filter events" do
+    it "should execute linger command" do
       call.should_receive(:linger)
       call.start_session
-      call.send_response :reply_ok
     end
 
-    it "should answer call after filter events" do
+    it "should run answer command in connect callback be default" do
       call.should_receive(:answer)
       call.start_session
-      call.send_response :reply_ok
     end
   end
 
   context "on answer" do
     before do
-      call.queue = []
-      call.session = mock('session', :unique_id => '123')
+      call.queue    = []
+      call.session  = mock('session', :unique_id => '123')
+      call.response = mock('response', :header => {})
     end
 
     it "should change state to ready" do
@@ -187,17 +193,13 @@ describe Larynx::CallHandler do
     end
 
     it "should fire global answer callback" do
-      Larynx.answer {|call| @callback = true }
-      answer_call
-      @callback.should be_true
+      with_global_callback(:answer, should_be_called) do
+        answer_call
+      end
     end
 
     def answer_call
-      call.start_session
-      call.send_response :reply_ok
-      call.send_response :reply_ok
-      call.send_response :reply_ok
-      call.send_response :execute_complete
+      call.send_response :answered
     end
   end
 
@@ -288,13 +290,13 @@ describe Larynx::CallHandler do
   context "timer" do
     it "should add EM timer with name and timeout" do
       Larynx::RestartableTimer.stub!(:new)
-      call.timer(:test, 0.1)
+      call.add_timer(:test, 0.1)
       call.timers[:test].should_not be_nil
     end
 
     it "should run callback on timeout" do
       em do
-        call.timer(:test, 0.2) { @callback = true; done }
+        call.add_timer(:test, 0.2) { @callback = true; done }
       end
       @callback.should be_true
     end
@@ -303,20 +305,18 @@ describe Larynx::CallHandler do
   context "stop_timer" do
     it "should run callback on timeout" do
       em do
-        call.timer(:test, 1) { @callback = true }
+        call.add_timer(:test, 1, &should_be_called)
         EM::Timer.new(0.1) { call.stop_timer :test; done }
       end
-      @callback.should be_true
     end
   end
 
   context "cancel_timer" do
     it "should not run callback" do
       em do
-        call.timer(:test, 0.2) { @callback = true }
+        call.add_timer(:test, 0.2, &should_not_be_called)
         EM::Timer.new(0.1) { call.cancel_timer :test; done }
       end
-      @callback.should_not be_true
     end
   end
 
@@ -325,7 +325,7 @@ describe Larynx::CallHandler do
       start = Time.now
       em do
         EM::Timer.new(0.5) { call.restart_timer :test }
-        call.timer(:test, 1) { done }
+        call.add_timer(:test, 1) { done }
       end
       (Time.now-start).should be_close(1.5, 0.2)
     end

data/spec/larynx/fields_spec.rb

@@ -1,40 +1,47 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
+class TestApp < Larynx::Application; end
+
 describe Larynx::Fields do
   attr_reader :call, :app
 
   before do
     @call = TestCallHandler.new(1)
-    @app = Larynx::Application.new(@call)
+    @app  = define_app.new(@call)
   end
 
   context 'module' do
-    include Larynx::Fields
+    before do
+      @app_class = define_app
+    end
 
     it 'should add field class method' do
-      self.class.should respond_to(:field)
+      @app_class.should respond_to(:field)
     end
 
     it 'should add instance accessor for field name' do
-      self.class.field(:guess) { prompt :speak => 'hello' }
-      self.methods.include?(:guess)
+      @app_class.field(:guess) { prompt :speak => 'hello' }
+      @app_class.methods.include?(:guess)
     end
   end
 
   context 'next_field' do
-    include Larynx::Fields
-    field(:field1) { prompt :speak => 'hello' }
-    field(:field2) { prompt :speak => 'hello' }
-    field(:field3) { prompt :speak => 'hello' }
+    before do
+      @app = define_app do
+        field(:field1) { prompt :speak => 'hello' }
+        field(:field2) { prompt :speak => 'hello' }
+        field(:field3) { prompt :speak => 'hello' }
+      end.new(call)
+    end
 
     it 'should iterate over defined fields' do
-      next_field.name.should == :field1
-      next_field.name.should == :field2
-      next_field.name.should == :field3
+      app.next_field.name.should == :field1
+      app.next_field.name.should == :field2
+      app.next_field.name.should == :field3
     end
 
     it 'should jump to field name if supplied' do
-      next_field(:field2).name.should == :field2
+      app.next_field(:field2).name.should == :field2
     end
   end
 
@@ -52,6 +59,18 @@ describe Larynx::Fields do
       fld.run app
     end
 
+    it 'should pass timeout and length options to the prompt object' do
+      fld = field(:guess, :length => 1, :min_length => 1, :max_length => 2, :interdigit_timeout => 1, :timeout => 2) do
+        prompt :speak => 'first'
+      end
+      fld.run(app)
+      prompt = fld.current_prompt
+      prompt.interdigit_timeout.should == 1
+      prompt.timeout.should == 2
+      prompt.minimum_length.should == 1
+      prompt.maximum_length.should == 2
+    end
+
     it 'should return same prompt all attempts if single prompt' do
       fld = field(:guess) do
         prompt :speak => 'first'
@@ -86,17 +105,6 @@ describe Larynx::Fields do
       fld.current_prompt.message.should == 'second'
     end
 
-    context 'valid_length?' do
-      it 'should be false if input size less than minimum' do
-        fld = field(:guess) do
-          prompt :speak => 'first'
-        end
-        fld.run app
-        fld.current_prompt.finalise
-        fld.valid_length?.should be_false
-      end
-    end
-
     context 'input evaluation' do
       it 'should run validate callback if input minimum length' do
         call_me = should_be_called
@@ -205,4 +213,11 @@ describe Larynx::Fields do
     @app.class.class_eval { attr_accessor name }
     Larynx::Fields::Field.new(name, options, &block)
   end
+
+  def define_app(&block)
+    reset_class(TestApp) do
+      include Larynx::Fields
+      instance_eval &block if block_given?
+    end
+  end
 end

data/spec/larynx/prompt_spec.rb

@@ -85,17 +85,18 @@ describe Larynx::Prompt do
   context "after callback" do
     context "input completed" do
       it "should not add timers if reached length" do
+        prompt = new_prompt
+        prompt.should_not_receive(:add_digit_timer)
+        prompt.should_not_receive(:add_input_timer)
         call.input << '1'
-        call.should_not_receive(:timer).with(:digit, anything())
-        call.should_not_receive(:timer).with(:input, anything())
-        after_callback new_prompt
+        after_callback prompt
       end
 
       it "should not add timers if termchar input" do
         prompt = new_prompt(:speak => 'hello', :length => 2, :termchar => '#')
+        prompt.should_not_receive(:add_digit_timer)
+        prompt.should_not_receive(:add_input_timer)
         call.input << '#'
-        call.should_not_receive(:timer).with(:digit, anything())
-        call.should_not_receive(:timer).with(:input, anything())
         after_callback prompt
       end
 
@@ -109,14 +110,15 @@ describe Larynx::Prompt do
 
     context "input not completed" do
       it "should add timers" do
-        call.should_receive(:timer).with(:digit, anything())
-        call.should_receive(:timer).with(:input, anything())
-        after_callback new_prompt
+        prompt = new_prompt
+        prompt.should_receive(:add_digit_timer)
+        prompt.should_receive(:add_input_timer)
+        after_callback prompt
       end
 
       it "should add itself as call observer" do
         prompt = new_prompt
-        call.stub!(:timer)
+        call.stub!(:add_timer)
         after_callback prompt
         call.observers.should include(prompt)
       end
@@ -142,15 +144,29 @@ describe Larynx::Prompt do
       call.should_receive(:remove_observer).with(prompt)
       prompt.finalise
     end
+
+    it "should clear input" do
+      prompt = new_prompt
+      call.should_receive(:clear_input)
+      prompt.finalise
+    end
   end
 
   context "user callback" do
     it "should be passed input argument equal to call input" do
-      prompt = new_prompt {|input| @callback = '1'}
+      prompt = new_prompt {|input| @callback = input }
       call.input << '1'
       after_callback prompt
       @callback.should == '1'
     end
+
+    it "should be passed input and result arguments if block arity is 2" do
+      prompt = new_prompt(:speak => '', :length => 1) {|input, result| @input = input; @result = result }
+      call.input << '1'
+      after_callback prompt
+      @input.should == '1'
+      @result.should be_true
+    end
   end
 
   context "interdigit timeout" do

data/spec/spec_helper.rb

@@ -11,8 +11,14 @@ LARYNX_LOGGER = Logger.new(STDOUT)
 RESPONSES = {}
 Dir['spec/fixtures/*.rb'].each {|file| require file }
 
+Larynx.module_eval do
+  def self.callbacks
+    @callbacks
+  end
+end
+
 class TestCallHandler < Larynx::CallHandler
-  attr_accessor :sent_data, :session, :state, :queue, :input, :timers
+  attr_accessor :sent_data, :session, :response, :state, :queue, :input, :timers
 
   def send_data(msg)
     @sent_data = msg
@@ -40,6 +46,22 @@ module SpecHelper
     proc.should_not_receive(:call).instance_eval(&(block || lambda {}))
     lambda { |*args| proc.call(*args) }
   end
+
+  def with_global_callback(name, test_callback)
+    default = Larynx.callbacks[name]
+    Larynx.send(name, &test_callback)
+    yield
+    Larynx.send(name, &default)
+  end
+
+  def reset_class(klass, &block)
+    name = klass.name.to_sym
+    Object.send(:remove_const, name)
+    eval "class #{klass}#{' < ' + klass.superclass.to_s if klass.superclass != Class}; end", TOPLEVEL_BINDING
+    new_klass = Object.const_get(name)
+    new_klass.class_eval &block if block_given?
+    new_klass
+  end
 end
 
 Spec::Runner.configure do |config|

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Adam Meehan
@@ -14,7 +14,7 @@ autorequire: larynx
 bindir: bin
 cert_chain: []
 
-date: 2010-03-31 00:00:00 +11:00
+date: 2010-04-29 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,7 +73,7 @@ dependencies:
         version: 0.1.3
   type: :development
   version_requirements: *id004
-description: ""
+description: An evented application framework for the FreeSWITCH telephony platform
 email: adam.meehan@gmail.com
 executables: 
 - larynx
@@ -88,6 +88,7 @@ files:
 - lib/larynx/application.rb
 - lib/larynx/call_handler.rb
 - lib/larynx/callbacks.rb
+- lib/larynx/callbacks_with_async.rb
 - lib/larynx/command.rb
 - lib/larynx/commands.rb
 - lib/larynx/fields.rb
@@ -101,6 +102,7 @@ files:
 - lib/larynx/version.rb
 - lib/larynx.rb
 - spec/fixtures/answer.rb
+- spec/fixtures/answered.rb
 - spec/fixtures/break.rb
 - spec/fixtures/channel_data.rb
 - spec/fixtures/dtmf.rb
@@ -147,6 +149,6 @@ rubyforge_project: larynx
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: ""
+summary: An evented application framework for the FreeSWITCH telephony platform
 test_files: []