punchblock 1.9.4 → 2.0.0.beta1

data/lib/punchblock/translator/freeswitch/component/flite_output.rb

@@ -8,7 +8,7 @@ module Punchblock
           private
 
           def document
-            @component_node.ssml.inner_text.to_s
+            @component_node.render_documents.first.value.inner_text.to_s
           end
         end
       end

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

@@ -8,6 +8,11 @@ module Punchblock
 
           include InputComponent
 
+          def execute
+            super
+            @dtmf_handler_id = register_dtmf_event_handler
+          end
+
           private
 
           def register_dtmf_event_handler

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

@@ -17,7 +17,7 @@ module Punchblock
           end
 
           def filenames
-            @filenames ||= @component_node.ssml.children.map do |node|
+            @filenames ||= @component_node.render_documents.first.value.children.map do |node|
               case node
               when RubySpeech::SSML::Audio
                 node.src
@@ -42,7 +42,7 @@ module Punchblock
           def complete_reason_for_event(event)
             case event[:application_response]
             when 'FILE PLAYED'
-              success_reason
+              finish_reason
             else
               Punchblock::Event::Complete::Error.new(:details => "Engine error: #{event[:application_response]}")
             end

data/lib/punchblock/translator/freeswitch/component/record.rb

@@ -13,11 +13,11 @@ module Punchblock
 
           def execute
             max_duration = @component_node.max_duration || -1
+            initial_timeout = @component_node.initial_timeout || -1
+            final_timeout = @component_node.final_timeout || -1
 
             raise OptionError, 'A start-beep value of true is unsupported.' if @component_node.start_beep
             raise OptionError, 'A start-paused value of true is unsupported.' if @component_node.start_paused
-            raise OptionError, 'An initial-timeout value is unsupported.' if @component_node.initial_timeout && @component_node.initial_timeout != -1
-            raise OptionError, 'A final-timeout value is unsupported.' if @component_node.final_timeout && @component_node.final_timeout != -1
             raise OptionError, 'A max-duration value that is negative (and not -1) is invalid.' unless max_duration >= -1
 
             @format = @component_node.format || 'wav'
@@ -29,16 +29,18 @@ module Punchblock
 
             record_args = ['start', filename]
             record_args << max_duration/1000 unless max_duration == -1
-            case @component_node.direction
-            when :send
-              call.uuid_foo :setvar, "RECORD_WRITE_ONLY true"
-            when :recv
-              call.uuid_foo :setvar, "RECORD_READ_ONLY true"
-            else
-              call.uuid_foo :setvar, "RECORD_STEREO true"
+
+            direction = case @component_node.direction
+            when :send then :RECORD_WRITE_ONLY
+            when :recv then :RECORD_READ_ONLY
+            else            :RECORD_STEREO
             end
-            call.uuid_foo :record, record_args.join(' ')
+            setvar direction, true
+
+            setvar :RECORD_INITIAL_TIMEOUT_MS, initial_timeout > -1 ? initial_timeout : 0
+            setvar :RECORD_FINAL_TIMEOUT_MS, final_timeout > -1 ? final_timeout : 0
 
+            call.uuid_foo :record, record_args.join(' ')
             send_ref
           rescue OptionError => e
             with_error 'option error', e.message
@@ -56,11 +58,15 @@ module Punchblock
           end
 
           def finished
-            send_complete_event(@complete_reason || success_reason)
+            send_complete_event(@complete_reason || max_duration_reason)
           end
 
           private
 
+          def setvar(key, value)
+            call.uuid_foo :setvar, "#{key} #{value}"
+          end
+
           def filename
             File.join RECORDING_BASE_PATH, [id, @format].join('.')
           end
@@ -73,8 +79,8 @@ module Punchblock
             Punchblock::Event::Complete::Stop.new
           end
 
-          def success_reason
-            Punchblock::Component::Record::Complete::Success.new
+          def max_duration_reason
+            Punchblock::Component::Record::Complete::MaxDuration.new
           end
 
           def send_complete_event(reason)

data/lib/punchblock/translator/freeswitch/component/tts_output.rb

@@ -9,14 +9,14 @@ module Punchblock
 
           def do_output(engine, default_voice = nil)
             register_handler :es, :event_name => 'CHANNEL_EXECUTE_COMPLETE' do |event|
-              send_complete_event success_reason
+              send_complete_event finish_reason
             end
             voice = @component_node.voice || default_voice || 'kal'
             application :speak, [engine, voice, document].join('|')
           end
 
           def document
-            @component_node.ssml.to_s
+            @component_node.render_documents.first.value.to_s
           end
         end
       end

