punchblock 1.9.4 → 2.0.0.beta1

data/lib/punchblock/connection/xmpp.rb

@@ -11,7 +11,7 @@ module Punchblock
   module Connection
     class XMPP < GenericConnection
       include Blather::DSL
-      attr_accessor :event_handler, :root_domain, :calls_domain, :mixers_domain
+      attr_accessor :event_handler, :root_domain
 
       ##
       # Initialize the required connection attributes
@@ -29,11 +29,8 @@ module Punchblock
 
         setup(*[:username, :password, :host, :port, :certs, :connection_timeout].map { |key| options.delete key })
 
-        @root_domain    = Blather::JID.new(options[:root_domain] || options[:rayo_domain] || @username).domain
-        @calls_domain   = options[:calls_domain]  || "calls.#{@root_domain}"
-        @mixers_domain  = options[:mixers_domain] || "mixers.#{@root_domain}"
+        @root_domain = Blather::JID.new(options[:root_domain] || options[:rayo_domain] || @username).domain
 
-        @callmap = {} # This hash maps call IDs to their XMPP domain.
         @joined_mixers = []
 
         @ping_period = options.has_key?(:ping_period) ? options[:ping_period] : 60
@@ -62,12 +59,13 @@ module Punchblock
         command.connection    = self
         command.target_call_id    ||= options[:call_id]
         command.target_mixer_name ||= options[:mixer_name]
+        command.domain            ||= options[:domain]
         command.component_id      ||= options[:component_id]
         if command.is_a?(Command::Join) && command.mixer_name
           @joined_mixers << command.mixer_name
         end
         create_iq(jid_for_command(command)).tap do |iq|
-          iq << command
+          command.to_rayo(iq)
         end
       end
 
@@ -111,15 +109,11 @@ module Punchblock
 
         if command.target_call_id
           node = command.target_call_id
-          domain = @callmap[command.target_call_id] || calls_domain
         elsif command.target_mixer_name
           node = command.target_mixer_name
-          domain = @callmap[command.target_mixer_name] || mixers_domain
-        else
-          domain = calls_domain
         end
 
-        Blather::JID.new(node, domain, command.component_id).to_s
+        Blather::JID.new(node, command.domain || root_domain, command.component_id).to_s
       end
 
       def send_presence(presence)
@@ -130,10 +124,10 @@ module Punchblock
 
       def handle_presence(p)
         throw :pass unless p.rayo_event?
-        @callmap[p.call_id] = p.from.domain
         event = p.event
         event.connection = self
         event.domain = p.from.domain
+        event.transport = "xmpp"
         if @joined_mixers.include?(p.call_id)
           event.target_mixer_name = p.call_id
         else
@@ -143,8 +137,6 @@ module Punchblock
       end
 
       def handle_iq_result(iq, command)
-        # FIXME: Do we need to raise a warning if the domain changes?
-        @callmap[iq.from.node] = iq.from.domain
         command.response = iq.rayo_node.is_a?(Ref) ? iq.rayo_node : true
       end
 

data/lib/punchblock/core_ext/blather/stanza.rb

@@ -8,7 +8,7 @@ module Blather
     #
     def rayo_node
       first_child = at_xpath '*'
-      Punchblock::RayoNode.import first_child, nil, component_id if first_child
+      Punchblock::RayoNode.from_xml first_child, nil, component_id if first_child
     rescue Punchblock::RayoNode::InvalidNodeError
       nil
     end

data/lib/punchblock/event/active_speaker.rb

@@ -3,16 +3,8 @@
 module Punchblock
   class Event
     module ActiveSpeaker
-      def call_id
-        read_attr :'call-id'
-      end
-
-      def call_id=(other)
-        write_attr :'call-id', other
-      end
-
-      def inspect_attributes # :nodoc:
-        [:call_id] + super
+      def self.included(klass)
+        klass.attribute :call_id
       end
     end
   end

data/lib/punchblock/event/answered.rb

@@ -6,6 +6,6 @@ module Punchblock
       register :answered, :core
 
       include HasHeaders
-    end # End
-  end # Event
-end # Punchblock
+    end
+  end
+end

data/lib/punchblock/event/asterisk/ami/event.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'punchblock/key_value_pair_node'
-
 module Punchblock
   class Event
     module Asterisk
@@ -9,60 +7,30 @@ module Punchblock
         class Event < Punchblock::Event
           register :event, :ami
 
-          def self.new(options = {})
-            super().tap do |new_node|
-              options.each_pair { |k,v| new_node.send :"#{k}=", v }
-            end
-          end
-
-          def name
-            read_attr :name
-          end
+          attribute :name
+          attribute :headers, Hash, default: {}
 
