adhearsion 1.2.6 → 2.0.0.alpha1

data/lib/adhearsion/tasks/configuration.rb

@@ -0,0 +1,26 @@
+require 'adhearsion/punchblock_plugin'
+
+begin
+  Adhearsion.config # load default config vlaues
+  require "#{Dir.pwd}/config/adhearsion.rb"
+rescue Exception => ex
+  STDERR.puts "\nError while loading application configuration file: #{ex}"
+end
+
+namespace :adhearsion do
+
+  namespace :config do
+
+    desc "Show configuration values in STDOUT; it accepts a parameter: [nil|platform|<plugin-name>|all]"
+    task :show, :name do |t, args|
+      name = args.name.nil? ? :all : args.name.to_sym
+      puts Adhearsion.config.description name, :show_values => true
+    end
+
+    desc "Show configuration description in STDOUT; it accepts a parameter: [nil|platform|<plugin-name>|all]"
+    task :desc, :name do |t, args|
+      name = args.name.nil? ? :all : args.name.to_sym
+      puts Adhearsion.config.description name, :show_values => false
+    end
+  end
+end

data/lib/adhearsion/tasks/plugins.rb

@@ -0,0 +1,17 @@
+require 'adhearsion/punchblock_plugin'
+
+namespace :adhearsion do
+
+  desc "List the configured plugins"
+  task :plugins do |t,args|
+    if Adhearsion::Plugin.subclasses.length > 0
+      puts "You have #{Adhearsion::Plugin.subclasses.length} plugin(s) in your Adhearsion application:\n"
+      Adhearsion::Plugin.subclasses.each do |plugin|
+        puts "* #{plugin.plugin_name}: #{plugin.name}"
+      end
+    else
+      puts "There is no Adhearsion plugin used in your application"
+    end
+    puts "\n"
+  end
+end

data/lib/adhearsion/version.rb

@@ -1,36 +1,30 @@
 module Adhearsion #:nodoc:
-  module VERSION #:nodoc:
-    MAJOR = 1 unless defined? MAJOR
-    MINOR = 2 unless defined? MINOR
-    TINY  = 6 unless defined? TINY
-
-    STRING = [MAJOR, MINOR, TINY].join('.') unless defined? STRING
-  end
+  VERSION = '2.0.0.alpha1'
 
   class PkgVersion
     include Comparable
 
     attr_reader :major, :minor, :revision
 
-    def initialize(version="")
-      version = "" if version.nil?
+    def initialize(version = nil)
+      version ||= ""
       @major, @minor, @revision, @patchlevel = version.split(".", 4).map(&:to_i)
       @major = 0 unless @major
     end
 
     def <=>(other)
-      return @major <=> other.major if ((@major <=> other.major) != 0)
-      return @minor <=> other.minor if ((@minor <=> other.minor) != 0)
-      return @revision <=> other.revision if ((@revision <=> other.revision) != 0)
+      return @major     <=> other.major     unless (@major <=> other.major) == 0
+      return @minor     <=> other.minor     unless (@minor <=> other.minor) == 0
+      return @revision  <=> other.revision  unless (@revision <=> other.revision) == 0
       return 0
     end
 
     def self.sort
-      self.sort!{|a,b| a <=> b}
+      self.sort! { |a,b| a <=> b }
     end
 
     def to_s
-      @major.to_s + "." + @minor.to_s + "." + @revision.to_s
+      "#{@major}.#{@minor}.#{@revision}"
     end
   end
 end

