punchblock 1.9.4 → 2.0.0.beta1

data/lib/punchblock/component/output.rb

@@ -5,174 +5,130 @@ module Punchblock
     class Output < ComponentNode
       register :output, :output
 
-      ##
-      # Creates an Rayo Output command
-      #
-      # @param [Hash] options
-      # @option options [String, Optional] :text to speak back
-      # @option options [String, Optional] :voice with which to render TTS
-      # @option options [String, Optional] :ssml document to render TTS
-      # @option options [Symbol] :interrupt_on input type on which to interrupt output. May be :speech, :dtmf or :any
-      # @option options [Integer] :start_offset Indicates some offset through which the output should be skipped before rendering begins.
-      # @option options [true, false] :start_paused Indicates wether or not the component should be started in a paused state to be resumed at a later time.
-      # @option options [Integer] :repeat_interval Indicates the duration of silence that should space repeats of the rendered document.
-      # @option options [Integer] :repeat_times Indicates the number of times the output should be played.
-      # @option options [Integer] :max_time Indicates the maximum amount of time for which the output should be allowed to run before being terminated. Includes repeats.
-      #
-      # @return [Command::Output] an Rayo "output" command
-      #
-      # @example
-      #   output :text => 'Hello brown cow.'
-      #
-      #   returns:
-      #     <output xmlns="urn:xmpp:rayo:output:1">Hello brown cow.</output>
-      #
-      def self.new(options = {})
-        super().tap do |new_node|
-          case options
-          when Hash
-            new_node.ssml = options.delete(:ssml) if options[:ssml]
-            new_node << options.delete(:text) if options[:text]
-            options.each_pair { |k,v| new_node.send :"#{k}=", v }
-          when Nokogiri::XML::Element
-            new_node.inherit options
+      class Document < RayoNode
+        register :document, :output
+
+        SSML_CONTENT_TYPE = 'application/ssml+xml'
+
+        # @return [String] the URL from which the fetch the grammar
+        attribute :url
+
+        # @return [String] the document content type
+        attribute :content_type, String, default: ->(grammar, attribute) { grammar.url ? nil : SSML_CONTENT_TYPE }
+
+        # @return [String, RubySpeech::SSML::Speak, URIList] the document
+        attribute :value
+
+        def inherit(xml_node)
+          super
+          self.value = if ssml?
+            RubySpeech::SSML.import xml_node.content
+          elsif urilist?
+            URIList.import xml_node.content
+          else
+            xml_node.content
           end
+          self
         end
-      end
 
-      ##
-      # @return [String] the TTS voice to use
-      #
-      def voice
-        read_attr :voice
-      end
+        def rayo_attributes
+          {
+            'url' => url,
+            'content-type' => content_type
+          }
+        end
 
-      ##
-      # @param [String] voice to use when rendering TTS
-      #
-      def voice=(voice)
-        write_attr :voice, voice
-      end
+        def rayo_children(root)
+          root.cdata xml_value
+          super
+        end
 
-      ##
-      # @return [String] the SSML document to render TTS
-      #
-      def ssml
-        node = children.first
-        RubySpeech::SSML.import node if node
-      end
+        private
 
-      ##
-      # @param [String] ssml the SSML document to render TTS
-      #
-      def ssml=(ssml)
-        return unless ssml
-        unless ssml.is_a?(RubySpeech::SSML::Element)
-          ssml = RubySpeech::SSML.import ssml
+        def xml_value
+          if ssml?
+            value.to_xml
+          elsif urilist?
+            value.to_s
+          elsif
+            value
+          end
         end
-        self << ssml
-      end
 
-      ##
-      # @return [Symbol] input type on which to interrupt output
-      #
-      def interrupt_on
-        read_attr :'interrupt-on', :to_sym
-      end
+        def ssml?
+          content_type == SSML_CONTENT_TYPE
+        end
 
-      ##
-      # @param [Symbol] other input type on which to interrupt output. May be :speech, :dtmf or :any
-      #
-      def interrupt_on=(other)
-        write_attr :'interrupt-on', other
+        def urilist?
+          content_type == 'text/uri-list'
+        end
       end
 
-      ##
-      # @return [Integer] Indicates some offset through which the output should be skipped before rendering begins.
-      #
-      def start_offset
-        read_attr :'start-offset', :to_i
+      def inherit(xml_node)
+        document_nodes = xml_node.xpath 'ns:document', ns: self.class.registered_ns
+        self.render_documents = document_nodes.to_a.map { |node| Document.from_xml node }
+        super
       end
 
-      ##
-      # @param [Integer] other Indicates some offset through which the output should be skipped before rendering begins.
-      #
-      def start_offset=(other)
-        write_attr :'start-offset', other, :to_i
-      end
+      # @return [String] the TTS voice to use
+      attribute :voice, String
 
