punchblock 0.8.4 → 0.9.0

data/lib/punchblock/translator/asterisk/component/asterisk/input.rb

@@ -1,116 +0,0 @@
-module Punchblock
-  module Translator
-    class Asterisk
-      module Component
-        module Asterisk
-          class Input < Component
-
-            attr_reader :grammar, :buffer
-
-            def setup
-              @media_engine = call.translator.media_engine
-              @buffer       = ""
-            end
-
-            def execute
-              initial_timeout = @component_node.initial_timeout || -1
-              @inter_digit_timeout = @component_node.inter_digit_timeout || -1
-
-              return with_error 'option error', 'A grammar document is required.' unless @component_node.grammar
-              return with_error 'option error', 'A mode value other than DTMF is unsupported on Asterisk.' unless @component_node.mode == :dtmf
-              return with_error 'option error', 'An initial timeout value that is negative (and not -1) is invalid.' unless initial_timeout >= -1
-              return with_error 'option error', 'An inter-digit timeout value that is negative (and not -1) is invalid.' unless @inter_digit_timeout >= -1
-
-              send_ref
-
-              case @media_engine
-              when :asterisk, nil
-                @grammar = @component_node.grammar.value.clone
-                grammar.inline!
-                grammar.tokenize!
-                grammar.normalize_whitespace
-
-                begin_initial_timer initial_timeout/1000 unless initial_timeout == -1
-
-                component = current_actor
-
-                @active = true
-
-                call.register_handler :ami, :name => 'DTMF' do |event|
-                  component.process_dtmf! event['Digit'] if event['End'] == 'Yes'
-                end
-              end
-            end
-
-            def process_dtmf(digit)
-              return unless @active
-              pb_logger.trace "Processing incoming DTMF digit #{digit}"
-              buffer << digit
-              cancel_initial_timer
-              case (match = grammar.match buffer.dup)
-              when RubySpeech::GRXML::Match
-                pb_logger.trace "Found a match against buffer #{buffer}"
-                complete success_reason(match)
-              when RubySpeech::GRXML::NoMatch
-                pb_logger.trace "Buffer #{buffer} does not match grammar"
-                complete Punchblock::Component::Input::Complete::NoMatch.new
-              when RubySpeech::GRXML::PotentialMatch
-                pb_logger.trace "Buffer #{buffer} potentially matches grammar. Waiting..."
-                reset_inter_digit_timer
-              end
-            end
-
-            private
-
-            def begin_initial_timer(timeout)
-              pb_logger.trace "Setting initial timer for #{timeout} seconds"
-              @initial_timer = after timeout do
-                pb_logger.trace "Initial timer expired."
-                complete Punchblock::Component::Input::Complete::NoInput.new
-              end
-            end
-
-            def cancel_initial_timer
-              return unless @initial_timer
-              @initial_timer.cancel
-              @initial_timer = nil
-            end
-
-            def reset_inter_digit_timer
-              return if @inter_digit_timeout == -1
-              @inter_digit_timer ||= begin
-                pb_logger.trace "Setting inter-digit timer for #{@inter_digit_timeout/1000} seconds"
-                after @inter_digit_timeout/1000 do
-                  pb_logger.trace "Inter digit-timer expired."
-                  complete Punchblock::Component::Input::Complete::NoMatch.new
-                end
-              end
-              pb_logger.trace "Resetting inter-digit timer"
-              @inter_digit_timer.reset
-            end
-
-            def cancel_inter_digit_timer
-              return unless @inter_digit_timer
-              @inter_digit_timer.cancel
-              @inter_digit_timer = nil
-            end
-
-            def success_reason(match)
-              Punchblock::Component::Input::Complete::Success.new :mode           => match.mode,
-                                                                  :confidence     => match.confidence,
-                                                                  :utterance      => match.utterance,
-                                                                  :interpretation => match.interpretation
-            end
-
-            def complete(reason)
-              @active = false
-              cancel_initial_timer
-              cancel_inter_digit_timer
-              send_complete_event reason
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/punchblock/translator/asterisk/component/asterisk/output.rb

