punchblock 0.4.0

data/lib/punchblock/command/join.rb

@@ -0,0 +1,81 @@
+module Punchblock
+  module Command
+    class Join < CommandNode
+      register :join, :core
+
+      ##
+      # Create a join message
+      #
+      # @param [Hash] options
+      # @option options [String, Optional] :other_call_id the call ID to join
+      # @option options [String, Optional] :mixer_id the mixer name to join
+      # @option options [Symbol, Optional] :direction the direction in which media should flow
+      # @option options [Symbol, Optional] :media the method by which to negotiate media
+      #
+      # @return [Command::Join] a formatted Rayo join command
+      #
+      def self.new(options = {})
+        super().tap do |new_node|
+          case options
+          when Nokogiri::XML::Node
+            new_node.inherit options
+          when Hash
+            options.each_pair { |k,v| new_node.send :"#{k}=", v }
+          end
+        end
+      end
+
+      ##
+      # @return [String] the call ID to join
+      def other_call_id
+        read_attr :'call-id'
+      end
+
+      ##
+      # @param [String] other the call ID to join
+      def other_call_id=(other)
+        write_attr :'call-id', other
+      end
+
+      ##
+      # @return [String] the mixer name to join
+      def mixer_id
+        read_attr :'mixer-id'
+      end
+
+      ##
+      # @param [String] other the mixer name to join
+      def mixer_id=(other)
+        write_attr :'mixer-id', other
+      end
+
+      ##
+      # @return [String] the direction in which media should flow
+      def direction
+        read_attr :direction, :to_sym
+      end
+
+      ##
+      # @param [String] other the direction in which media should flow. Can be :duplex, :recv or :send
+      def direction=(other)
+        write_attr :direction, other
+      end
+
+      ##
+      # @return [String] the method by which to negotiate media
+      def media
+        read_attr :media, :to_sym
+      end
+
+      ##
+      # @param [String] other the method by which to negotiate media. Can be :direct or :bridge
+      def media=(other)
+        write_attr :media, other
+      end
+
+      def inspect_attributes # :nodoc:
+        [:other_call_id, :mixer_id, :direction, :media] + super
+      end
+    end # Join
+  end # Command
+end # Punchblock

data/lib/punchblock/command/mute.rb

@@ -0,0 +1,7 @@
+module Punchblock
+  module Command
+    class Mute < CommandNode
+      register :mute, :core
+    end # Mute
+  end # Command
+end # Punchblock

data/lib/punchblock/command/redirect.rb

@@ -0,0 +1,49 @@
+module Punchblock
+  module Command
+    class Redirect < CommandNode
+      register :redirect, :core
+
+      include HasHeaders
+
+      ##
+      # Create an Rayo redirect message
+      #
+      # @param [Hash] options
+      # @option options [String] :to redirect target
+      # @option options [Array[Header], Hash, Optional] :headers SIP headers to attach to
+      #   the new call. Can be either a hash of key-value pairs, or an array of
+      #   Header objects.
+      #
+      # @return [Command::Redirect] a formatted Rayo redirect command
+      #
+      # @example
+      #    Redirect.new(:to => 'tel:+14045551234').to_xml
+      #
+      #    returns:
+      #        <redirect to="tel:+14045551234" xmlns="urn:xmpp:rayo:1"/>
+      #
+      def self.new(options = {})
+        super().tap do |new_node|
+          new_node.to = options[:to]
+          new_node.headers = options[:headers]
+        end
+      end
+
+      ##
+      # @return [String] the redirect target
+      def to
+        read_attr :to
+      end
+
+      ##
+      # @param [String] redirect_to redirect target
+      def to=(redirect_to)
+        write_attr :to, redirect_to
+      end
+
+      def inspect_attributes # :nodoc:
+        [:to] + super
+      end
+    end # Redirect
+  end # Command
+end # Punchblock

data/lib/punchblock/command/reject.rb