data/lib/punchblock/translator/freeswitch/component.rb

@@ -45,10 +45,7 @@ module Punchblock
           def send_complete_event(reason, recording = nil)
             return if @complete
             @complete = true
-            event = Punchblock::Event::Complete.new.tap do |c|
-              c.reason = reason
-              c << recording if recording
-            end
+            event = Punchblock::Event::Complete.new reason: reason, recording: recording
             send_event event
             terminate
           end
@@ -82,7 +79,7 @@ module Punchblock
           end
 
           def send_ref
-            set_node_response Ref.new :id => id
+            set_node_response Ref.new uri: id
           end
 
           def with_error(name, text)

data/lib/punchblock/translator/freeswitch.rb

@@ -34,8 +34,8 @@ module Punchblock
         @calls[call.id] ||= call
       end
 
-      def deregister_call(call)
-        @calls.delete call.id
+      def deregister_call(id)
+        @calls.delete id
       end
 
       def call_with_id(call_id)

data/lib/punchblock/translator/input_component.rb

@@ -5,15 +5,9 @@ module Punchblock
     module InputComponent
       def execute
         validate
-
-        @recognizer = DTMFRecognizer.new self,
-                                         @component_node.grammar.value,
-                                         (@component_node.initial_timeout || -1),
-                                         (@component_node.inter_digit_timeout || -1)
-
+        setup_dtmf_recognizer
         send_ref
-
-        @dtmf_handler_id = register_dtmf_event_handler
+        start_timers
       rescue OptionError => e
         with_error 'option error', e.message
       end
@@ -32,8 +26,8 @@ module Punchblock
         end
       end
 
-      def match(mode, confidence, utterance, interpretation)
-        complete Punchblock::Component::Input::Complete::Success.new(:mode => mode, :confidence => confidence, :utterance => utterance, :interpretation => interpretation)
+      def match(match)
+        complete success_reason(match)
       end
 
       def nomatch
@@ -46,14 +40,40 @@ module Punchblock
 
       private
 
+      def input_node
+        @component_node
+      end
+
       def validate
-        raise OptionError, 'A grammar document is required.' unless @component_node.grammar
-        raise OptionError, 'A mode value other than DTMF is unsupported.' unless @component_node.mode == :dtmf
+        raise OptionError, 'A grammar document is required.' unless input_node.grammars.first
+        raise OptionError, 'Only a single grammar is supported.' unless input_node.grammars.size == 1
+        raise OptionError, 'A mode value other than DTMF is unsupported.' unless input_node.mode == :dtmf
+      end
+
+      def setup_dtmf_recognizer
+        @recognizer = DTMFRecognizer.new self,
+                        input_node.grammars.first.value,
+                        (input_node.initial_timeout || -1),
+                        (input_node.inter_digit_timeout || -1),
+                        input_node.terminator
+      end
+
+      def start_timers
+        @recognizer.start_timers
+      end
+
+      def success_reason(match)
+        nlsml = RubySpeech::NLSML.draw do
+          interpretation confidence: match.confidence do
+            instance match.interpretation
+            input match.utterance, mode: match.mode
+          end
+        end
+        Punchblock::Component::Input::Complete::Match.new :nlsml => nlsml
       end
 
       def complete(reason)
         unregister_dtmf_event_handler
-        @recognizer.finalize if @recognizer
         send_complete_event reason
       end
     end

data/lib/punchblock/uri_list.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Punchblock
+  class URIList < SimpleDelegator
+    def self.import(string)
+      new string.strip.split("\n").map(&:strip)
+    end
+
+    def initialize(*list)
+      super list.flatten
+    end
+
+    def to_s
+      join("\n")
+    end
+
+    def ==(other)
+      self.__getobj__ == other.to_ary
+    end
+  end
+end

data/lib/punchblock/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Punchblock
-  VERSION = "1.9.4"
+  VERSION = "2.0.0.beta1"
 end

data/lib/punchblock.rb

@@ -4,6 +4,7 @@
   active_support/dependencies/autoload
   active_support/core_ext/object/blank
   active_support/core_ext/module/delegation
+  active_support/inflector
   future-resource
   has_guarded_handlers
   ruby_speech
@@ -22,11 +23,11 @@ module Punchblock
   autoload :DeadActorSafety
   autoload :DisconnectedError
   autoload :HasHeaders
-  autoload :Header
   autoload :MediaNode
   autoload :ProtocolError
   autoload :RayoNode
   autoload :Translator
+  autoload :URIList
 
   class << self
     def logger
@@ -50,7 +51,7 @@ module Punchblock
     # @return [Punchblock::Client] a punchblock client object
     #
     def client_with_connection(type, options)