-          def name=(other)
-            write_attr :name, other
-          end
+          alias :attributes :headers
 
-          ##
-          # @return [Hash] hash of key-value pairs of attributes
-          #
-          def attributes_hash
-            attributes.inject({}) do |hash, attribute|
-              hash[attribute.name.downcase.gsub('-', '_').to_sym] = attribute.value
-              hash
+          def inherit(xml_node)
+            xml_node.xpath('//ns:attribute', ns: self.class.registered_ns).to_a.each do |attribute|
+              headers[attribute[:name]] = attribute[:value]
             end
+            super
           end
 
-          ##
-          # @return [Array[Attribute]] attributes
-          #
-          def attributes
-            find('//ns:attribute', :ns => self.class.registered_ns).map do |i|
-              Attribute.new i
-            end
+          def rayo_attributes
+            {'name' => name}
           end
 
-          ##
-          # @param [Hash, Array] attributes A hash of key-value attribute pairs, or an array of Attribute objects
-          #
-          def attributes=(attributes)
-            find('//ns:attribute', :ns => self.class.registered_ns).each(&:remove)
-            if attributes.is_a? Hash
-              attributes.each_pair { |k,v| self << Attribute.new(k, v) }
-            elsif attributes.is_a? Array
-              [attributes].flatten.each { |i| self << Attribute.new(i) }
+          def rayo_children(root)
+            super
+            headers.each do |name, value|
+              root.attribute name: name, value: value
             end
           end
-
-          def inspect_attributes # :nodoc:
-            [:name, :attributes_hash] + super
-          end
-
-          class Attribute < RayoNode
-            include KeyValuePairNode
-          end
         end
       end
     end
-  end # Command
-end # Punchblock
+  end
+end

data/lib/punchblock/event/complete.rb

@@ -5,51 +5,34 @@ module Punchblock
     class Complete < Event
       register :complete, :ext
 
-      def reason
-        element = find_first '*'
-        return unless element
-        RayoNode.import(element).tap do |reason|
-          reason.target_call_id = target_call_id
-          reason.component_id = component_id
-        end
-      end
+      attribute :reason
 
-      def reason=(other)
-        children.map(&:remove)
-        self << other
-      end
+      attribute :recording
 
-      def recording
-        element = find_first('//ns:recording', :ns => RAYO_NAMESPACES[:record_complete])
-        return unless element
-        RayoNode.import(element).tap do |recording|
-          recording.target_call_id = target_call_id
-          recording.component_id = component_id
+      def inherit(xml_node)
+        if reason_node = xml_node.at_xpath('*')
+          self.reason = RayoNode.from_xml(reason_node).tap do |reason|
+            reason.target_call_id = target_call_id
+            reason.component_id = component_id
+          end
         end
-      end
-
-      def inspect_attributes # :nodoc:
-        [:reason, :recording] + super
-      end
 
-      class Reason < RayoNode
-        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
+        if recording_node = xml_node.at_xpath('//ns:recording', ns: RAYO_NAMESPACES[:record_complete])
+          self.recording = RayoNode.from_xml(recording_node).tap do |recording|
+            recording.target_call_id = target_call_id
+            recording.component_id = component_id
           end
         end
 
-        def name
-          super.to_sym
-        end
+        super
+      end
+
+      class Reason < RayoNode
+        attribute :name
 
-        def inspect_attributes # :nodoc:
-          [:name] + super
+        def inherit(xml_node)
+          self.name = xml_node.name.to_sym
+          super
         end
       end
 
@@ -64,18 +47,13 @@ module Punchblock
       class Error < Reason
         register :error, :ext_complete
 
-        def details
-          text.strip
-        end
-
-        def details=(other)
-          self << other
-        end
+        attribute :details
 
-        def inspect_attributes # :nodoc:
-          [:details] + super
+        def inherit(xml_node)
+          self.details = xml_node.text.strip
+          super
         end
       end
-    end # Complete
+    end
   end
-end # Punchblock
+end

data/lib/punchblock/event/dtmf.rb

@@ -5,17 +5,7 @@ module Punchblock
     class DTMF < Event
       register :dtmf, :core
 
-      def signal
-        read_attr :signal
-      end
-
-      def signal=(other)
-        write_attr :signal, other
-      end
-
-      def inspect_attributes # :nodoc:
-        [:signal] + super
-      end
-    end # End
+      attribute :signal
+    end
   end
-end # Punchblock
+end

data/lib/punchblock/event/end.rb

@@ -7,17 +7,16 @@ module Punchblock
 
       include HasHeaders
 