@@ -0,0 +1,61 @@
+module Punchblock
+  module Command
+    class Reject < CommandNode
+      register :reject, :core
+
+      include HasHeaders
+
+      VALID_REASONS = [:busy, :decline, :error].freeze
+
+      ##
+      # Create an Rayo reject message
+      #
+      # @param [Hash] options
+      # @option options [Symbol] :reason for rejecting the call. Can be any one of VALID_REASONS. Defaults to :decline
+      # @option options [Array[Header], Hash, Optional] :headers SIP headers to attach to
+      #   the call. Can be either a hash of key-value pairs, or an array of
+      #   Header objects.
+      #
+      # @return [Command::Reject] a formatted Rayo reject command
+      #
+      # @example
+      #    Reject.new(:reason => :busy).to_xml
+      #
+      #    returns:
+      #        <reject xmlns="urn:xmpp:rayo:1"><busy/></reject
+      #
+      def self.new(options = {})
+        super().tap do |new_node|
+          new_node.reason = options[:reason] || :decline
+          new_node.headers = options[:headers]
+        end
+      end
+
+      ##
+      # @return [Symbol] the reason type for rejecting a call
+      #
+      def reason
+        children.select { |c| c.is_a? Nokogiri::XML::Element }.first.name.to_sym
+      end
+
+      ##
+      # Set the reason for rejecting the call
+      #
+      # @param [Symbol] reject_reason Can be any one of :busy, :dclined or :error.
+      #
+      # @raises ArgumentError if reject_reason is not one of the allowed reasons
+      #
+      def reason=(reject_reason)
+        if reject_reason && !VALID_REASONS.include?(reject_reason.to_sym)
+          raise ArgumentError, "Invalid Reason (#{reject_reason}), use: #{VALID_REASONS*' '}"
+        end
+        children.each &:remove
+        self << RayoNode.new(reject_reason)
+      end
+
+      def inspect_attributes # :nodoc:
+        [:reason] + super
+      end
+    end # Reject
+  end # Command
+end # Punchblock

data/lib/punchblock/command/unjoin.rb

@@ -0,0 +1,50 @@
+module Punchblock
+  module Command
+    class Unjoin < CommandNode
+      register :unjoin, :core
+
+      ##
+      # Create an ujoin message
+      #
+      # @param [Hash] options
+      # @option options [String, Optional] :other_call_id the call ID to unjoin
+      # @option options [String, Optional] :mixer_id the mixer name to unjoin
+      #
+      # @return [Command::Unjoin] a formatted Rayo unjoin command
+      #
+      def self.new(options = {})
+        super().tap do |new_node|
+          options.each_pair { |k,v| new_node.send :"#{k}=", v }
+        end
+      end
+
+      ##
+      # @return [String] the call ID to unjoin
+      def other_call_id
+        read_attr :'call-id'
+      end
+
+      ##
+      # @param [String] other the call ID to unjoin
+      def other_call_id=(other)
+        write_attr :'call-id', other
+      end
+
+      ##
+      # @return [String] the mixer name to unjoin
+      def mixer_id
+        read_attr :'mixer-id'
+      end
+
+      ##
+      # @param [String] other the mixer name to unjoin
+      def mixer_id=(other)
+        write_attr :'mixer-id', other
+      end
+
+      def inspect_attributes # :nodoc:
+        [:other_call_id, :mixer_id] + super
+      end
+    end # Unjoin
+  end # Command
+end # Punchblock

data/lib/punchblock/command/unmute.rb

@@ -0,0 +1,7 @@
+module Punchblock
+  module Command
+    class Unmute < CommandNode
+      register :unmute, :core
+    end # Mute
+  end # Command
+end # Punchblock

data/lib/punchblock/command.rb

@@ -0,0 +1,16 @@
+module Punchblock
+  module Command
+    extend ActiveSupport::Autoload
+
+    autoload :Accept
+    autoload :Answer
+    autoload :Dial
+    autoload :Hangup
+    autoload :Join
+    autoload :Mute
+    autoload :Redirect
+    autoload :Reject
+    autoload :Unjoin
+    autoload :Unmute
+  end # Command
+end # Punchblock

data/lib/punchblock/command_node.rb

@@ -0,0 +1,46 @@
+require 'state_machine'
+
+module Punchblock
+  class CommandNode < RayoNode
+    def self.new(options = {})
+      super().tap do |new_node|
+        new_node.call_id = options[:call_id]
+        new_node.component_id = options[:component_id]
+      end
+    end
+
+    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 write_attr(*args)
+      raise StandardError, "Cannot alter attributes of a requested command" unless new?
+      super
+    end
+
+    def response(timeout = nil)
+      @response.resource timeout
+    end
+
+    def response=(other)
+      return if @response.set_yet?
+      @response.resource = other
+      execute!
+    end
+  end # CommandNode
+end # Punchblock

data/lib/punchblock/component/input.rb

