shingara-blather 0.4.8

data/lib/blather/xmpp_node.rb

@@ -0,0 +1,218 @@
+module Blather
+
+  # Base XML Node
+  # All XML classes subclass XMPPNode it allows the addition of helpers
+  class XMPPNode < Nokogiri::XML::Node
+    # @private
+    BASE_NAMES = %w[presence message iq].freeze
+
+    # @private
+    @@registrations = {}
+
+    class_inheritable_accessor  :registered_ns,
+                                :registered_name
+
+    # Register a new stanza class to a name and/or namespace
+    #
+    # This registers a namespace that is used when looking
+    # up the class name of the object to instantiate when a new
+    # stanza is received
+    #
+    # @param [#to_s] name the name of the node
+    # @param [String, nil] ns the namespace the node belongs to
+    def self.register(name, ns = nil)
+      self.registered_name = name.to_s
+      self.registered_ns = ns
+      @@registrations[[self.registered_name, self.registered_ns]] = self
+    end
+
+    # Find the class to use given the name and namespace of a stanza
+    #
+    # @param [#to_s] name the name to lookup
+    # @param [String, nil] xmlns the namespace the node belongs to
+    # @return [Class, nil] the class appropriate for the name/ns combination
+    def self.class_from_registration(name, ns = nil)
+      name = name.to_s
+      @@registrations[[name, ns]] || @@registrations[[name, nil]]
+    end
+
+    # Import an XML::Node to the appropriate class
+    #
+    # Looks up the class the node should be then creates it based on the
+    # 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)
+      ns = (node.namespace.href if node.namespace)
+      klass = class_from_registration(node.element_name, ns)
+      if klass && klass != self
+        klass.import(node)
+      else
+        new(node.element_name).inherit(node)
+      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 = nil, doc = nil)
+      name ||= self.registered_name
+
+      node = super name.to_s, (doc || Nokogiri::XML::Document.new)
+      node.document.root = node unless doc
+      node.namespace = self.registered_ns unless BASE_NAMES.include?(name.to_s)
+      node
+    end
+
+    # Helper method to read an attribute
+    #
+    # @param [#to_sym] attr_name the name of the attribute
+    # @param [String, Symbol, nil] to_call the name of the method to call on
+    # the returned value
+    # @return nil or the value
+    def read_attr(attr_name, to_call = nil)
+      val = self[attr_name.to_sym]
+      val && to_call ? val.__send__(to_call) : val
+    end
+
+    # Helper method to write a value to an attribute
+    #
+    # @param [#to_sym] attr_name the name of the attribute
+    # @param [#to_s] value the value to set the attribute to
+    def write_attr(attr_name, value)
+      self[attr_name.to_sym] = value
+    end
+
+    # Helper method to read the content of a node
+    #
+    # @param [#to_sym] node the name of the node
+    # @param [String, Symbol, nil] to_call the name of the method to call on
+    # the returned value
+    # @return nil or the value
+    def read_content(node, to_call = nil)
+      val = content_from node.to_sym
+      val && to_call ? val.__send__(to_call) : val
+    end
+
+    # Turn the object into a proper stanza
+    #
+    # @return a stanza object
+    def to_stanza
+      self.class.import self
+    end
+
+    # @private
+    alias_method :nokogiri_namespace=, :namespace=
+    # Attach a namespace to the node
+    #
+    # @overload namespace=(ns)
+    #   Attach an already created XML::Namespace
+    #   @param [XML::Namespace] ns the namespace object
+    # @overload namespace=(ns)
+    #   Create a new namespace and attach it
+    #   @param [String] ns the namespace uri
+    # @overload namespace=(namespaces)
+    #   Createa and add new namespaces from a hash
+    #   @param [Hash] namespaces a hash of prefix => uri pairs
+    def namespace=(namespaces)
+      case namespaces
+      when Nokogiri::XML::Namespace
+        self.nokogiri_namespace = namespaces
+      when String
+        self.add_namespace nil, namespaces
+      when Hash
+        if ns = namespaces.delete(nil)
+          self.add_namespace nil, ns
+        end
+        namespaces.each do |p, n|
+          ns = self.add_namespace p, n
+          self.nokogiri_namespace = ns
+        end
+      end
+    end
+
+    # Helper method to get the node's namespace
+    #
+    # @return [XML::Namespace, nil] The node's namespace object if it exists
+    def namespace_href
+      namespace.href if namespace
+    end
+
+    # Remove a child with the name and (optionally) namespace given
+    #
+    # @param [String] name the name or xpath of the node to remove
+    # @param [String, nil] ns the namespace the node is in
+    def remove_child(name, ns = nil)
+      child = xpath(name, ns).first
+      child.remove if child
+    end
+
+    # Remove all children with a given name regardless of namespace
+    #
+    # @param [String] name the name of the nodes to remove
+    def remove_children(name)
+      xpath("./*[local-name()='#{name}']").remove
+    end
+
+    # The content of the named node
+    #
+    # @param [String] name the name or xpath of the node
+    # @param [String, nil] ns the namespace the node is in
+    # @return [String, nil] the content of the node
+    def content_from(name, ns = nil)
+      child = xpath(name, ns).first
+      child.content if child
+    end
+
+    # Sets the content for the specified node.
+    # If the node exists it is updated. If not a new node is created
+    # If the node exists and the content is nil, the node will be removed
+    # entirely
+    #
+    # @param [String] node the name of the node to update/create
+    # @param [String, nil] content the content to set within the node
+    def set_content_for(node, content = nil)
+      if content
+        child = xpath(node).first
+        self << (child = XMPPNode.new(node, self.document)) unless child
+        child.content = content
+      else
+        remove_child node
+      end
+    end
+
+    alias_method :copy, :dup
+
+    # Inherit the attributes and children of an XML::Node
+    #
+    # @param [XML::Node] stanza the node to inherit
+    # @return [self]
+    def inherit(stanza)
+      set_namespace stanza.namespace if stanza.namespace
+      inherit_attrs stanza.attributes
+      stanza.children.each do |c|
+        self << (n = c.dup)
+        ns = n.namespace_definitions.find { |ns| ns.prefix == c.namespace.prefix }
+        n.namespace = ns if ns
+      end
+      self
+    end
+
+    # Inherit a set of attributes
+    #
+    # @param [Hash] attrs a hash of attributes to set on the node
+    # @return [self]
+    def inherit_attrs(attrs)
+      attrs.each  { |name, value| self[name] = value }
+      self
+    end
+
+    def inspect
+      self.to_xml
+    end
+  end  # XMPPNode
+
+end  # Blather

