adhearsion 2.1.3 → 2.2.0

data/lib/adhearsion/call_controller/output/abstract_player.rb

@@ -17,12 +17,12 @@ module Adhearsion
           end
         end
 
-        def play_ssml_for(*args)
-          play_ssml Formatter.ssml_for(args)
-        end
-
         def new_output(options)
-          Punchblock::Component::Output.new options
+          defaults = {}
+          default_voice = Adhearsion.config.punchblock[:default_voice]
+          defaults[:voice] = default_voice if default_voice
+
+          Punchblock::Component::Output.new defaults.merge(options)
         end
       end
     end

data/lib/adhearsion/call_controller/output/formatter.rb

@@ -3,90 +3,90 @@
 module Adhearsion
   class CallController
     module Output
-      module Formatter
+      class Formatter
 
-        class << self
-          def ssml_for_collection(collection)
-            collection.inject RubySpeech::SSML::Speak.new do |doc, argument|
-              doc + case argument
-              when Hash
-                Formatter.ssml_for argument.delete(:value), argument
-              when RubySpeech::SSML::Speak
-                argument
-              else
-                Formatter.ssml_for argument
-              end
-            end
-          end
-
-          def detect_type(output)
-            case output
-            when Date, Time, DateTime
-              :time
-            when Numeric, /^\d+$/
-              :numeric
-            when /^\//, ->(string) { uri? string }
-              :audio
+        def ssml_for_collection(collection)
+          collection.inject RubySpeech::SSML::Speak.new do |doc, argument|
+            doc + case argument
+            when Hash
+              ssml_for argument.delete(:value), argument
+            when RubySpeech::SSML::Speak
+              argument
+            when lambda { |a| a.respond_to? :each }
+              ssml_for_collection argument
             else
-              :text
+              ssml_for argument
             end
           end
+        end
 
-          def uri?(string)
-            uri = URI.parse string
-            !!uri.scheme
-          rescue URI::BadURIError
-            false
-          rescue URI::InvalidURIError
-            false
+        def detect_type(output)
+          case output
+          when Date, Time, DateTime
+            :time
+          when Numeric, /^\d+$/
+            :numeric
+          when /^\//, ->(string) { uri? string }
+            :audio
+          else
+            :text
           end
+        end
 
-          #
-          # Generates SSML for the argument and options passed, using automatic detection
-          # Directly returns the argument if it is already an SSML document
-          #
-          # @param [String, Hash, RubySpeech::SSML::Speak] the argument with options as accepted by the play_ methods, or an SSML document
-          # @return [RubySpeech::SSML::Speak] an SSML document
-          #
-          def ssml_for(*args)
-            return args[0] if args.size == 1 && args[0].is_a?(RubySpeech::SSML::Speak)
-            argument, options = args.flatten
-            options ||= {}
-            type = detect_type argument
-            send "ssml_for_#{type}", argument, options
-          end
+        def uri?(string)
+          uri = URI.parse string
+          !!uri.scheme
+        rescue URI::BadURIError
+          false
+        rescue URI::InvalidURIError
+          false
+        end
 
-          def ssml_for_text(argument, options = {})
-            RubySpeech::SSML.draw { argument }
-          end
+        #
+        # Generates SSML for the argument and options passed, using automatic detection
+        # Directly returns the argument if it is already an SSML document
+        #
+        # @param [String, Hash, RubySpeech::SSML::Speak] the argument with options as accepted by the play_ methods, or an SSML document
+        # @return [RubySpeech::SSML::Speak] an SSML document
+        #
+        def ssml_for(*args)
+          return args[0] if args.size == 1 && args[0].is_a?(RubySpeech::SSML::Speak)
+          argument, options = args.flatten
+          options ||= {}
+          type = detect_type argument
+          send "ssml_for_#{type}", argument, options
+        end
 
-          def ssml_for_time(argument, options = {})
-            interpretation = case argument
-            when Date then 'date'
-            when Time then 'time'
-            end
+        def ssml_for_text(argument, options = {})
+          RubySpeech::SSML.draw { argument }
+        end
 
-            format = options.delete :format
-            strftime = options.delete :strftime
+        def ssml_for_time(argument, options = {})
+          interpretation = case argument
+          when Date then 'date'
+          when Time then 'time'
+          end
 
-            time_to_say = strftime ? argument.strftime(strftime) : argument.to_s
+          format = options.delete :format
+          strftime = options.delete :strftime
 