@@ -0,0 +1,320 @@
+module Punchblock
+  module Component
+    class Input < ComponentNode
+      register :input, :input
+
+      ##
+      # Create an input message
+      #
+      # @param [Hash] options for inputing/prompting a specific call
+      # @option options [Choices, Hash] :choices to allow the user to input
+      # @option options [Prompt, Hash, Optional] :prompt to play/read to the caller as the question
+      # @option options [Symbol, Optional] :mode by which to accept input. Can be :speech, :dtmf or :any
+      # @option options [Integer, Optional] :timeout to wait for user input
+      # @option options [Boolean, Optional] :bargein wether or not to allow the caller to begin their response before the prompt finishes
+      # @option options [String, Optional] :recognizer to use for speech recognition
+      # @option options [String, Optional] :terminator by which to signal the end of input
+      # @option options [Float, Optional] :min_confidence with which to consider a response acceptable
+      #
+      # @return [Command::Input] a formatted Rayo input command
+      #
+      # @example
+      #    input :prompt      => {:text => 'Please enter your postal code.', :voice => 'simon'},
+      #          :choices     => {:value => '[5 DIGITS]'},
+      #          :timeout     => 30,
+      #          :recognizer  => 'es-es'
+      #
+      #    returns:
+      #      <input xmlns="urn:xmpp:tropo:input:1" timeout="30" recognizer="es-es">
+      #        <prompt voice='simon'>Please enter your postal code.</prompt>
+      #        <choices content-type="application/grammar+voxeo">[5 DIGITS]</choices>
+      #      </input>
+      #
+      def self.new(options = {})
+        super().tap do |new_node|
+          options.each_pair { |k,v| new_node.send :"#{k}=", v }
+        end
+      end
+
+      ##
+      # @return [Boolean] wether or not to allow the caller to begin their response before the prompt finishes
+      #
+      def max_digits
+        read_attr :'max-digits', :to_i
+      end
+
+      ##
+      # @param [Boolean] bargein wether or not to allow the caller to begin their response before the prompt finishes
+      #
+      def max_digits=(other)
+        write_attr :'max-digits', other
+      end
+
+      ##
+      # @return [Float] Confidence with which to consider a response acceptable
+      #
+      def min_confidence
+        read_attr 'min-confidence', :to_f
+      end
+
+      ##
+      # @param [Float] min_confidence with which to consider a response acceptable
+      #
+      def min_confidence=(min_confidence)
+        write_attr 'min-confidence', min_confidence
+      end
+
+      ##
+      # @return [Symbol] mode by which to accept input. Can be :speech, :dtmf or :any
+      #
+      def mode
+        read_attr :mode, :to_sym
+      end
+
+      ##
+      # @param [Symbol] mode by which to accept input. Can be :speech, :dtmf or :any
+      #
+      def mode=(mode)
+        write_attr :mode, mode
+      end
+
+      ##
+      # @return [String] recognizer to use for speech recognition
+      #
+      def recognizer
+        read_attr :recognizer
+      end
+
+      ##
+      # @param [String] recognizer to use for speech recognition
+      #
+      def recognizer=(recognizer)
+        write_attr :recognizer, recognizer
+      end
+
+      ##
+      # @return [String] terminator by which to signal the end of input
+      #
+      def terminator
+        read_attr :terminator
+      end
+
+      ##
+      # @param [String] terminator by which to signal the end of input
+      #
+      def terminator=(terminator)
+        write_attr :terminator, terminator
+      end
+
+      ##
+      # @return [Integer] timeout to wait for user input
+      #
+      def sensitivity
+        read_attr :sensitivity, :to_f
+      end
+
+      ##
+      # @param [Integer] timeout to wait for user input
+      #
+      def sensitivity=(other)
+        write_attr :sensitivity, other
+      end
+
+      ##
+      # @return [Integer] timeout to wait for user input
+      #
+      def initial_timeout
+        read_attr :'initial-timeout', :to_i
+      end
+
+      ##
+      # @param [Integer] timeout to wait for user input
+      #
+      def initial_timeout=(other)
+        write_attr :'initial-timeout', other
+      end
+
+      ##
+      # @return [Integer] timeout to wait for user input
+      #
+      def inter_digit_timeout
+        read_attr :'inter-digit-timeout', :to_i
+      end
+
+      ##
+      # @param [Integer] timeout to wait for user input
+      #
+      def inter_digit_timeout=(other)
+        write_attr :'inter-digit-timeout', other
+      end
+
+      ##
+      # @return [Integer] timeout to wait for user input
+      #
+      def term_timeout
+        read_attr :'term-timeout', :to_i
+      end
+
+      ##
+      # @param [Integer] timeout to wait for user input
+      #
+      def term_timeout=(other)
+        write_attr :'term-timeout', other
+      end
+
+      ##
+      # @return [Integer] timeout to wait for user input
+      #
+      def complete_timeout
+        read_attr :'complete-timeout', :to_i
+      end
+
+      ##
+      # @param [Integer] timeout to wait for user input
+      #
+      def complete_timeout=(other)
+        write_attr :'complete-timeout', other
+      end
+
+      ##
+      # @return [Integer] timeout to wait for user input
+      #
+      def incomplete_timeout
+        read_attr :'incomplete-timeout', :to_i
+      end
+
+      ##
+      # @param [Integer] timeout to wait for user input
+      #
+      def incomplete_timeout=(other)
+        write_attr :'incomplete-timeout', other
+      end
+
+      ##
+      # @return [Choices] the choices available
+      #
+      def grammar
+        Grammar.new find_first('ns:grammar', :ns => self.class.registered_ns)
+      end
+
+      ##
+      # @param [Hash] choices
+      # @option choices [String] :content_type
+      # @option choices [String] :value the choices available
+      #
+      def grammar=(other)
+        remove_children :grammar
+        grammar = Grammar.new(other) unless other.is_a?(Grammar)
+        self << grammar
+      end
+
+      def inspect_attributes # :nodoc:
+        [:mode, :terminator, :max_digits, :recognizer, :initial_timeout, :inter_digit_timeout, :term_timeout, :complete_timeout, :incomplete_timeout, :sensitivity, :min_confidence, :choices] + super
+      end
+
+      class Grammar < RayoNode
+        ##
+        # @param [Hash] options
+        # @option options [String] :content_type
+        # @option options [String] :value the choices available
+        #
+        def self.new(options = {})
+          super(:grammar).tap do |new_node|
+            case options
+            when Nokogiri::XML::Node
+              new_node.inherit options
+            when Hash
+              new_node.content_type = options[:content_type]
+              new_node.value = options[:value]
+            end
+          end
+        end
+
+        ##
+        # @return [String] the choice content type
+        #
+        def content_type
+          read_attr 'content-type'
+        end
+
+        ##
+        # @param [String] content_type Defaults to the Voxeo Simple Grammar
+        #
+        def content_type=(content_type)
+          write_attr 'content-type', content_type || 'application/grammar+grxml'
+        end
+
+        ##
+        # @return [String] the choices available
+        def value
+          content
+        end
+
+        ##
+        # @param [String] value the choices available
+        def value=(value)
+          Nokogiri::XML::Builder.with(self) do |xml|
+            xml.cdata " #{value} "
+          end
+        end
+
+        # Compare two Choices objects by content type, and value
+        # @param [Header] o the Choices object to compare against
+        # @return [true, false]
+        def eql?(o, *fields)
+          super o, *(fields + [:content_type, :value])
+        end
+
+        def inspect_attributes # :nodoc:
+          [:content_type, :value] + super
+        end
+      end # Choices
+
+      class Complete
+        class Success < Event::Complete::Reason
+          register :success, :input_complete
+
+          ##
+          # @return [Symbol] the mode by which the question was answered. May be :speech or :dtmf
+          #
+          def mode
+            read_attr :mode, :to_sym
+          end
+
+          ##
+          # @return [Float] A measure of the confidence of the result, between 0-1
+          #
+          def confidence
+            read_attr :confidence, :to_f
+          end
+
+          ##
+          # @return [String] An intelligent interpretation of the meaning of the response.
+          #
+          def interpretation
+            find_first('//ns:interpretation', :ns => self.registered_ns).text
+          end
+
+          ##
+          # @return [String] The exact response gained
+          #
+          def utterance
+            find_first('//ns:utterance', :ns => self.registered_ns).text
+          end
+
+          def inspect_attributes # :nodoc:
+            [:mode, :confidence, :interpretation, :utterance] + super
+          end
+        end
+
+        class NoMatch < Event::Complete::Reason
+          register :nomatch, :input_complete
+        end
+
+        class NoInput < Event::Complete::Reason
+          register :noinput, :input_complete
+        end
+      end # Complete
+    end # Input
+  end # Command
+end # Punchblock