cerberus 0.6 → 0.7

data/lib/vendor/xmpp4r/lib/xmpp4r/version.rb

@@ -0,0 +1,7 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/version/helper/responder.rb'
+require 'xmpp4r/version/helper/simpleresponder.rb'
+require 'xmpp4r/version/iq/version.rb'

data/lib/vendor/xmpp4r/lib/xmpp4r/version/helper/responder.rb

@@ -0,0 +1,72 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/callbacks'
+require 'xmpp4r/version/iq/version'
+
+module Jabber
+  module Version
+    ##
+    # A class to answer version requests using IqQueryVersion
+    #
+    # If you don't need the flexibility of dynamic responses with
+    # the callback you can register with add_version_callback,
+    # take a look at SimpleResponder
+    class Responder
+      ##
+      # Initialize a new version responder
+      #
+      # Registers it's callback (prio = 180, ref = self)
+      # stream:: [Stream] Where to register callback handlers
+      def initialize(stream)
+        @stream = stream
+        @versioncbs = CallbackList.new
+
+        stream.add_iq_callback(180, self) { |iq|
+          iq_callback(iq)
+        }
+      end
+
+      ##
+      # Add a callback for Iq stanzas with IqQueryVersion
+      #
+      # First argument passed to block is the Iq stanza,
+      # second argument is a block, which can be called with
+      # software name, version and os
+      #
+      # Example:
+      #   my_version_helper.add_version_callback { |iq,block|
+      #     block.call('Cool client', '6.0', 'Cool OS')
+      #   }
+      def add_version_callback(priority = 0, ref = nil, &block)
+        @versioncbs.add(priority, ref, block)
+      end
+
+      ##
+      # <iq/> callback handler to answer Software Version queries
+      # (registered by constructor and used internally only)
+      #
+      # Used internally
+      def iq_callback(iq)
+        if iq.type == :get
+          if iq.query.kind_of?(IqQueryVersion)
+            replyblock = lambda { |name,version,os|
+              answer = iq.answer
+              answer.type = :result
+              answer.query.set_iname(name).set_version(version).set_os(os)
+
+              @stream.send(answer)
+              true
+            }
+            @versioncbs.process(iq, replyblock)
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/version/helper/simpleresponder.rb

@@ -0,0 +1,44 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/iq'
+require 'xmpp4r/version/helper/responder'
+
+module Jabber
+  module Version
+    ##
+    # A class to answer version requests using IqQueryVersion
+    #
+    # This is simplification as one doesn't need dynamic
+    # version answering normally.
+    #
+    # Example usage:
+    #  Jabber::Version::SimpleResponder.new(my_client, "My cool XMPP4R script", "1.0", "Younicks")
+    class SimpleResponder < Responder
+      attr_accessor :name
+      attr_accessor :version
+      attr_accessor :os
+
+      ##
+      # Initialize a new version responder
+      #
+      # Registers it's callback (prio = 180, ref = self)
+      # stream:: [Stream] Where to register callback handlers
+      # name:: [String] Software name for answers
+      # version:: [String] Software versio for answers
+      # os:: [String] Optional operating system name for answers
+      def initialize(stream, name, version, os=nil)
+        super stream
+
+        @name = name
+        @version = version
+        @os = os
+
+        add_version_callback(180, self) { |iq,block|
+          block.call(@name, @version, @os)
+        }
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/version/iq/version.rb