-            RubySpeech::SSML.draw do
-              say_as(:interpret_as => interpretation, :format => format) { time_to_say }
-            end
+          time_to_say = strftime ? argument.strftime(strftime) : argument.to_s
+
+          RubySpeech::SSML.draw do
+            say_as(:interpret_as => interpretation, :format => format) { time_to_say }
           end
+        end
 
-          def ssml_for_numeric(argument, options = {})
-            RubySpeech::SSML.draw do
-              say_as(:interpret_as => 'cardinal') { argument.to_s }
-            end
+        def ssml_for_numeric(argument, options = {})
+          RubySpeech::SSML.draw do
+            say_as(:interpret_as => 'cardinal') { argument.to_s }
           end
+        end
 
-          def ssml_for_audio(argument, options = {})
-            fallback = (options || {}).delete :fallback
-            RubySpeech::SSML.draw do
-              audio(:src => argument) { fallback }
-            end
+        def ssml_for_audio(argument, options = {})
+          fallback = (options || {}).delete :fallback
+          RubySpeech::SSML.draw do
+            audio(:src => argument) { fallback }
           end
         end
       end

data/lib/adhearsion/call_controller/record.rb

@@ -5,6 +5,93 @@ module Adhearsion
     module Record
       RecordError = Class.new StandardError # Represents failure to record such as when a file cannot be written.
 
+      #
+      # Handle a recording
+      #
+      # @param [Adhearsion::CallController] controller on which to execute the recording
+      # @param [Hash] options
+      # @option options [Boolean, Optional] :async Execute asynchronously. Defaults to false
+      # @option options [Boolean, Optional] :start_beep Indicates whether subsequent record will be preceded with a beep. Default is true.
+      # @option options [Boolean, Optional] :start_paused Whether subsequent record will start in PAUSE mode. Default is false.
+      # @option options [String, Optional] :max_duration Indicates the maximum duration (seconds) for a recording.
+      # @option options [String, Optional] :format File format used during recording.
+      # @option options [String, Optional] :initial_timeout Controls how long (seconds) the recognizer should wait after the end of the prompt for the caller to speak before sending a Recorder event.
+      # @option options [String, Optional] :final_timeout Controls the length (seconds) of a period of silence after callers have spoken to conclude they finished.
+      # @option options [Boolean, Optional] :interruptible Allows the recording to be terminated by any single DTMF key, default is false
+      #
+      class Recorder
+        attr_accessor :record_component, :stopper_component
+
+        def initialize(controller, options = {})
+          @controller = controller
+
+          options = prep_options options
+
+          @async = options.delete :async
+
+          @stopper_component  = options.delete(:interruptible) ? setup_stopper : nil
+          @record_component   = Punchblock::Component::Record.new options
+        end
+
+        #
+        # Execute the recorder
+        #
+        # @return nil
+        #
+        def run
+          execute_stopper
+          execute_recording
+          terminate_stopper
+          nil
+        end
+
+        #
+        # Set a callback to be executed when recording completes
+        #
+        # @yield [Punchblock::Event::Complete] the complete Event for the recording
+        #
+        def handle_record_completion(&block)
+          @record_component.register_event_handler Punchblock::Event::Complete, &block
+        end
+
+        private
+
+        def setup_stopper
+          @stopper_component = Punchblock::Component::Input.new :mode => :dtmf,
+            :grammar => {
+              :value => @controller.grammar_accept('0123456789#*')
+            }
+          @stopper_component.register_event_handler Punchblock::Event::Complete do |event|
+            @record_component.stop! unless @record_component.complete?
+          end
+          @stopper_component
+        end
+
+        def execute_stopper
+          @controller.write_and_await_response @stopper_component if @stopper_component
+        end
+
+        def execute_recording
+          if @async
+            @controller.write_and_await_response @record_component
+          else
+            @controller.execute_component_and_await_completion @record_component
+          end
+        end
+
+        def terminate_stopper
+          @stopper_component.stop! if @stopper_component && !@stopper_component.complete?
+        end
+
+        def prep_options(opts)
+          opts.dup.tap do |options|
+            [:max_duration, :initial_timeout, :final_timeout].each do |k|
+              options[k] = options[k] * 1000 if options[k]
+            end
+          end
+        end
+      end
+
       #
       # Start a recording
       #
@@ -23,7 +110,6 @@ module Adhearsion
       # @option options [Boolean, Optional] :start_paused Whether subsequent record will start in PAUSE mode. Default is false.
       # @option options [String, Optional] :max_duration Indicates the maximum duration (seconds) for a recording.
       # @option options [String, Optional] :format File format used during recording.