-      def reason
-        children.select { |c| c.is_a? Nokogiri::XML::Element }.first.name.to_sym
-      end
-
-      def reason=(other)
-        self << Nokogiri::XML::Element.new(other.to_s, self.document)
-      end
+      attribute :reason, Symbol
+      attribute :platform_code, String
 
-      def inspect_attributes # :nodoc:
-        [:reason] + super
+      def inherit(xml_node)
+        if reason_node = xml_node.at_xpath('*')
+          self.reason = reason_node.name
+          self.platform_code = reason_node['platform-code']
+        end
+        super
       end
-    end # End
+    end
   end
-end # Punchblock
+end

data/lib/punchblock/event/joined.rb

@@ -5,33 +5,13 @@ module Punchblock
     class Joined < Event
       register :joined, :core
 
-      ##
       # @return [String] the call ID that was joined
-      def call_id
-        read_attr :'call-id'
-      end
+      attribute :call_uri
 
-      ##
-      # @param [String] other the call ID that was joined
-      def call_id=(other)
-        write_attr :'call-id', other
-      end
-
-      ##
       # @return [String] the mixer name that was joined
-      def mixer_name
-        read_attr :'mixer-name'
-      end
-
-      ##
-      # @param [String] other the mixer name that was joined
-      def mixer_name=(other)
-        write_attr :'mixer-name', other
-      end
+      attribute :mixer_name
 
-      def inspect_attributes # :nodoc:
-        [:call_id, :mixer_name] + super
-      end
-    end # Joined
+      alias :call_id :call_uri
+    end
   end
-end # Punchblock
+end

data/lib/punchblock/event/offer.rb

@@ -7,29 +7,8 @@ module Punchblock
 
       include HasHeaders
 
-      def to
-        read_attr :to
-      end
-
-      def to=(offer_to)
-        write_attr :to, offer_to
-      end
-
-      def from
-        read_attr :from
-      end
-
-      def from=(offer_from)
-        write_attr :from, offer_from
-      end
-
-      def inspect_attributes # :nodoc:
-        [:to, :from] + super
-      end
-
-      def inspect
-        "#<Punchblock::Event::Offer to=\"#{to}\", from=\"#{from}\", headers=#{headers_hash.inspect}, call_id=\"#{target_call_id}\""
-      end
-    end # Offer
+      attribute :to
+      attribute :from
+    end
   end
-end # Punchblock
+end

data/lib/punchblock/event/ringing.rb

@@ -6,6 +6,6 @@ module Punchblock
       register :ringing, :core
 
       include HasHeaders
-    end # End
-  end # Event
-end # Punchblock
+    end
+  end
+end

data/lib/punchblock/event/unjoined.rb

@@ -5,33 +5,13 @@ module Punchblock
     class Unjoined < Event
       register :unjoined, :core
 
-      ##
       # @return [String] the call ID that was unjoined
-      def call_id
-        read_attr :'call-id'
-      end
+      attribute :call_uri
 
-      ##
-      # @param [String] other the call ID that was unjoined
-      def call_id=(other)
-        write_attr :'call-id', other
-      end
-
-      ##
       # @return [String] the mixer name that was unjoined
-      def mixer_name
-        read_attr :'mixer-name'
-      end
-
-      ##
-      # @param [String] other the mixer name that was unjoined
-      def mixer_name=(other)
-        write_attr :'mixer-name', other
-      end
+      attribute :mixer_name
 
-      def inspect_attributes # :nodoc:
-        [:call_id, :mixer_name] + super
-      end
-    end # Unjoined
+      alias :call_id :call_uri
+    end
   end
-end # Punchblock
+end

data/lib/punchblock/event.rb

@@ -2,16 +2,6 @@
 
 module Punchblock
   class Event < RayoNode
-    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
   end
 end
 

data/lib/punchblock/has_headers.rb

@@ -2,39 +2,33 @@
 
 module Punchblock
   module HasHeaders
-    ##
-    # @return [Hash] hash of key-value pairs of headers
-    #
-    def headers_hash
-      headers.inject({}) do |hash, header|
-        hash[header.name.downcase.gsub('-', '_').to_sym] = header.value
-        hash
-      end
+    def self.included(klass)
+      klass.attribute :headers, Hash, default: {}
     end
 
-    ##
-    # @return [Array[Header]] headers
-    #
-    def headers
-      find('//ns:header', :ns => self.class.registered_ns).map do |i|
-        Header.new i
-      end
+    def headers=(other)
+      super(other || {})
     end
 