@@ -0,0 +1,105 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/query'
+
+module Jabber
+  module Version
+    ##
+    # Class for handling queries for 'Software Version'
+    # (JEP 0092)
+    #
+    # Notice that according to JEP 0092 only the <os/> element can be omitted,
+    # <name/> (iname) and <version/> must be present
+    class IqQueryVersion < IqQuery
+      name_xmlns 'query', 'jabber:iq:version'
+
+      ##
+      # Create a new <query xmlns='jabber:iq:version'/> element
+      def initialize(iname=nil, version=nil, os=nil)
+        super()
+        set_iname(iname) if iname
+        set_version(version) if version
+        set_os(os) if os
+      end
+
+      ##
+      # Get the name of the software
+      #
+      # This has been renamed to 'iname' here to keep
+      # REXML::Element#name accessible
+      def iname
+        first_element_text('name')
+      end
+
+      ##
+      # Set the name of the software
+      #
+      # The element won't be deleted if text is nil as
+      # it must occur in a version query, but its text will
+      # be empty.
+      def iname=(text)
+        replace_element_text('name', text.nil? ? '' : text)
+      end
+
+      ##
+      # Set the name of the software (chaining-friendly)
+      # result:: [String] or nil
+      def set_iname(text)
+        self.iname = text
+        self
+      end
+
+      ##
+      # Get the version of the software
+      # result:: [String] or nil
+      def version
+        first_element_text('version')
+      end
+
+      ##
+      # Set the version of the software
+      #
+      # The element won't be deleted if text is nil as
+      # it must occur in a version query
+      def version=(text)
+        replace_element_text('version', text.nil? ? '' : text)
+      end
+
+      ##
+      # Set the version of the software (chaining-friendly)
+      # text:: [String]
+      def set_version(text)
+        self.version = text
+        self
+      end
+
+      ##
+      # Get the operating system or nil
+      # (os is not mandatory for Version Query)
+      def os
+        first_element_text('os')
+      end
+
+      ##
+      # Set the os of the software
+      # text:: [String] or nil
+      def os=(text)
+        if text
+          replace_element_text('os', text)
+        else
+          delete_elements('os')
+        end
+      end
+
+      ##
+      # Set the os of the software (chaining-friendly)
+      # text:: [String] or nil
+      def set_os(text)
+        self.os = text
+        self
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/x.rb

@@ -0,0 +1,37 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/xmppelement'
+
+module Jabber
+  ##
+  # A class used to build/parse <x/> elements
+  #
+  # These elements may occur as "attachments"
+  # in [Message] and [Presence] stanzas
+  class X < XMPPElement
+    name_xmlns 'x'
+    force_xmlns true
+  end
+
+  module XParent
+    ##
+    # Get the first <x/> element in this stanza, or nil if none found.
+    # wanted_xmlns:: [String] Optional, find the first <x/> element having this xmlns,
+    # wanted_xmlns can also be a derivate of XMPPElement from which the namespace will be taken
+    # result:: [REXML::Element] or nil
+    def x(wanted_xmlns=nil)
+      if wanted_xmlns.kind_of? Class and wanted_xmlns.ancestors.include? XMPPElement
+        wanted_xmlns = wanted_xmlns.new.namespace
+      end
+
+        each_element('x') { |x|
+        if wanted_xmlns.nil? or wanted_xmlns == x.namespace
+          return x
+        end
+      }
+      nil
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/xhtml.rb

@@ -0,0 +1 @@
+require 'xmpp4r/xhtml/html'

data/lib/vendor/xmpp4r/lib/xmpp4r/xhtml/html.rb