data/spec/adhearsion/call_controller/dial_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    describe Dial do
+      include CallControllerTestHelpers
+
+      let(:to) { 'sip:foo@bar.com' }
+
+      let(:other_call_id) { rand }
+      let(:other_mock_call) { flexmock OutboundCall.new, :id => other_call_id }
+
+      let(:mock_end) { flexmock Punchblock::Event::End.new, :reason => :hangup }
+      let(:mock_answered) { Punchblock::Event::Answered.new }
+
+      #added for multiple dial testing
+      let(:second_to) { 'sip:baz@bar.com' }
+      let(:second_other_call_id) { rand }
+      let(:second_other_mock_call) { flexmock OutboundCall.new, :id => second_other_call_id }
+
+      def mock_dial
+        flexmock(OutboundCall).new_instances.should_receive(:dial).and_return true
+      end
+
+      describe "#dial" do
+        it "should create a new call and return it" do
+          mock_dial
+          Thread.new do
+            subject.dial(to).should be_a OutboundCall
+          end
+          other_mock_call << mock_end
+        end
+
+        it "should dial the call to the correct endpoint" do
+          other_mock_call
+          flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+          flexmock(other_mock_call).should_receive(:dial).with(to, :from => 'foo').once
+          dial_thread = Thread.new do
+            subject.dial to, :from => 'foo'
+          end
+          sleep 0.1
+          other_mock_call << mock_end
+          dial_thread.join.should be_true
+        end
+
+        describe "without a block" do
+          it "blocks the original dialplan until the new call ends" do
+            other_mock_call
+
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+
+            latch = CountDownLatch.new 1
+
+            Thread.new do
+              subject.dial to
+              latch.countdown!
+            end
+
+            latch.wait(1).should be_false
+
+            other_mock_call << mock_end
+
+            latch.wait(1).should be_true
+          end
+
+          it "joins the new call to the existing one on answer" do
+            other_mock_call
+
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(other_mock_call).should_receive(:join).once.with(call_id)
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+
+            latch = CountDownLatch.new 1
+
+            Thread.new do
+              subject.dial to
+              latch.countdown!
+            end
+
+            latch.wait(1).should be_false
+
+            other_mock_call << mock_answered
+            other_mock_call << mock_end
+
+            latch.wait(1).should be_true
+          end
+        end
+
+        describe "with multiple third parties specified" do
+          it "dials all parties and joins the first one to answer, hanging up the rest" do
+            other_mock_call
+            second_other_mock_call
+
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(other_mock_call).should_receive(:join).once.with(call_id)
+            flexmock(other_mock_call).should_receive(:hangup!).never
+
+            flexmock(second_other_mock_call).should_receive(:dial).once
+            flexmock(second_other_mock_call).should_receive(:hangup!).once
+
+
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call, second_other_mock_call
+            latch = CountDownLatch.new 1
+
+            Thread.new do
+              subject.dial [to, second_to]
+              latch.countdown!
+            end
+
+            latch.wait(1).should be_false
+
+            other_mock_call << mock_answered
+            other_mock_call << mock_end
+
+            latch.wait(1).should be_true
+          end
+        end
+
+        describe "with a timeout specified" do
+          it "should abort the dial after the specified timeout"
+        end
+
+        describe "with a from specified" do
+          it "originates the call from the specified caller ID"
+        end
+
+      	describe "with a block" do
+          it "uses the block as the dialplan for the new call"
+
+          it "joins the new call to the existing call once the block returns"
+
+          it "does not try to join the calls if the new call is hungup when the block returns"
+        end
+      end#describe #dial
+    end
+  end
+end