-      ##
-      # @return [true, false] Indicates wether or not the component should be started in a paused state to be resumed at a later time.
-      #
-      def start_paused
-        read_attr(:'start-paused') == 'true'
-      end
+      # @return [Symbol] input type on which to interrupt output
+      attribute :interrupt_on, Symbol
 
-      ##
-      # @param [true, false] other Indicates wether or not the component should be started in a paused state to be resumed at a later time.
-      #
-      def start_paused=(other)
-        write_attr :'start-paused', other, :to_s
-      end
+      # @return [Integer] Indicates some offset through which the output should be skipped before rendering begins.
+      attribute :start_offset, Integer
 
-      ##
-      # @return [Integer] Indicates the duration of silence that should space repeats of the rendered document.
-      #
-      def repeat_interval
-        read_attr :'repeat-interval', :to_i
-      end
+      # @return [true, false] Indicates wether or not the component should be started in a paused state to be resumed at a later time.
+      attribute :start_paused, Boolean, default: false
 
-      ##
-      # @param [Integer] other Indicates the duration of silence that should space repeats of the rendered document.
-      #
-      def repeat_interval=(other)
-        write_attr :'repeat-interval', other, :to_i
-      end
+      # @return [Integer] Indicates the duration of silence that should space repeats of the rendered document.
+      attribute :repeat_interval, Integer
 
-      ##
       # @return [Integer] Indicates the number of times the output should be played.
-      #
-      def repeat_times
-        read_attr :'repeat-times', :to_i
-      end
-
-      ##
-      # @param [Integer] other Indicates the number of times the output should be played.
-      #
-      def repeat_times=(other)
-        write_attr :'repeat-times', other, :to_i
-      end
+      attribute :repeat_times, Integer
 
-      ##
       # @return [Integer] Indicates the maximum amount of time for which the output should be allowed to run before being terminated. Includes repeats.
-      #
-      def max_time
-        read_attr :'max-time', :to_i
-      end
+      attribute :max_time, Integer
 
-      ##
-      # @param [Integer] other Indicates the maximum amount of time for which the output should be allowed to run before being terminated. Includes repeats.
-      #
-      def max_time=(other)
-        write_attr :'max-time', other, :to_i
+      # @return [String] the rendering engine requested by the component
+      attribute :renderer, String
+
+      def rayo_attributes
+        {
+          'voice' => voice,
+          'interrupt-on' => interrupt_on,
+          'start-offset' => start_offset,
+          'start-paused' => start_paused,
+          'repeat-interval' => repeat_interval,
+          'repeat-times' => repeat_times,
+          'max-time' => max_time,
+          'renderer' => renderer
+        }
       end
 
-      ##
-      # @return [String] the rendering engine requested by the component
-      #
-      def renderer
-        read_attr :renderer
+      def rayo_children(root)
+        render_documents.each do |render_document|
+          render_document.to_rayo root.parent
+        end
+        super
       end
 
+      # @return [Document] the document to render
+      attribute :render_documents, Array[Document], default: []
+
       ##
-      # @param [String] the rendering engine to use with this component
+      # @param [Hash] other
+      # @option other [String] :content_type the document content type
+      # @option other [String] :value the output doucment
+      # @option other [String] :url the url from which to fetch the document
       #
-      def renderer=(renderer)
-        write_attr :renderer, renderer
+      def render_document=(other)
+        self.render_documents = [other].compact
       end
 
-      def inspect_attributes
-        super + [:voice, :ssml, :interrupt_on, :start_offset, :start_paused, :repeat_interval, :repeat_times, :max_time, :renderer]
+      def ssml=(other)
+        self.render_documents = [{:value => other}]
       end
 
       state_machine :state do
@@ -281,20 +237,8 @@ module Punchblock
       class Seek < CommandNode # :nodoc:
         register :seek, :output
 
-        def self.new(options = {})
-          super.tap do |new_node|
-            new_node.direction  = options[:direction]
-            new_node.amount     = options[:amount]
-          end
-        end
-
-        def direction=(other)
-          write_attr :direction, other
-        end
-
-        def amount=(other)
-          write_attr :amount, other
-        end
+        attribute :direction
+        attribute :amount
 
         def request!
           source.seeking!
@@ -305,6 +249,10 @@ module Punchblock
           source.stopped_seeking!
           super
         end
+
+        def rayo_attributes
+          {'direction' => direction, 'amount' => amount}
+        end
       end
 
       ##
@@ -496,8 +444,12 @@ module Punchblock
       end
 
       class Complete
-        class Success < Event::Complete::Reason
-          register :success, :output_complete
+        class Finish < Event::Complete::Reason
+          register :finish, :output_complete
+        end
+
+        class MaxTime < Event::Complete::Reason
+          register :'max-time', :output_complete
         end
       end
     end # Output