-      # @option options [String, Optional] :format File format used during recording.
       # @option options [String, Optional] :initial_timeout Controls how long (seconds) the recognizer should wait after the end of the prompt for the caller to speak before sending a Recorder event.
       # @option options [String, Optional] :final_timeout Controls the length (seconds) of a period of silence after callers have spoken to conclude they finished.
       # @option options [Boolean, Optional] :interruptible Allows the recording to be terminated by any single DTMF key, default is false
@@ -31,37 +117,14 @@ module Adhearsion
       # @return Punchblock::Component::Record
       #
       def record(options = {})
-        async = options.delete :async
-        interruptible = options.delete :interruptible
-        interrupt_key = '0123456789#*'
-        stopper_component = nil
-        [:max_duration, :initial_timeout, :final_timeout].each do |k|
-          options[k] = options[k].to_i * 1000 if options[k]
-        end
+        recorder = Recorder.new self, options
 
-        component = Punchblock::Component::Record.new options
-        component.register_event_handler Punchblock::Event::Complete do |event|
+        recorder.handle_record_completion do |event|
           catching_standard_errors { yield event if block_given? }
         end
 
-        if interruptible
-          stopper_component = Punchblock::Component::Input.new :mode => :dtmf,
-            :grammar => {
-              :value => grammar_accept(interrupt_key)
-            }
-          stopper_component.register_event_handler Punchblock::Event::Complete do |event|
-            component.stop! unless component.complete?
-          end
-          write_and_await_response stopper_component
-        end
-
-        if async
-          write_and_await_response component
-        else
-          execute_component_and_await_completion component
-        end
-        stopper_component.stop! if stopper_component && stopper_component.executing?
-        component
+        recorder.run
+        recorder.record_component
       end
     end
   end

data/lib/adhearsion/call_controller/utility.rb

@@ -44,16 +44,23 @@ module Adhearsion
       end
 
       #
-      # Parses a single DTMF tone in the format dtmf-*
+      # Parses a DTMF tone string
       #
       # @param [String] the tone string to be parsed
-      # @return [String] the digit in case input was 0-9, * or # if star or pound respectively
+      # @return [String] the digits/*/# without any separation
       #
       # @private
       #
-      def parse_single_dtmf(result)
-        return if result.nil?
-        case tone = result.split('-')[1]
+      def parse_dtmf(dtmf)
+        return if dtmf.nil?
+        dtmf.split(' ').inject '' do |final, digit|
+          final << parse_dtmf_digit(digit)
+        end
+      end
+
+      # @private
+      def parse_dtmf_digit(digit)
+        case tone = digit.split('-').last
         when 'star'
           '*'
         when 'pound'

data/lib/adhearsion/calls.rb

@@ -45,10 +45,10 @@ module Adhearsion
     end
 
     def call_died(call, reason)
-      return unless reason
       catching_standard_errors do
         call_id = key call
         remove_inactive_call call
+        return unless reason
         PunchblockPlugin.client.execute_command Punchblock::Command::Hangup.new, :async => true, :call_id => call_id
       end
     end

data/lib/adhearsion/configuration.rb

@@ -52,6 +52,10 @@ module Adhearsion
             A log formatter to apply to all active outputters. If nil, the Adhearsion default formatter will be used.
           __
         }
+
+        after_hangup_lifetime 30, :transform => Proc.new { |v| v.to_i }, :desc => <<-__
+          Lifetime of a call after it has hung up
+        __
       end
 
       Loquacious::Configuration.for :platform, &block if block_given?

data/lib/adhearsion/events.rb

@@ -83,7 +83,8 @@ module Adhearsion
     private
 
     def call_handler(handler, guards, event)
-      super && throw(:pass)
+      super
+      throw :pass
     end
 
     class ErrorHandler

data/lib/adhearsion/generators/app/app_generator.rb

@@ -4,8 +4,8 @@ module Adhearsion
   module Generators
     class AppGenerator < Generator
 
-      BASEDIRS = %w( config lib script spec )
-      EMPTYDIRS = %w( spec/call_controllers spec/support )
+      BASEDIRS  = %w( config lib script spec )
+      EMPTYDIRS = %w( spec/support )
 
       def setup_project
         self.destination_root = @generator_name

data/lib/adhearsion/generators/app/templates/Gemfile.erb