data/spec/adhearsion/call_controller/input_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    describe Input do
+      include CallControllerTestHelpers
+
+      describe "#grammar_digits" do
+        let(:grxml) {
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
+            rule id: 'inputdigits', scope: 'public' do
+              item repeat: '2' do
+                one_of do
+                  0.upto(9) { |d| item { d.to_s } }
+                end
+              end
+            end
+          end
+        }
+
+        it 'generates the correct GRXML grammar' do
+          subject.grammar_digits(2).to_s.should == grxml.to_s
+        end
+
+      end # describe #grammar_digits
+
+      describe "#grammar_accept" do
+        let(:grxml) {
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
+            rule id: 'inputdigits', scope: 'public' do
+              one_of do
+                item { '3' }
+                item { '5' }
+              end
+            end
+          end
+        }
+
+        it 'generates the correct GRXML grammar' do
+          subject.grammar_accept('35').to_s.should == grxml.to_s
+        end
+
+        it 'filters meaningless characters out' do
+          subject.grammar_accept('3+5').to_s.should == grxml.to_s
+        end
+      end # grammar_accept
+
+      describe "#parse_single_dtmf"  do
+        it "correctly returns the parsed input" do
+          subject.parse_single_dtmf("dtmf-3").should == '3'
+        end
+
+        it "correctly returns star as *" do
+          subject.parse_single_dtmf("dtmf-star").should == '*'
+        end
+
+        it "correctly returns pound as #" do
+          subject.parse_single_dtmf("dtmf-pound").should == '#'
+        end
+
+        it "correctly returns nil when input is nil" do
+          subject.parse_single_dtmf(nil).should == nil
+        end
+      end # describe #grammar_accept
+
+      describe "#wait_for_digit" do
+        let(:timeout) { 2 }
+        let(:timeout_ms) { 2000 }
+
+        let(:grxml) {
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
+            rule id: 'inputdigits', scope: 'public' do
+              one_of do
+                0.upto(9) { |d| item { d.to_s } }
+                item { "#" }
+                item { "*" }
+              end
+            end
+          end
+        }
+
+        let(:input_component) {
+          Punchblock::Component::Input.new(
+            { :mode => :dtmf,
+              :initial_timeout => timeout_ms,
+              :inter_digit_timeout => timeout_ms,
+              :grammar => {
+                :value => grxml.to_s
+              }
+            }
+          )
+        }
+
+        def expect_component_complete_event
+          complete_event = Punchblock::Event::Complete.new
+          flexmock(complete_event).should_receive(:reason => flexmock(:interpretation => 'dtmf-5', :name => :input))
+          flexmock(Punchblock::Component::Input).new_instances do |input|
+            input.should_receive(:complete?).and_return(false)
+            input.should_receive(:complete_event).and_return(complete_event)
+          end
+        end
+
+        it "sends the correct input component" do
+          expect_component_complete_event
+          subject.should_receive(:execute_component_and_await_completion).once.with(input_component).and_return input_component
+          subject.wait_for_digit timeout
+        end
+
+        it "returns the correct pressed digit" do
+          expect_component_complete_event
+          subject.should_receive(:execute_component_and_await_completion).once.with(Punchblock::Component::Input).and_return input_component
+          subject.wait_for_digit(timeout).should == '5'
+        end
+
+        context "with a nil timeout" do
+          let(:timeout)     { nil }
+          let(:timeout_ms)  { nil }
+
+          it "does not set a timeout on the component" do
+            expect_component_complete_event
+            subject.should_receive(:execute_component_and_await_completion).once.with(input_component).and_return input_component
+            subject.wait_for_digit timeout
+          end
+        end
+      end # wait_for_digit
+
+      describe "#input!" do
+        describe "simple usage" do
+          let(:timeout) { 3000 }
+
+          it "can be called with no arguments" do
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('1')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input!
+          end
+
+          it "can be called with 1 digit as an argument" do
+            subject.should_receive(:wait_for_digit).with(nil)
+            subject.input! 1
+          end
+
+          it "accepts a timeout argument" do
+            subject.should_receive(:wait_for_digit).with(3000)
+            subject.input! :timeout => timeout
+          end
+        end
+
+        describe "any number of digits with a terminator" do
+          let(:terminator) { '9' }
+
+          it "called with no arguments, it returns any number of digits taking a terminating digit" do
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('1')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input!.should == '1'
+          end
+
+          it "allows to set a different terminator" do
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('1')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return(terminator)
+            subject.input!(:terminator => terminator).should == '1'
+          end
+        end
+
+        describe "with a fixed number or digits" do
+          it "accepts and returns three digits without a terminator" do
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('1')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('2')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('3')
+            subject.input!(3).should == '123'
+          end
+        end
+
+        describe "with play arguments" do
+          let(:string_play)   { "Thanks for calling" }
+          let(:ssml_play)     { RubySpeech::SSML.draw { string "Please stand by" } }
+          let(:hash_play)     { {:value => Time.parse("24/10/2011"), :strftime => "%H:%M"} }
+          let(:hash_value)    { Time.parse "24/10/2011" }
+          let(:hash_options)  { {:strftime => "%H:%M"} }
+
+          it "plays a string argument" do
+            subject.should_receive(:interruptible_play!).with(string_play)
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input! :play => string_play
+          end
+
+          it "plays a SSML argument" do
+            subject.should_receive(:interruptible_play!).with(ssml_play)
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input! :play => ssml_play
+          end
+
+          it "plays a Hash argument" do
+            subject.should_receive(:interruptible_play!).with([hash_value, hash_options])
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input! :play => hash_play
+          end
+
+          it "plays an array of mixed arguments" do
+            subject.should_receive(:interruptible_play!).with(string_play)
+            subject.should_receive(:interruptible_play!).with(ssml_play)
+            subject.should_receive(:interruptible_play!).with([hash_value, hash_options])
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input! :play => [string_play, ssml_play, hash_play]
+          end
+
+          it "plays a string argument, takes 1 digit and returns the input" do
+            subject.should_receive(:interruptible_play!).with(string_play).and_return('1')
+            subject.input!(1, :play => string_play).should == '1'
+          end
+
+          it "plays a string argument, takes 2 digits and returns the input" do
+            subject.should_receive(:interruptible_play!).with(string_play).and_return('1')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('1')
+            subject.input!(2, :play => string_play).should == '11'
+          end
+
+          it "plays a string argument, allows for any number of digit and an accept key" do
+            subject.should_receive(:interruptible_play!).with(string_play).and_return('1').ordered
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('2').ordered
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#').ordered
+            subject.input!(:play => string_play).should == '12'
+          end
+
+          it "plays an array of mixed arguments, stops playing when a key is pressed, and returns the input" do
+            subject.should_receive(:interruptible_play!).and_return(nil, '1', StandardError.new("should not be called"))
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input!(:play => [string_play, ssml_play, hash_play]).should == '1'
+          end
+        end # describe with play arguments
+
+        describe "non interruptible play" do
+          let(:string_play) { "Thanks for calling" }
+
+          it "calls play! when passed :interruptible => false" do
+            subject.should_receive(:play!).with(string_play)
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input! :play => string_play, :interruptible => false
+          end
+
+          it "still collects digits when passed :interruptible => false" do
+            subject.should_receive(:play!).with(string_play)
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('1')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input!(:play => string_play, :interruptible => false).should == '1'
+          end
+        end # describe non interruptible play
+
+        describe "speak functionality" do
+          let(:string_speak) { "Thanks for calling" }
+
+          it "speaks passed text" do
+            subject.should_receive(:interruptible_play!).with(string_speak, {})
+            subject.input! :speak => {:text => string_speak }
+          end
+
+          it "speaks passed text and collect digits" do
+            subject.should_receive(:interruptible_play!).with(string_speak, {}).and_return('1')
+            subject.should_receive(:wait_for_digit).once.with(nil).and_return('#')
+            subject.input!(:speak => {:text => string_speak }).should == '1'
+          end
+        end
+
+        it 'throws an exception when playback fails'
+      end # describe input!
+
+      describe "#input" do
+        let(:string_play) { "Thanks for calling" }
+
+        it "just calls #input!" do
+          subject.should_receive(:input!).with(:play => string_play).and_return(nil)
+          subject.input! :play => string_play
+        end
+
+        it 'does not throw exceptions when playback fails'
+      end # describe input
+    end
+  end
+end