adhearsion 2.6.4 → 3.0.0.beta1

data/lib/adhearsion/rayo/command/redirect.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'adhearsion/rayo/command_node'
+require 'adhearsion/has_headers'
+
+module Adhearsion
+  module Rayo
+    module Command
+      class Redirect < CommandNode
+        register :redirect, :core
+
+        include HasHeaders
+
+        # @return [String] the redirect target
+        attribute :to
+
+        def rayo_attributes
+          {'to' => to}
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/command/reject.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'adhearsion/rayo/command_node'
+require 'adhearsion/has_headers'
+
+module Adhearsion
+  module Rayo
+    module Command
+      class Reject < CommandNode
+        register :reject, :core
+
+        include HasHeaders
+
+        VALID_REASONS = [:busy, :decline, :error].freeze
+
+        # @return [Symbol] the reason type for rejecting a call. One of :busy, :dclined or :error.
+        # @raises ArgumentError if reject_reason is not one of the allowed reasons
+        attribute :reason, Symbol
+        def reason=(reject_reason)
+          if reject_reason && !VALID_REASONS.include?(reject_reason.to_sym)
+            raise ArgumentError, "Invalid Reason (#{reject_reason}), use: #{VALID_REASONS*' '}"
+          end
+          super
+        end
+
+        def inherit(xml_node)
+          if first_child = xml_node.at_xpath('*')
+            self.reason = first_child.name
+          end
+          super
+        end
+
+        def rayo_children(root)
+          root.send reason if reason
+          super
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/command/unjoin.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'adhearsion/rayo/command_node'
+
+module Adhearsion
+  module Rayo
+    module Command
+      class Unjoin < CommandNode
+        register :unjoin, :core
+
+        # @return [String] the call ID to unjoin
+        attribute :call_uri
+        alias :call_id= :call_uri=
+
+        # @return [String] the mixer name to unjoin
+        attribute :mixer_name
+
+        def rayo_attributes
+          {'call-uri' => call_uri, 'mixer-name' => mixer_name}
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/command/unmute.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'adhearsion/rayo/command_node'
+
+module Adhearsion
+  module Rayo
+    module Command
+      class Unmute < CommandNode
+        register :unmute, :core
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/command_node.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'state_machine'
+require 'future-resource'
+require 'adhearsion/rayo/rayo_node'
+
+module Adhearsion
+  module Rayo
+    class CommandNode < RayoNode
+
+      attribute :request_id, String, default: ->(*) { Adhearsion.new_request_id }
+
+      def initialize(*args)
+        super
+        @response = FutureResource.new
+      end
+
+      state_machine :state, :initial => :new do
+        event :request do
+          transition :new => :requested
+        end
+
+        event :execute do
+          transition :requested => :executing
+        end
+
+        event :complete do
+          transition :executing => :complete
+        end
+      end
+
+      def response(timeout = nil)
+        @response.resource timeout
+      end
+
+      def response=(other)
+        return if @response.set_yet?
+        @response.resource = other
+        execute!
+      rescue StateMachine::InvalidTransition => e
+        e.message << " for command #{self}"
+        raise e
+      rescue FutureResource::ResourceAlreadySetException
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      InvalidActionError = Class.new StandardError
+    end
+  end
+end
+
+%w{
+  asterisk
+  component_node
+  input
+  output
+  prompt
+  receive_fax
+  record
+  send_fax
+  stop
+}.each { |component| require "adhearsion/rayo/component/#{component}" }

data/lib/adhearsion/rayo/component/asterisk.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      module Asterisk
+      end
+    end
+  end
+end
+
+require 'adhearsion/rayo/component/asterisk/agi'
+require 'adhearsion/rayo/component/asterisk/ami'

data/lib/adhearsion/rayo/component/asterisk/agi.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      module Asterisk
+        module AGI
+        end
+      end
+    end
+  end
+end
+
+require 'adhearsion/rayo/component/asterisk/agi/command'

data/lib/adhearsion/rayo/component/asterisk/agi/command.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'adhearsion/rayo/component/component_node'
+require 'adhearsion/event/complete'
+
+module Adhearsion
+  module Rayo
+    module Component
+      module Asterisk
+        module AGI
+          class Command < ComponentNode
+            register :command, :agi
+
+            attribute :name
+            attribute :params, Array, default: []
+
+            def inherit(xml_node)
+              xml_node.xpath('//ns:param', ns: self.class.registered_ns).to_a.each do |param|
+                params << param[:value]
+              end
+              super
+            end
+
+            class Complete
+              class Success < Event::Complete::Reason
+                register :success, :agi_complete
+
+                attribute :code, Integer
+                attribute :result, Integer
+                attribute :data
+
+                def inherit(xml_node)
+                  [:code, :result, :data].each do |attr|
+                    node = xml_node.at_xpath "ns:#{attr}", ns: self.class.registered_ns
+                    self.send "#{attr}=", node.text if node
+                  end
+                  super
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component/asterisk/ami.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      module Asterisk
+        module AMI
+        end
+      end
+    end
+  end
+end
+
+require 'adhearsion/rayo/component/asterisk/ami/action'