@@ -0,0 +1,115 @@
+require 'xmpp4r/xmppelement'
+
+module Jabber
+  module XHTML
+    NS_XHTML_IM = 'http://jabber.org/protocol/xhtml-im'
+    NS_XHTML = 'http://www.w3.org/1999/xhtml'
+
+    ##
+    # XHTML-IM (XEP-0071) container
+    #
+    # The important methods are:
+    # * HTML#contents=
+    # * HTML#to_text
+    class HTML < XMPPElement
+      name_xmlns 'html', NS_XHTML_IM
+      force_xmlns true
+
+      ##
+      # Initialize element with HTML contents (see HTML#contents=)
+      def initialize(contents=[])
+        super()
+        self.contents = contents
+      end
+
+      ##
+      # Get first XHTML::Body child
+      def body
+        first_element('body') || add(Body.new)
+      end
+
+      ##
+      # Replace first XHTML::Body child
+      def body=(body)
+        delete_elements('body')
+        add(body)
+      end
+
+      ##
+      # Replace first XHTML::Body child (chainable)
+      def set_body(body)
+        self.body = body
+        self
+      end
+
+      ##
+      # Set contents of this HTML document. The "contents" parameter can be:
+      # * An Array of REXML::Element and Strings which will replace the current children of the body
+      # * A single REXML::Element which will replace all other children of the body
+      # * An instance of XHTML::Body which will replace the current body
+      # * A String comprising an HTML fragment. This will be parsed, which could raise an Exception.
+      #   We must never send invalid XML over an XMPP stream. If you intend to put variable data in
+      #   your HTML, use something like Rails' Builder::XmlMarkup or Ramaze::Gestalt
+      def contents=(contents)
+        if contents.kind_of? String
+          self.body = REXML::Document.new("<body xmlns='#{NS_XHTML}'>#{contents}</body>").root
+        elsif contents.kind_of? Body
+          self.body = contents
+        elsif contents.kind_of? Array
+          self.body = Body.new
+          contents.each do |element|
+            if element.kind_of? String
+              body.add_text(element)
+            else
+              body.add(element)
+            end
+          end
+        else
+          self.body = Body.new
+          body.add(contents)
+        end
+      end
+
+      ##
+      # HTML#contents= chainable
+      def set_contents(contents)
+        self.contents = contents
+        self
+      end
+
+      ##
+      # Convert contents of this XHTML container to plain text
+      # for easy usage with an additional fall-back <body/> in message stanzas
+      #
+      # The resulting string is recursively composed of the text nodes of
+      # all children.
+      # This works because of the design criteria of HTML/XHTML:
+      # readable content is not being put into attributes but as text children.
+      #
+      # If you require clickable links and proper information representation
+      # then compose the text yourself!
+      def to_text
+        text_getter = nil # Create binding so that the following lambda can work recursively
+
+        text_getter = lambda do |element|
+          if element.kind_of? REXML::Text
+            element.value
+          elsif element.kind_of? REXML::Element
+            element.children.collect { |child|
+              text_getter.call(child)
+            }.join
+          end
+        end
+
+        text_getter.call(self) # Finally, execute and return results
+      end
+    end
+
+    ##
+    # HTML Body element, must be the only child of XHTML::HTML
+    class Body < XMPPElement
+      name_xmlns 'body', NS_XHTML
+      force_xmlns true
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/xmpp4r.rb

@@ -0,0 +1,18 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+##
+# The Jabber module is the root namespace of the library.
+module Jabber
+  # XMPP4R Version number.  This is the ONLY place where the version number
+  # should be specified.  This constant is used to determine the version of
+  # package tarballs and generated gems.
+  XMPP4R_VERSION = '0.4'
+end
+
+require 'xmpp4r/client'
+require 'xmpp4r/component'
+require 'xmpp4r/debuglog'
+require 'xmpp4r/errors'
+

data/lib/vendor/xmpp4r/lib/xmpp4r/xmppelement.rb