data/lib/punchblock/component/prompt.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Punchblock
+  module Component
+    class Prompt < ComponentNode
+      register :prompt, :prompt
+
+      attribute :barge_in, Boolean
+      attribute :output, Output
+      attribute :input, Input
+
+      ##
+      # Create a prompt command
+      #
+      # @param [Output] output
+      # @param [Input] input
+      # @param [Hash] options
+      # @option options [true, false, optional] :barge_in Indicates wether or not the input should interrupt then output
+      #
+      # @return [Component::Prompt] a formatted Rayo prompt command
+      #
+      def initialize(output = nil, input = nil, options = {})
+        super options
+        self.output = output
+        self.input  = input
+      end
+
+      def inherit(xml_node)
+        input_node = xml_node.at_xpath('ns:input', ns: Input.registered_ns)
+        self.input = Input.from_xml input_node if input_node
+
+        output_node = xml_node.at_xpath('ns:output', ns: Output.registered_ns)
+        self.output = Output.from_xml output_node if output_node
+
+        super
+      end
+
+      def rayo_attributes
+        {
+          'barge-in' => barge_in
+        }
+      end
+
+      def rayo_children(root)
+        input.to_rayo(root) if input
+        output.to_rayo(root) if output
+        super
+      end
+    end
+  end
+end

data/lib/punchblock/component/record.rb

@@ -7,132 +7,51 @@ module Punchblock
 
       VALID_DIRECTIONS = [:duplex, :send, :recv].freeze
 
-      ##
-      # Creates an Rayo Record command
-      #
-      # @param [Hash] options
-      # @option options [String] :format to use for recording
-      # @option options [Integer] :initial_timeout Controls how long the recognizer should wait after the end of the prompt for the caller to speak before sending a Recorder event.
-      # @option options [Integer] :final_timeout Controls the length of a period of silence after callers have spoken to conclude they finished.
-      # @option options [Integer] :max_duration Indicates the maximum duration for the recording.
-      # @option options [true, false] :start_beep Indicates whether subsequent record will be preceded with a beep.
-      # @option options [true, false] :start_paused Whether subsequent record will start in PAUSE mode.
-      #
-      # @return [Command::Record] a Rayo "record" command
-      #
-      # @example
-      #   record :text => 'Hello brown cow.'
-      #
-      #   returns:
-      #     <record xmlns="urn:xmpp:rayo:record:1">Hello brown cow.</record>
-      #
-      def self.new(options = {})
-        super().tap do |new_node|
-          options.each_pair { |k,v| new_node.send :"#{k}=", v }
-        end
-      end
-
-      ##
-      # @return [Integer] Controls the length of a period of silence after callers have spoken to conclude they finished.
-      #
-      def final_timeout
-        read_attr :'final-timeout', :to_i
-      end
-
-      ##
-      # @param [Integer] timeout Controls the length of a period of silence after callers have spoken to conclude they finished.
-      #
-      def final_timeout=(timeout)
-        write_attr :'final-timeout', timeout, :to_i
-      end
-
-      ##
       # @return [String] the codec to use for recording
-      #
-      def format
-        read_attr :format
-      end
-
-      ##
-      # @param [String] codec to use for recording
-      #
-      def format=(format)
-        write_attr :format, format
-      end
+      attribute :format
 
-      ##
       # @return [Integer] Controls how long the recognizer should wait after the end of the prompt for the caller to speak before sending a Recorder event.
-      #
-      def initial_timeout
-        read_attr :'initial-timeout', :to_i
-      end
+      attribute :initial_timeout, Integer
 
-      ##
-      # @param [Integer] timeout Controls how long the recognizer should wait after the end of the prompt for the caller to speak before sending a Recorder event.
-      #
-      def initial_timeout=(timeout)
-        write_attr :'initial-timeout', timeout, :to_i
-      end
+      # @return [Integer] Controls the length of a period of silence after callers have spoken to conclude they finished.
+      attribute :final_timeout, Integer
 
-      ##
       # @return [Integer] Indicates the maximum duration for the recording.
-      #
-      def max_duration
-        read_attr :'max-duration', :to_i
-      end
+      attribute :max_duration, Integer
 
-      ##
-      # @param [Integer] other Indicates the maximum duration for the recording.
-      #
-      def max_duration=(other)
-        write_attr :'max-duration', other, :to_i
-      end
+      # @return [true, false] Indicates whether record will be preceded with a beep.
+      attribute :start_beep, Boolean
 
-      ##
-      # @return [true, false] Indicates whether subsequent record will be preceded with a beep.
-      #
-      def start_beep
-        read_attr(:'start-beep') == 'true'
-      end
+      # @return [true, false] Indicates whether record will be followed by a beep.
+      attribute :stop_beep, Boolean
 