-    ##
-    # @param [Hash, Array] headers A hash of key-value header pairs, or an array of Header objects
-    #
-    def headers=(headers)
-      find('//ns:header', :ns => self.class.registered_ns).each(&:remove)
-      if headers.is_a? Hash
-        headers.each_pair { |k,v| self << Header.new(k, v) }
-      elsif headers.is_a? Array
-        [headers].flatten.each { |i| self << Header.new(i) }
+    def inherit(xml_node)
+      xml_node.xpath('//ns:header', ns: self.class.registered_ns).to_a.each do |header|
+        if headers.has_key?(header[:name])
+          headers[header[:name]] = [headers[header[:name]]]
+          headers[header[:name]] << header[:value]
+        else
+          headers[header[:name]] = header[:value]
+        end
       end
+      super
     end
 
-    def inspect_attributes # :nodoc:
-      [:headers_hash] + super
+    def rayo_children(root)
+      super
+      headers.each do |name, value|
+        Array(value).each do |v|
+          root.header name: name, value: v
+        end
+      end
     end
   end
 end

data/lib/punchblock/rayo_node.rb

@@ -1,17 +1,25 @@
 # encoding: utf-8
 
 require 'active_support/core_ext/class/attribute'
-require 'niceogiri'
+require 'virtus'
 
 module Punchblock
-  class RayoNode < Niceogiri::XML::Node
+  class RayoNode
+    include Virtus
+
     InvalidNodeError = Class.new Punchblock::Error
 
     @@registrations = {}
 
     class_attribute :registered_ns, :registered_name
 
-    attr_accessor :target_call_id, :target_mixer_name, :component_id, :domain, :connection, :client, :original_component
+    attribute :target_call_id
+    attribute :target_mixer_name
+    attribute :component_id
+    attribute :domain
+    attribute :transport
+
+    attr_accessor :connection, :client, :original_component
 
     # Register a new stanza class to a name and/or namespace
     #
@@ -42,12 +50,11 @@ module Punchblock
     # elements of the XML::Node
     # @param [XML::Node] node the node to import
     # @return the appropriate object based on the node name and namespace
-    def self.import(node, call_id = nil, component_id = nil)
-      node = Nokogiri::XML(node.to_xml).root if Punchblock.jruby?
+    def self.from_xml(node, call_id = nil, component_id = nil)
       ns = (node.namespace.href if node.namespace)
-      klass = class_from_registration(node.element_name, ns)
+      klass = class_from_registration(node.name, ns)
       if klass && klass != self
-        klass.import node, call_id, component_id
+        klass.from_xml node, call_id, component_id
       else
         new.inherit node
       end.tap do |event|
@@ -56,27 +63,23 @@ module Punchblock
       end
     end
 
-    # Create a new Node object
-    #
-    # @param [String, nil] name the element name
-    # @param [XML::Document, nil] doc the document to attach the node to. If
-    # not provided one will be created
-    # @return a new object with the registered name and namespace
-    def self.new(name = registered_name, doc = nil)
-      raise InvalidNodeError, "Trying to create a new #{self} with no name" unless name
-      super name, doc, registered_ns
+    def inherit(xml_node)
+      xml_node.attributes.each do |key, attr_node|
+        send "#{key.gsub('-', '_')}=", xml_node[key]
+      end
+      self
     end
 
-    def inspect_attributes # :nodoc:
-      [:target_call_id, :component_id, :target_mixer_name]
+    def inspect
+      "#<#{self.class} #{to_hash.map { |k, v| "#{k}=#{v.inspect}" }.compact * ', '}>"
     end
 
-    def inspect
-      "#<#{self.class} #{inspect_attributes.map { |c| "#{c}=#{self.__send__(c).inspect rescue nil}" }.compact * ', '}>"
+    def ==(o)
+      o.is_a?(self.class) && self.to_hash == o.to_hash
     end
 
-    def eql?(o, *fields)
-      super o, *(fields + inspect_attributes)
+    def to_hash
+      get_attributes(&:public_reader?)
     end
 
     ##
@@ -87,7 +90,27 @@ module Punchblock
       @source ||= original_component
     end
 
+    def rayo_attributes
+      {}
+    end
+
+    def rayo_children(root)
+    end
+
+    def to_rayo(parent = nil)
+      parent = parent.parent if parent.is_a?(Nokogiri::XML::Builder)
+      Nokogiri::XML::Builder.with(parent) do |xml|
+        xml.send(registered_name,
+          {xmlns: registered_ns}.merge(rayo_attributes.delete_if { |k,v| v.nil? })) do |root|
+          rayo_children root
+        end
+      end.doc.root
+    end
+
+    def to_xml
+      to_rayo.to_xml
+    end
+
     alias :to_s :inspect
-    alias :xmlns :namespace_href
   end
 end