@@ -0,0 +1,168 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/rexmladdons'
+
+module Jabber
+
+  ##
+  # This class represents an XML element and provides functionality
+  # for automatic casting of XML element classes according to their
+  # element name and namespace.
+  #
+  # Deriving classes must met these criteria:
+  # * The element name and namespace must be specified by calling
+  #   the name_xmlns class method
+  # * The class constructor must be callable with no mandatory parameter
+  class XMPPElement < REXML::Element
+    @@name_xmlns_classes = {}
+    @@force_xmlns = false
+
+    ##
+    # Specify XML element name and xmlns for a deriving class,
+    # this pair and the class will be added to a global pool
+    #
+    # If the namespace is nil the class is a "wildcard class"
+    # matching elements with any xmlns if no other class with
+    # that namespace was defined
+    def self.name_xmlns(name, xmlns=nil)
+      @@name_xmlns_classes[[name, xmlns]] = self
+    end
+
+    ##
+    # Set whether this element is always built with an xmlns attribute
+    def self.force_xmlns(force)
+      @@force_xmlns = force
+    end
+
+    ##
+    # Whether this element is always built with an xmlns attribute
+    def self.force_xmlns?
+      @@force_xmlns
+    end
+
+    ##
+    # Find the name and namespace for a given class.
+    # This class must have registered these two values
+    # by calling name_xmlns at definition time.
+    #
+    # Raises an exception if none was found
+    # klass:: [Class]
+    # result:: [String, String] name and namespace
+    def self.name_xmlns_for_class(klass)
+      klass.ancestors.each do |klass1|
+        @@name_xmlns_classes.each do |name_xmlns,k|
+          if klass1 == k
+            return name_xmlns
+          end
+        end
+      end
+
+      raise NoNameXmlnsRegistered.new(klass)
+    end
+
+    ##
+    # Find a class for given name and namespace
+    # name:: [String]
+    # xmlns:: [String]
+    # result:: A descendant of XMPPElement or REXML::Element
+    def self.class_for_name_xmlns(name, xmlns)
+      if @@name_xmlns_classes.has_key? [name, xmlns]
+        @@name_xmlns_classes[[name, xmlns]]
+      elsif @@name_xmlns_classes.has_key? [name, nil]
+        @@name_xmlns_classes[[name, nil]]
+      else
+        REXML::Element
+      end
+    end
+
+    ##
+    # Import another REXML::Element descendant to:
+    # * Either an element class that registered with
+    #   name and xmlns before
+    # * Or if none was found to the class itself
+    #   (you may call this class method on a deriving class)
+    def self.import(element)
+      klass = class_for_name_xmlns(element.name, element.namespace)
+      if klass != self and klass.ancestors.include?(self)
+        klass.new.import(element)
+      else
+        self.new.import(element)
+      end
+    end
+
+    ##
+    # Initialize this element, which will then be initialized
+    # with the name registered with name_xmlns.
+    def initialize(*arg)
+      if arg.empty?
+        name, xmlns = self.class::name_xmlns_for_class(self.class)
+        super(name)
+        if self.class::force_xmlns?
+          add_namespace(xmlns)
+        end
+      else
+        super
+      end
+    end
+
+    ##
+    # Add a child element which will be imported according to the
+    # child's name and xmlns
+    # element:: [REXML::Element] Child
+    # result:: [REXML::Element or descendant of XMPPElement] New child
+    def typed_add(element)
+      if element.kind_of? REXML::Element
+        element_ns = (element.namespace.to_s == '') ? namespace : element.namespace
+
+        klass = XMPPElement::class_for_name_xmlns(element.name, element_ns)
+        if klass != element.class
+          element = klass.import(element)
+        end
+      end
+
+      super(element)
+    end
+
+    def parent=(new_parent)
+      if parent and parent.namespace('') == namespace('') and attributes['xmlns'].nil?
+        add_namespace parent.namespace('')
+      end
+
+      super
+
+      if new_parent and new_parent.namespace('') == namespace('')
+        delete_namespace
+      end
+    end
+
+    def clone
+      cloned = self.class.new
+      cloned.add_attributes self.attributes.clone
+      cloned.context = @context
+      cloned
+    end
+
+    ##
+    # Generic XML attribute 'xml:lang'
+    # (REXML provides no shortcut)
+    def xml_lang
+      attributes['xml:lang']
+    end
+
+    ##
+    # Set XML language attribute
+    def xml_lang=(l)
+      attributes['xml:lang'] = l
+    end
+
+    ##
+    # Set XML language attribute (chainable)
+    def set_xml_lang(l)
+      self.xml_lang = l
+      self
+    end
+
+  end
+end