@@ -1,94 +0,0 @@
-require 'active_support/core_ext/string/filters'
-
-module Punchblock
-  module Translator
-    class Asterisk
-      module Component
-        module Asterisk
-          class Output < Component
-
-            def setup
-              @media_engine = @call.translator.media_engine
-            end
-
-            def execute
-              return with_error 'option error', 'An SSML document is required.' unless @component_node.ssml
-
-              return with_error 'option error', 'An interrupt-on value of speech is unsupported.' if @component_node.interrupt_on == :speech
-
-              [:start_offset, :start_paused, :repeat_interval, :repeat_times, :max_time].each do |opt|
-                return with_error 'option error', "A #{opt} value is unsupported on Asterisk." if @component_node.send opt
-              end
-
-              case @media_engine
-              when :asterisk, nil
-                return with_error 'option error', "A voice value is unsupported on Asterisk." if @component_node.voice
-
-                @execution_elements = @component_node.ssml.children.map do |node|
-                  case node
-                  when RubySpeech::SSML::Audio
-                    lambda { current_actor.play_audio! node.src }
-                  end
-                end.compact
-
-                @pending_actions = @execution_elements.count
-
-                send_ref
-
-                @interrupt_digits = '0123456789*#' if [:any, :dtmf].include? @component_node.interrupt_on
-
-                @execution_elements.each do |element|
-                  element.call
-                  wait :continue
-                  process_playback_completion
-                end
-              when :unimrcp
-                doc = @component_node.ssml.to_s.squish.gsub(/["\\]/) { |m| "\\#{m}" }
-                send_ref
-                @call.send_agi_action! 'EXEC MRCPSynth', doc, mrcpsynth_options do |complete_event|
-                  pb_logger.debug "MRCPSynth completed with #{complete_event}."
-                  send_complete_event success_reason
-                end
-              end
-            end
-
-            def process_playback_completion
-              @pending_actions -= 1
-              pb_logger.debug "Received action completion. Now waiting on #{@pending_actions} actions."
-              if @pending_actions < 1
-                pb_logger.debug "Sending complete event"
-                send_complete_event success_reason
-              end
-            end
-
-            def continue(event = nil)
-              signal :continue, event
-            end
-
-            def play_audio(path)
-              pb_logger.debug "Playing an audio file (#{path}) via STREAM FILE"
-              op = current_actor
-              @call.send_agi_action! 'STREAM FILE', path, @interrupt_digits do |complete_event|
-                pb_logger.debug "STREAM FILE completed with #{complete_event}. Signalling to continue execution."
-                op.continue! complete_event
-              end
-            end
-
-            private
-
-            def mrcpsynth_options
-              [].tap do |opts|
-                opts << 'i=any' if [:any, :dtmf].include? @component_node.interrupt_on
-                opts << "v=#{@component_node.voice}" if @component_node.voice
-              end.join '&'
-            end
-
-            def success_reason
-              Punchblock::Component::Output::Complete::Success.new
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/punchblock/component/tropo/conference_spec.rb

@@ -1,361 +0,0 @@
-require 'spec_helper'
-
-module Punchblock
-  module Component
-    module Tropo
-      describe Conference do
-        it 'registers itself' do
-          RayoNode.class_from_registration(:conference, 'urn:xmpp:tropo:conference:1').should == Conference
-        end
-
-        describe "when setting options in initializer" do
-          subject do
-            Conference.new :name              => '1234',
-                           :terminator        => '#',
-                           :moderator         => true,
-                           :tone_passthrough  => true,
-                           :mute              => false,
-                           :announcement      => {:text => "Welcome to Rayo", :voice => 'shelly'},
-                           :music             => {:text => "The moderator how not yet joined.. Listen to this awesome music while you wait.", :voice => 'frank'}
-          end
-
-          its(:name)              { should == '1234' }
-          its(:mute)              { should == false }
-          its(:terminator)        { should == '#' }
-          its(:tone_passthrough)  { should == true }
-          its(:moderator)         { should == true }
-          its(:announcement)      { should == Conference::Announcement.new(:text => "Welcome to Rayo", :voice => 'shelly') }
-          its(:music)             { should == Conference::Music.new(:text => "The moderator how not yet joined.. Listen to this awesome music while you wait.", :voice => 'frank') }
-        end
-
-        its(:mute_status_name) { should == :unknown_mute }
-        its(:hold_status_name) { should == :unknown_hold }
-
-        describe "#==" do
-          subject { Conference.new :name => 'the-conference' }
-          let(:conference2) { Conference.new :name => 'the-conference' }
-          let(:conference3) { Conference.new :name => 'other-conference' }
-
-          it { should == conference2 }
-          it { should_not == conference3 }
-        end
-
-        describe "#add_event" do
-          describe "with an on-hold" do
-            it "should call #onhold!" do
-              subject.expects(:onhold!).once
-              subject.add_event Conference::OnHold.new
-            end
-          end
-
-          describe "with an off-hold" do
-            it "should call #offhold!" do
-              subject.expects(:offhold!).once
-              subject.add_event Conference::OffHold.new
-            end
-          end
-        end
-
-        describe "#requested" do
-          context "when requesting to be muted" do
-            subject { Conference.new :mute => true }
-            before { subject.request! }
-            its(:mute_status_name) { should == :muted }
-          end
-
-          context "when requesting not to be muted" do
-            subject { Conference.new :mute => false }
-            before { subject.request! }
-            its(:mute_status_name) { should == :unmuted }
-          end
-        end
-
-        describe "#onhold!" do
-          before do
-            subject.onhold!
-          end
-
-          its(:hold_status_name) { should == :onhold }
-
-          it "should raise a StateMachine::InvalidTransition when received a second time" do
-            lambda { subject.onhold! }.should raise_error(StateMachine::InvalidTransition)
-          end
-        end
-
-        describe "#offhold!" do
-          before do
-            subject.onhold!
-            subject.offhold!
-          end
-
-          its(:hold_status_name) { should == :offhold }
-
-          it "should raise a StateMachine::InvalidTransition when received a second time" do
-            lambda { subject.offhold! }.should raise_error(StateMachine::InvalidTransition)
-          end
-        end
-
-        describe "actions" do
-          let(:mock_client) { mock 'Client' }
-          let(:conference) { Conference.new :name => '1234' }
-
-          before do
-            conference.component_id = 'abc123'
-            conference.call_id = '123abc'
-            conference.client = mock_client
-          end
-
-          describe '#mute_action' do
-            subject { conference.mute_action }
-
-            it { should be_a Command::Mute }
-            its(:component_id) { should == 'abc123' }
-            its(:call_id) { should == '123abc' }
-          end
-
-          describe '#mute!' do
-            describe "when unmuted" do
-              before do
-                conference.request!
-                conference.execute!
-              end
-
-              it "should send its command properly" do
-                mock_client.expects(:execute_command).with(conference.mute_action, :call_id => '123abc', :component_id => 'abc123').returns true
-                conference.expects :muted!
-                conference.mute!
-              end
-            end
-
-            describe "when muted" do
-              before { conference.muted! }
-
-              it "should raise an error" do
-                lambda { conference.mute! }.should raise_error(InvalidActionError, "Cannot mute a Conference that is already muted")
-              end
-            end
-          end
-
-          describe "#muted!" do
-            before do
-              subject.request!
-              subject.execute!
-              subject.muted!
-            end
-
-            its(:mute_status_name) { should == :muted }
-
-            it "should raise a StateMachine::InvalidTransition when received a second time" do
-              lambda { subject.muted! }.should raise_error(StateMachine::InvalidTransition)
-            end
-          end
-
-          describe '#unmute_action' do
-            subject { conference.unmute_action }
-
-            it { should be_a Command::Unmute }
-            its(:component_id) { should == 'abc123' }
-            its(:call_id) { should == '123abc' }
-          end
-
-          describe '#unmute!' do
-            before do
-              conference.request!
-              conference.execute!
-            end
-
-            describe "when muted" do
-              before do
-                conference.muted!
-              end
-
-              it "should send its command properly" do
-                mock_client.expects(:execute_command).with(conference.unmute_action, :call_id => '123abc', :component_id => 'abc123').returns true
-                conference.expects :unmuted!
-                conference.unmute!
-              end
-            end
-
-            describe "when unmuted" do
-              it "should raise an error" do
-                lambda { conference.unmute! }.should raise_error(InvalidActionError, "Cannot unmute a Conference that is not muted")
-              end
-            end
-          end
-
-          describe "#unmuted!" do
-            before do
-              subject.request!
-              subject.execute!
-              subject.muted!
-              subject.unmuted!
-            end
-
-            its(:mute_status_name) { should == :unmuted }
-
-            it "should raise a StateMachine::InvalidTransition when received a second time" do
-              lambda { subject.unmuted! }.should raise_error(StateMachine::InvalidTransition)
-            end
-          end
-
-          describe '#stop_action' do
-            subject { conference.stop_action }
-
-            its(:to_xml) { should == '<stop xmlns="urn:xmpp:rayo:1"/>' }
-            its(:component_id) { should == 'abc123' }
-            its(:call_id) { should == '123abc' }
-          end
-
-          describe '#stop!' do
-            describe "when the command is executing" do
-              before do
-                conference.request!
-                conference.execute!
-              end
-
-              it "should send its command properly" do
-                mock_client.expects(:execute_command).with(conference.stop_action, :call_id => '123abc', :component_id => 'abc123')
-                conference.stop!
-              end
-            end
-
-            describe "when the command is not executing" do
-              it "should raise an error" do
-                lambda { conference.stop! }.should raise_error(InvalidActionError, "Cannot stop a Conference that is not executing")
-              end
-            end
-          end # describe #stop!
-
-          describe '#kick_action' do
-            subject { conference.kick_action :message => 'bye!' }
-
-            its(:to_xml) { should == '<kick xmlns="urn:xmpp:tropo:conference:1">bye!</kick>' }
-            its(:component_id) { should == 'abc123' }
-            its(:call_id) { should == '123abc' }
-          end
-
-          describe '#kick!' do
-            describe "when the command is executing" do
-              before do
-                conference.request!
-                conference.execute!
-              end
-
-              it "should send its command properly" do
-                mock_client.expects(:execute_command).with(conference.kick_action(:message => 'bye!'), :call_id => '123abc', :component_id => 'abc123')
-                conference.kick! :message => 'bye!'
-              end
-            end
-
-            describe "when the command is not executing" do
-              it "should raise an error" do
-                lambda { conference.kick! }.should raise_error(InvalidActionError, "Cannot kick a Conference that is not executing")
-              end
-            end
-          end # describe #kick!
-        end
-
-        describe Conference::OnHold do
-          it 'registers itself' do
-            RayoNode.class_from_registration(:'on-hold', 'urn:xmpp:tropo:conference:1').should == Conference::OnHold
-          end
-
-          describe "from a stanza" do
-            let(:stanza) { "<on-hold xmlns='urn:xmpp:tropo:conference:1'/>" }
-
-            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
-
-            it { should be_instance_of Conference::OnHold }
-
-            it_should_behave_like 'event'
-          end
-        end
-
-        describe Conference::OffHold do
-          it 'registers itself' do
-            RayoNode.class_from_registration(:'off-hold', 'urn:xmpp:tropo:conference:1').should == Conference::OffHold
-          end
-
-          describe "from a stanza" do
-            let(:stanza) { "<off-hold xmlns='urn:xmpp:tropo:conference:1'/>" }
-
-            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
-
-            it { should be_instance_of Conference::OffHold }
-
-            it_should_behave_like 'event'
-          end
-        end
-
-        describe Conference::Speaking do
-          it 'registers itself' do
-            RayoNode.class_from_registration(:speaking, 'urn:xmpp:tropo:conference:1').should == Conference::Speaking
-          end
-
-          describe "from a stanza" do
-            let(:stanza) { "<speaking xmlns='urn:xmpp:tropo:conference:1' call-id='abc123'/>" }
-
-            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
-
-            it { should be_instance_of Conference::Speaking }
-
-            it_should_behave_like 'event'
-
-            its(:speaking_call_id) { should == 'abc123' }
-          end
-        end
-
-        describe Conference::FinishedSpeaking do
-          it 'registers itself' do
-            RayoNode.class_from_registration(:'finished-speaking', 'urn:xmpp:tropo:conference:1').should == Conference::FinishedSpeaking
-          end
-
-          describe "from a stanza" do
-            let(:stanza) { "<finished-speaking xmlns='urn:xmpp:tropo:conference:1' call-id='abc123'/>" }
-
-            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
-
-            it { should be_instance_of Conference::FinishedSpeaking }
-
-            it_should_behave_like 'event'
-
-            its(:speaking_call_id) { should == 'abc123' }
-          end
-        end
-
-        describe Conference::Complete::Kick do
-          let :stanza do
-            <<-MESSAGE
-<complete xmlns='urn:xmpp:rayo:ext:1'>
-  <kick xmlns='urn:xmpp:tropo:conference:complete:1'>wouldn't stop talking</kick>
-</complete>
-            MESSAGE
-          end
-
-          subject { RayoNode.import(parse_stanza(stanza).root).reason }
-
-          it { should be_instance_of Conference::Complete::Kick }
-
-          its(:name)    { should == :kick }
-          its(:details) { should == "wouldn't stop talking" }
-        end
-
-        describe Conference::Complete::Terminator do
-          let :stanza do
-            <<-MESSAGE
-<complete xmlns='urn:xmpp:rayo:ext:1'>
-  <terminator xmlns='urn:xmpp:tropo:conference:complete:1' />
-</complete>
-            MESSAGE
-          end
-
-          subject { RayoNode.import(parse_stanza(stanza).root).reason }
-
-          it { should be_instance_of Conference::Complete::Terminator }
-
-          its(:name) { should == :terminator }
-        end
-      end
-    end
-  end
-end # Punchblock