data/lib/adhearsion/rayo/component/asterisk/ami/action.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      module Asterisk
+        module AMI
+          class Action < ComponentNode
+            register :action, :ami
+
+            attribute :name
+            attribute :params, Hash, default: {}
+
+            def inherit(xml_node)
+              xml_node.xpath('//ns:param', ns: self.class.registered_ns).to_a.each do |param|
+                params[param[:name]] = param[:value]
+              end
+              super
+            end
+
+            def rayo_attributes
+              {'name' => name}
+            end
+
+            def rayo_children(root)
+              super
+              params.each do |name, value|
+                root.param name: name, value: value
+              end
+            end
+
+            class Complete
+              class Success < Event::Complete::Reason
+                register :success, :ami_complete
+
+                attribute :message
+                attribute :text_body
+                attribute :headers, Hash, default: {}
+
+                alias :attributes :headers
+
+                def inherit(xml_node)
+                  message_node = xml_node.at_xpath 'ns:message', ns: self.class.registered_ns
+                  self.message = message_node.text if message_node
+
+                  text_body_node = xml_node.at_xpath 'ns:text-body', ns: self.class.registered_ns
+                  self.text_body = text_body_node.text if text_body_node
+
+                  xml_node.xpath('//ns:attribute', ns: self.class.registered_ns).to_a.each do |attribute|
+                    headers[attribute[:name]] = attribute[:value]
+                  end
+                  super
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component/component_node.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'future-resource'
+require 'has_guarded_handlers'
+require 'adhearsion/rayo/command_node'
+
+module Adhearsion
+  module Rayo
+    module Component
+      class ComponentNode < CommandNode
+        include HasGuardedHandlers
+
+        def initialize(*args)
+          super
+          @complete_event_resource = FutureResource.new
+          @mutex = Mutex.new
+          register_internal_handlers
+        end
+
+        def register_internal_handlers
+          register_handler :internal, Event::Complete do |event|
+            self.complete_event = event
+            throw :pass
+          end
+        end
+
+        def add_event(event)
+          trigger_handler :internal, event
+        end
+
+        def trigger_event_handler(event)
+          trigger_handler :event, event
+        end
+
+        def register_event_handler(*guards, &block)
+          register_handler :event, *guards, &block
+        end
+
+        def write_action(action)
+          client.execute_command action, :target_call_id => target_call_id, :component_id => component_id
+          action
+        end
+
+        def response=(other)
+          @mutex.synchronize do
+            if other.is_a?(Ref)
+              @component_id = other.component_id
+              @source_uri = other.uri.to_s
+              client.register_component self if client
+            end
+            super
+          end
+        end
+
+        def complete_event(timeout = nil)
+          @complete_event_resource.resource timeout
+        end
+
+        def complete_event=(other)
+          @mutex.synchronize do
+            return if @complete_event_resource.set_yet?
+            client.delete_component_registration self if client
+            complete!
+            @complete_event_resource.resource = other
+          end
+        rescue StateMachine::InvalidTransition => e
+          e.message << " for component #{self}"
+          raise e
+        end
+
+        ##
+        # Create a Rayo stop message
+        #
+        # @return [Stop] a Rayo stop message
+        #
+        def stop_action
+          Stop.new :component_id => component_id, :target_call_id => target_call_id
+        end
+
+        ##
+        # Sends a Rayo stop message for the current component
+        #
+        def stop!(options = {})
+          raise InvalidActionError, "Cannot stop a #{self.class.name.split("::").last} that is #{state}" unless executing?
+          stop_action.tap { |action| write_action action }
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component/input.rb