data/lib/blather.rb

@@ -0,0 +1,78 @@
+# Require the necessary files
+%w[
+  rubygems
+  eventmachine
+  nokogiri
+  digest/md5
+  logger
+  active_support/core_ext/class/inheritable_attributes
+  active_support/core_ext/object/blank
+
+  blather/core_ext/nokogiri
+
+  blather/errors
+  blather/errors/sasl_error
+  blather/errors/stanza_error
+  blather/errors/stream_error
+  blather/jid
+  blather/roster
+  blather/roster_item
+  blather/xmpp_node
+
+  blather/stanza
+  blather/stanza/iq
+  blather/stanza/iq/query
+  blather/stanza/iq/roster
+  blather/stanza/disco
+  blather/stanza/disco/disco_info
+  blather/stanza/disco/disco_items
+  blather/stanza/message
+  blather/stanza/presence
+  blather/stanza/presence/status
+  blather/stanza/presence/subscription
+
+  blather/stanza/pubsub
+  blather/stanza/pubsub/affiliations
+  blather/stanza/pubsub/create
+  blather/stanza/pubsub/event
+  blather/stanza/pubsub/items
+  blather/stanza/pubsub/publish
+  blather/stanza/pubsub/retract
+  blather/stanza/pubsub/subscribe
+  blather/stanza/pubsub/subscription
+  blather/stanza/pubsub/subscriptions
+  blather/stanza/pubsub/unsubscribe
+
+  blather/stanza/pubsub_owner
+  blather/stanza/pubsub_owner/delete
+  blather/stanza/pubsub_owner/purge
+
+  blather/stream
+  blather/stream/client
+  blather/stream/component
+  blather/stream/parser
+  blather/stream/features
+  blather/stream/features/resource
+  blather/stream/features/sasl
+  blather/stream/features/session
+  blather/stream/features/tls
+].each { |r| require r }
+
+module Blather
+  # @private
+  @@logger = nil
+
+  # Get or create an instance of Logger
+  def self.logger
+    unless @@logger
+      self.logger = Logger.new($stdout)
+      self.logger.level = Logger::INFO
+    end
+    @@logger
+  end
+
+  # Set the Logger
+  def self.logger=(logger)
+    @@logger = logger
+  end
+end