-      connection = Connection.const_get(type.to_s.classify).new options
+      connection = Connection.const_get(type == :xmpp ? 'XMPP' : type.to_s.classify).new options
       Client.new :connection => connection
     rescue NameError
       raise ArgumentError, "Connection type #{type.inspect} is not valid."
@@ -74,7 +75,7 @@ module Punchblock
   RAYO_VERSION            = '1'
   RAYO_NAMESPACES         = {:core => [BASE_RAYO_NAMESPACE, RAYO_VERSION].compact.join(':')}
 
-  [:ext, :record, :output, :input].each do |ns|
+  [:ext, :record, :output, :input, :prompt].each do |ns|
     RAYO_NAMESPACES[ns] = [BASE_RAYO_NAMESPACE, ns.to_s, RAYO_VERSION].compact.join(':')
     RAYO_NAMESPACES[:"#{ns}_complete"] = [BASE_RAYO_NAMESPACE, ns.to_s, 'complete', RAYO_VERSION].compact.join(':')
   end

data/punchblock.gemspec

@@ -22,17 +22,18 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.3.7") if s.respond_to? :required_rubygems_version=
 
-  s.add_runtime_dependency %q<niceogiri>, ["~> 1.1"]
   s.add_runtime_dependency %q<nokogiri>, ["~> 1.5", ">= 1.5.6"]
   s.add_runtime_dependency %q<blather>, [">= 0.7.0"]
-  s.add_runtime_dependency %q<activesupport>, ["~> 3.0"]
+  s.add_runtime_dependency %q<activesupport>, [">= 3.0.0", "< 5.0.0"]
   s.add_runtime_dependency %q<state_machine>, ["~> 1.0"]
   s.add_runtime_dependency %q<future-resource>, ["~> 1.0"]
   s.add_runtime_dependency %q<has-guarded-handlers>, ["~> 1.5"]
   s.add_runtime_dependency %q<celluloid>, ["~> 0.14"]
   s.add_runtime_dependency %q<ruby_ami>, ["~> 2.0"]
   s.add_runtime_dependency %q<ruby_fs>, ["~> 1.1"]
-  s.add_runtime_dependency %q<ruby_speech>, ["~> 1.0"]
+  s.add_runtime_dependency %q<ruby_speech>, ["~> 2.0"]
+  s.add_runtime_dependency %q<virtus>
+  s.add_runtime_dependency %q<ruby_jid>, ["~> 1.0"]
 
   s.add_development_dependency %q<bundler>, ["~> 1.0"]
   s.add_development_dependency %q<rspec>, ["~> 2.7"]
@@ -43,4 +44,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency %q<countdownlatch>, [">= 0"]
   s.add_development_dependency %q<guard-rspec>
   s.add_development_dependency %q<rb-fsevent>, ['~> 0.9']
+  s.add_development_dependency %q<coveralls>, ['>= 0']
+  s.add_development_dependency %q<guard-rake>
+  s.add_development_dependency %q<benchmark_suite>
 end

data/spec/punchblock/client/component_registry_spec.rb

@@ -6,7 +6,7 @@ module Punchblock
   class Client
     describe ComponentRegistry do
       let(:component_id)  { 'abc123' }
-      let(:component)     { stub 'Component', :component_id => component_id }
+      let(:component)     { double 'Component', :component_id => component_id }
 
       it 'should store components and allow lookup by ID' do
         subject << component

data/spec/punchblock/client_spec.rb

@@ -8,15 +8,14 @@ module Punchblock
 
     subject { Client.new :connection => connection }
 
-    its(:event_queue)         { should be_a Queue }
     its(:connection)          { should be connection }
     its(:component_registry)  { should be_a Client::ComponentRegistry }
 
     let(:call_id)         { 'abc123' }
-    let(:mock_event)      { stub('Event').as_null_object }
+    let(:mock_event)      { double('Event').as_null_object }
     let(:component_id)    { 'abc123' }
-    let(:mock_component)  { stub 'Component', :component_id => component_id }
-    let(:mock_command)    { stub 'Command' }
+    let(:mock_component)  { double 'Component', :component_id => component_id }
+    let(:mock_command)    { double 'Command' }
 
     describe '#run' do
       it 'should start up the connection' do
@@ -50,13 +49,8 @@ module Punchblock
           mock_component.should_receive(:add_event).with mock_event
         end
 
-        it 'should not queue up the event' do
-          subject.handle_event mock_event
-          subject.event_queue.should be_empty
-        end
-
         it 'should not call event handlers' do
-          handler = mock 'handler'
+          handler = double 'handler'
           handler.should_receive(:call).never
           subject.register_event_handler do |event|
             handler.call event