-      ##
-      # @param [true, false] sb Indicates whether subsequent record will be preceded with a beep.
-      #
-      def start_beep=(sb)
-        write_attr :'start-beep', sb
-      end
-
-      ##
       # @return [true, false] Whether subsequent record will start in PAUSE mode.
-      #
-      def start_paused
-        read_attr(:'start-paused') == 'true'
-      end
+      attribute :start_paused, Boolean
 
-      ##
-      # @param [true, false] other Whether subsequent record will start in PAUSE mode.
-      #
-      def start_paused=(other)
-        write_attr :'start-paused', other
-      end
-
-      ##
       # @return [Symbol] the direction of media to be recorded.
-      def direction
-        read_attr :direction, :to_sym
-      end
-
-      ##
-      # @param [#to_s] otherthe direction of media to be recorded. Can be :duplex, :recv or :send
+      attribute :direction, Symbol
       def direction=(direction)
         if direction && !VALID_DIRECTIONS.include?(direction.to_sym)
           raise ArgumentError, "Invalid Direction (#{direction}), use: #{VALID_DIRECTIONS*' '}"
         end
-        write_attr :direction, direction
+        super
       end
 
-      def inspect_attributes # :nodoc:
-        [:final_timeout, :format, :initial_timeout, :max_duration, :start_beep, :start_paused, :direction] + super
+      # @return [true, false] wether to mix audio down or not
+      attribute :mix, Boolean
+
+      def rayo_attributes
+        {
+          'format' => format,
+          'initial-timeout' => initial_timeout,
+          'final-timeout' => final_timeout,
+          'max-duration' => max_duration,
+          'start-beep' => start_beep,
+          'stop-beep' => start_beep,
+          'start-paused' => start_paused,
+          'direction' => direction,
+          'mix' => mix
+        }
       end
 
       state_machine :state do
@@ -221,32 +140,24 @@ module Punchblock
       class Recording < Event
         register :recording, :record_complete
 
-        def uri
-          read_attr :uri
-        end
-
-        def uri=(other)
-          write_attr :uri, other
-        end
-
-        def duration
-          read_attr :duration, :to_i
-        end
+        attribute :uri
+        attribute :duration, Integer
+        attribute :size, Integer
+      end
 
-        def size
-          read_attr :size, :to_i
+      class Complete
+        class MaxDuration < Event::Complete::Reason
+          register :'max-duration', :record_complete
         end
 
-        def inspect_attributes # :nodoc:
-          [:uri, :duration, :size] + super
+        class InitialTimeout < Event::Complete::Reason
+          register :'initial-timeout', :record_complete
         end
-      end
 
-      class Complete
-        class Success < Event::Complete::Reason
-          register :success, :record_complete
+        class FinalTimeout < Event::Complete::Reason
+          register :'final-timeout', :record_complete
         end
       end
-    end # Record
-  end # Command
-end # Punchblock
+    end
+  end
+end

data/lib/punchblock/component.rb

@@ -8,6 +8,7 @@ module Punchblock
     autoload :ComponentNode
     autoload :Input
     autoload :Output
+    autoload :Prompt
     autoload :Record
     autoload :Stop
 

data/lib/punchblock/connection/asterisk.rb

@@ -9,14 +9,15 @@ module Punchblock
       attr_accessor :event_handler
 
       def initialize(options = {})
-        @ami_client = RubyAMI::Stream.new options[:host], options[:port], options[:username], options[:password], ->(event) { translator.async.handle_ami_event event }, pb_logger
-        @translator = Translator::Asterisk.new @ami_client, self, options[:media_engine]
+        @stream_options = options.values_at(:host, :port, :username, :password)
+        @translator_options = options.values_at(:media_engine)
+        @ami_client = new_ami_stream
+        @translator = Translator::Asterisk.new @ami_client, self, *@translator_options
         super()
       end
 
       def run
-        ami_client.async.run
-        Celluloid::Actor.join(ami_client)
+        start_ami_client
         raise DisconnectedError
       end
 
@@ -32,6 +33,32 @@ module Punchblock
       def handle_event(event)
         event_handler.call event
       end
+
+      def new_ami_stream
+        stream = RubyAMI::Stream.new(*@stream_options, ->(event) { translator.async.handle_ami_event event }, pb_logger)
+        client = (ami_client || RubyAMIStreamProxy.new(stream))
+        client.stream = stream
+        client
+      end
+
+      def start_ami_client
+        @ami_client = new_ami_stream unless ami_client.alive?
+        ami_client.async.run
+        Celluloid::Actor.join(ami_client)
+      end
+    end
+
+    class RubyAMIStreamProxy
+      attr_accessor :stream
+
+      def initialize(ami)
+        @stream = ami
+      end
+
+      def method_missing(method, *args, &block)
+        stream.__send__(method, *args, &block)
+      end
+
     end
   end
 end