@@ -0,0 +1,186 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      class Input < ComponentNode
+
+        include HasHeaders
+
+        NLSML_NAMESPACE = 'http://www.ietf.org/xml/ns/mrcpv2'
+
+        register :input, :input
+
+        # @return [Integer] the amount of time in milliseconds that an input command will wait until considered that a silence becomes a NO-MATCH
+        attribute :max_silence, Integer
+
+        # @return [Float] Confidence with which to consider a response acceptable
+        attribute :min_confidence, Float
+
+        # @return [Symbol] mode by which to accept input. Can be :voice, :dtmf or :any
+        attribute :mode, Symbol, default: :dtmf
+
+        # @return [String] recognizer to use for speech recognition
+        attribute :recognizer, String
+
+        # @return [String] language to use for speech recognition
+        attribute :language, String
+
+        # @return [String] terminator by which to signal the end of input
+        attribute :terminator, String
+
+        # @return [Float] Indicates how sensitive the interpreter should be to loud versus quiet input. Higher values represent greater sensitivity.
+        attribute :sensitivity, Float
+
+        # @return [Integer] Indicates the amount of time (in milliseconds) preceding input which may expire before a timeout is triggered.
+        attribute :initial_timeout, Integer
+
+        # @return [Integer] Indicates (in the case of DTMF input) the amount of time (in milliseconds) between input digits which may expire before a timeout is triggered.
+        attribute :inter_digit_timeout, Integer
+
+        # @return [Integer] Indicates the amount of time during input that recognition will occur before a timeout is triggered.
+        attribute :recognition_timeout, Integer
+
+        attribute :grammars, Array, default: []
+        def grammars=(others)
+          super others.map { |other| Grammar.new(other) }
+        end
+
+        ##
+        # @param [Hash] other
+        # @option other [String] :content_type the document content type
+        # @option other [String] :value the grammar doucment
+        # @option other [String] :url the url from which to fetch the grammar
+        #
+        def grammar=(other)
+          self.grammars = [other].compact
+        end
+
+        def inherit(xml_node)
+          grammar_nodes = xml_node.xpath('ns:grammar', ns: self.class.registered_ns)
+          self.grammars = grammar_nodes.to_a.map { |grammar_node| Grammar.from_xml(grammar_node)}
+          super
+        end
+
+        def rayo_attributes
+          {
+            'max-silence' => max_silence,
+            'min-confidence' => min_confidence,
+            'mode' => mode,
+            'recognizer' => recognizer,
+            'language' => language,
+            'terminator' => terminator,
+            'sensitivity' => sensitivity,
+            'initial-timeout' => initial_timeout,
+            'inter-digit-timeout' => inter_digit_timeout,
+            'recognition-timeout' => recognition_timeout
+          }
+        end
+
+        def rayo_children(root)
+          grammars.each do |grammar|
+            grammar.to_rayo(root)
+          end
+          super
+        end
+
+        class Grammar < RayoNode
+          register :grammar, :input
+
+          GRXML_CONTENT_TYPE = 'application/srgs+xml'
+
+          attribute :value
+          attribute :content_type, String, default: ->(grammar, attribute) { grammar.url ? nil : GRXML_CONTENT_TYPE }
+          attribute :url
+
+          def inherit(xml_node)
+            self.value = xml_node.content.strip
+            super
+          end
+
+          def rayo_attributes
+            {
+              'url' => url,
+              'content-type' => content_type
+            }
+          end
+
+          def rayo_children(root)
+            root.cdata value if value
+          end
+
+          private
+
+          def grxml?
+            content_type == GRXML_CONTENT_TYPE
+          end
+        end
+
+        class Signal < Event::Complete::Reason
+          register :signal, :cpa
+
+          attribute :type, String
+          attribute :duration, Integer
+          attribute :value, String
+        end
+
+        class Complete
+          class Match < Event::Complete::Reason
+            register :match, :input_complete
+
+            attribute :content_type, String, default: 'application/nlsml+xml'
+
+            attribute :nlsml
+            def nlsml=(other)
+              doc = case other
+              when Nokogiri::XML::Element, Nokogiri::XML::Document
+                RubySpeech::NLSML::Document.new(other)
+              else
+                other
+              end
+              super doc
+            end
+
+            def mode
+              nlsml.best_interpretation[:input][:mode]
+            end
+
+            def confidence
+              nlsml.best_interpretation[:confidence]
+            end
+
+            def utterance
+              nlsml.best_interpretation[:input][:content]
+            end
+
+            def interpretation
+              nlsml.best_interpretation[:instance]
+            end
+
+            def inherit(xml_node)
+              self.nlsml = result_node(xml_node)
+              super
+            end
+
+            private
+
+            def result_node(xml)
+              directly_nested = xml.at_xpath 'ns:result', ns: NLSML_NAMESPACE
+              return directly_nested if directly_nested
+              document = Nokogiri::XML.parse xml.text, nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS
+              document.at_xpath 'ns:result', ns: NLSML_NAMESPACE or raise "Couldn't find the NLSML node"
+            end
+          end
+
+          class NoMatch < Event::Complete::Reason
+            register :nomatch, :input_complete
+          end
+
+          class NoInput < Event::Complete::Reason
+            register :noinput, :input_complete
+          end
+        end
+      end
+    end
+  end
+end