@@ -70,23 +64,13 @@ module Punchblock
           mock_event.stub :source => nil
         end
 
-        context 'if event handlers have been set' do
-          it 'should call the event handler and not queue up the event' do
-            handler = mock 'handler'
-            handler.should_receive(:call).once.with mock_event
-            subject.register_event_handler do |event|
-              handler.call event
-            end
-            subject.handle_event mock_event
-            subject.event_queue.should be_empty
-          end
-        end
-
-        context 'if event handlers have not been set' do
-          it 'should queue up the event' do
-            subject.handle_event mock_event
-            subject.event_queue.pop(true).should be == mock_event
+        it 'should call registered event handlers' do
+          handler = double 'handler'
+          handler.should_receive(:call).once.with mock_event
+          subject.register_event_handler do |event|
+            handler.call event
           end
+          subject.handle_event mock_event
         end
       end
     end

data/spec/punchblock/command/accept_spec.rb

@@ -6,18 +6,52 @@ module Punchblock
   module Command
     describe Accept do
       it 'registers itself' do
-        RayoNode.class_from_registration(:accept, 'urn:xmpp:rayo:1').should be == Accept
+        RayoNode.class_from_registration(:accept, 'urn:xmpp:rayo:1').should be == described_class
       end
 
-      it_should_behave_like 'command_headers'
-
       describe "from a stanza" do