@@ -13,3 +13,7 @@ gem "adhearsion", "~> <%= Adhearsion::VERSION.split('.')[0,2].join('.') %>"
 # gem 'adhearsion-ldap'
 # gem 'adhearsion-xmpp'
 # gem 'adhearsion-drb'
+
+group :development, :test do
+  gem 'rspec'
+end

data/lib/adhearsion/generators/app/templates/Rakefile

@@ -3,3 +3,8 @@
 require File.expand_path('../config/environment',  __FILE__)
 
 require 'adhearsion/tasks'
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/lib/adhearsion/generators/app/templates/lib/simon_game.rb

@@ -1,6 +1,9 @@
 # encoding: utf-8
 
 class SimonGame < Adhearsion::CallController
+
+  attr_accessor :number, :attempt
+
   def run
     answer
     reset

data/lib/adhearsion/generators/app/templates/rspec

@@ -1 +1,3 @@
+--format documentation
 --colour
+--tty

data/lib/adhearsion/generators/app/templates/spec/call_controllers/simon_game_spec.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SimonGame do
+
+  let(:example_response)  { OpenStruct.new(:response => "5")     }
+  let(:example_number)    { "5"                                  }
+  let(:long_response)     { OpenStruct.new(:response => "55555") }
+  let(:long_number)       { "55555"                              }
+
+  let(:mock_call) { mock 'Call' }
+  subject { SimonGame.new(mock_call) }
+
+  describe "#random_number" do 
+
+    before { subject.stub!(:rand).and_return(example_number) }
+
+    it "generates a random number" do 
+      subject.random_number.should eq example_number   
+    end
+  end
+
+  describe "#update_number" do 
+
+    before { subject.number = "123" }
+    before { subject.stub!(:random_number).and_return "4" }
+
+    it "adds a digit to the end of the number" do 
+      subject.update_number
+      subject.number.should eq "1234"
+    end
+  end
+
+  describe "#collect_attempt" do 
+
+    context "when the @number is 1 digit long" do 
+    
+      before { subject.number = "3" }
+
+      it "asks for a 1 digits number" do 
+        subject.should_receive(:ask).with("3", :limit => 1).and_return(example_response)
+        subject.collect_attempt
+      end 
+    end
+
+    context "when the @number is 5 digits long" do 
+    
+      before { subject.number = long_number }
+
+      it "asks for a 5 digits number" do 
+        subject.should_receive(:ask).with(long_number, :limit => 5).and_return(long_response)
+        subject.collect_attempt
+      end 
+    end
+
+    context "sets @attempt" do
+
+      before { subject.number = "12345" }
+
+      it "based on the user's response" do 
+        subject.should_receive(:ask).with("12345", :limit => 5).and_return(long_response)
+        subject.collect_attempt
+        subject.attempt.should eq long_number
+      end
+    end
+  end
+
+  describe "#attempt_correct?" do 
+   
+    before { subject.number = "7" }
+
+    context "with a good attempt" do 
+
+      before { subject.attempt = "7" }
+
+      it "returns true" do 
+        subject.attempt_correct?.should be_true
+      end
+    end 
+
+    context "with a bad attempt" do 
+
+      before { subject.attempt = "9" }
+
+      it "returns true" do 
+        subject.attempt_correct?.should be_false
+      end
+    end
+  end
+
+  describe "#verify_attempt" do 
+    context "when the user is a good guesser" do 
+
+      before { subject.stub!(:attempt_correct?).and_return true }
+
+      it "congradulates them" do 
+        subject.should_receive(:speak).with('good')
+        subject.verify_attempt
+      end
+    end 
+
+    context "when the user guesses wrong" do 
+
+      before { subject.number  = "12345" }
+      before { subject.attempt = "12346" }
+
+      it "congradulates them" do 
+        subject.should_receive(:speak).with('4 times wrong, try again smarty')
+        subject.verify_attempt
+      end
+    end
+  end
+
+  describe "#reset" do 
+
+    before { subject.reset }
+
+    it "sets @number" do 
+      subject.number.should eq ''
+    end
+
+    it "sets @attempt" do 
+      subject.attempt.should eq ''
+    end
+  end
+
+  describe "#run" do 
+    it "loops the loop" do 
+      subject.should_receive :answer
+      subject.should_receive :reset
+
+      subject.should_receive :update_number
+      subject.should_receive :collect_attempt
+      subject.should_receive(:verify_attempt).and_throw :rspec_loop_stop
+
+      catch :rspec_loop_stop do 
+        subject.run
+      end
+    end
+  end
+end