-        let(:stanza) { '<accept xmlns="urn:xmpp:rayo:1"/>' }
+        let(:stanza) do
+          <<-STANZA
+            <accept xmlns="urn:xmpp:rayo:1">
+              <header name="X-skill" value="agent" />
+              <header name="X-customer-id" value="8877" />
+            </accept>
+          STANZA
+        end
+
+        subject { RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+        it { should be_instance_of described_class }
+        its(:headers) { should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+        context "with no headers provided" do
+          let(:stanza) { '<accept xmlns="urn:xmpp:rayo:1"/>' }
+
+          its(:headers) { should == {} }
+        end
+      end
+
+      describe "when setting options in initializer" do
+        subject { described_class.new headers: { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+        its(:headers) { should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
 
-        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+        describe "exporting to Rayo" do
+          it "should export to XML that can be understood by its parser" do
+            new_instance = RayoNode.from_xml subject.to_rayo
+            new_instance.should be_instance_of described_class
+            new_instance.headers.should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' }
+          end
 
-        it { should be_instance_of Accept }
+          it "should render to a parent node if supplied" do
+            doc = Nokogiri::XML::Document.new
+            parent = Nokogiri::XML::Node.new 'foo', doc
+            doc.root = parent
+            rayo_doc = subject.to_rayo(parent)
+            rayo_doc.should == parent
+          end
+        end
       end
     end
   end
-end # Punchblock
+end

data/spec/punchblock/command/answer_spec.rb

@@ -6,18 +6,62 @@ module Punchblock
   module Command
     describe Answer do
       it 'registers itself' do
-        RayoNode.class_from_registration(:answer, 'urn:xmpp:rayo:1').should be == Answer
+        RayoNode.class_from_registration(:answer, 'urn:xmpp:rayo:1').should be == described_class
       end
 
-      it_should_behave_like 'command_headers'
-
       describe "from a stanza" do
-        let(:stanza) { '<answer xmlns="urn:xmpp:rayo:1"/>' }
+        let(:stanza) do
+          <<-STANZA
+            <answer xmlns="urn:xmpp:rayo:1">
+              <header name="X-skill" value="agent" />
+              <header name="X-customer-id" value="8877" />
+            </answer>
+          STANZA
+        end
+
+        subject { RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+        it { should be_instance_of described_class }
+        its(:headers) { should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+        context "with no headers provided" do
+          let(:stanza) { '<answer xmlns="urn:xmpp:rayo:1"/>' }
+
+          its(:headers) { should == {} }
+        end
+      end
+
+      describe "when setting options in initializer" do
+        subject { described_class.new headers: { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+        its(:headers) { should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+        describe "exporting to Rayo" do
+          it "should export to XML that can be understood by its parser" do
+            new_instance = RayoNode.from_xml subject.to_rayo
+            new_instance.should be_instance_of described_class
+            new_instance.headers.should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' }
+          end
+
+          it "should render to a parent node if supplied" do
+            doc = Nokogiri::XML::Document.new
+            parent = Nokogiri::XML::Node.new 'foo', doc
+            doc.root = parent
+            rayo_doc = subject.to_rayo(parent)
+            rayo_doc.should == parent
+          end
 
-        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+          context "with multiple headers of the same name" do
+            subject { described_class.new headers: { 'X-skill' => ['sales', 'complaints'] } }
 
-        it { should be_instance_of Answer }
+            it "should export to XML that can be understood by its parser" do
+              new_instance = RayoNode.from_xml subject.to_rayo
+              new_instance.should be_instance_of described_class
+              new_instance.headers.should == { 'X-skill' => ['sales', 'complaints'] }
+            end
+          end
+        end
       end
     end
   end
-end # Punchblock
+end

data/spec/punchblock/command/dial_spec.rb

@@ -7,61 +7,103 @@ module Punchblock
     describe Dial do
 
       it 'registers itself' do
-        RayoNode.class_from_registration(:dial, 'urn:xmpp:rayo:1').should be == Dial
+        RayoNode.class_from_registration(:dial, 'urn:xmpp:rayo:1').should be == described_class
       end
 
-      let(:join_params) { {:call_id => 'abc123'} }
+      let(:join_params) { {:call_uri => 'abc123'} }
 
       describe "when setting options in initializer" do
-        subject { Dial.new :to => 'tel:+14155551212', :from => 'tel:+13035551212', :timeout => 30000, :headers => { :x_skill => 'agent', :x_customer_id => 8877 }, :join => join_params }
-
-        it_should_behave_like 'command_headers'
+        subject { described_class.new to: 'tel:+14155551212', from: 'tel:+13035551212', timeout: 30000, headers: { 'X-skill' => 'agent', 'X-customer-id' => '8877' }, join: join_params }
 
         its(:to)      { should be == 'tel:+14155551212' }
         its(:from)    { should be == 'tel:+13035551212' }
         its(:timeout) { should be == 30000 }
         its(:join)    { should be == Join.new(join_params) }
+        its(:headers) { should be == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+        describe "exporting to Rayo" do
+          it "should export to XML that can be understood by its parser" do
+            new_instance = RayoNode.from_xml subject.to_rayo
+            new_instance.should be_instance_of described_class
+            new_instance.to.should == 'tel:+14155551212'
+            new_instance.from.should == 'tel:+13035551212'
+            new_instance.timeout.should == 30000
+            new_instance.join.should == Join.new(join_params)
+            new_instance.headers.should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' }
+          end
+
+          it "should render to a parent node if supplied" do
+            doc = Nokogiri::XML::Document.new
+            parent = Nokogiri::XML::Node.new 'foo', doc
+            doc.root = parent
+            rayo_doc = subject.to_rayo(parent)
+            rayo_doc.should == parent
+          end
+
+          context "when attributes are not set" do
+            subject { described_class.new to: 'abc123' }
+
+            it "should not include them in the XML representation" do
+              subject.to_rayo['to'].should == 'abc123'
+              subject.to_rayo['from'].should be_nil
+            end
+          end
+        end
       end
 
       describe "from a stanza" do
         let :stanza do
           <<-MESSAGE
 <dial to='tel:+14155551212' from='tel:+13035551212' timeout='30000' xmlns='urn:xmpp:rayo:1'>
-  <join call-id="abc123" />
+  <join call-uri="abc123" />
   <header name="X-skill" value="agent" />
   <header name="X-customer-id" value="8877" />
 </dial>
           MESSAGE
         end
 
-        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+        subject { RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
 
-        it { should be_instance_of Dial }
-
-        it_should_behave_like 'event_headers'
+        it { should be_instance_of described_class }
 
         its(:to)      { should be == 'tel:+14155551212' }
         its(:from)    { should be == 'tel:+13035551212' }
         its(:timeout) { should be == 30000 }
         its(:join)    { should be == Join.new(join_params) }
+        its(:headers) { should be == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+        context "with no headers provided" do
+          let(:stanza) { '<dial xmlns="urn:xmpp:rayo:1"/>' }
+
+          its(:headers) { should == {} }
+        end
       end
 
       describe "#response=" do
         before { subject.request! }
 
         let(:call_id) { 'abc123' }
+        let(:domain)  { 'rayo.net' }
 
         let :ref do
-          Ref.new.tap do |ref|
-            ref.id = call_id
-          end
+          Ref.new uri: "xmpp:#{call_id}@#{domain}"
+        end
+
+        it "should set the transport from the ref" do
+          subject.response = ref
+          subject.transport.should be == 'xmpp'
         end
 
         it "should set the call ID from the ref" do
           subject.response = ref
           subject.target_call_id.should be == call_id
         end
+
+        it "should set the domain from the ref" do
+          subject.response = ref
+          subject.domain.should be == domain
+        end
       end
     end
   end
-end # Punchblock
+end