blather 0.1

data/lib/blather/core/xmpp_node.rb

@@ -0,0 +1,132 @@
+module Blather
+
+  ##
+  # Base XML Node
+  # All XML classes subclass XMPPNode
+  # it allows the addition of helpers
+  class XMPPNode < XML::Node
+    @@registrations = {}
+
+    alias_method :element_name, :name
+
+    class_inheritable_accessor  :xmlns,
+                                :name
+
+    ##
+    # Automatically sets the namespace registered by the subclass
+    def self.new(name = nil, content = nil)
+      name ||= self.name
+
+      args = []
+      args << name.to_s if name
+      args << content if content
+
+      elem = super *args
+      elem.xmlns = xmlns
+      elem
+    end
+
+    ##
+    # Lets a subclass register itself
+    #
+    # This registers a namespace that is used when looking
+    # up the class name of the object to instantiate when a new
+    # stanza is received
+    def self.register(name, xmlns = nil)
+      self.name = name.to_s
+      self.xmlns = xmlns
+      @@registrations[[name, xmlns]] = self
+    end
+
+    ##
+    # Find the class to use given the name and namespace of a stanza
+    def self.class_from_registration(name, xmlns)
+      name = name.to_s
+      @@registrations[[name, xmlns]] || @@registrations[[name, nil]]
+    end
+
+    ##
+    # Looks up the class to use then instantiates an object
+    # of that class and imports all the <tt>node</tt>'s attributes
+    # and children into it.
+    def self.import(node)
+      klass = class_from_registration(node.element_name, node.xmlns)
+      if klass && klass != self
+        klass.import(node)
+      else
+        new(node.element_name).inherit(node)
+      end
+    end
+
+    ##
+    # Quickway of turning itself into a proper object
+    def to_stanza
+      self.class.import self
+    end
+
+    def xmlns=(ns)
+      attributes.remove :xmlns
+      self['xmlns'] = ns if ns
+    end
+
+    def xmlns
+      self['xmlns']
+    end
+
+    ##
+    # Remove a child with the name and (optionally) namespace given
+    def remove_child(name, ns = nil)
+      name = name.to_s
+      self.each { |n| n.remove! if n.element_name == name && (!ns || n.xmlns == ns) }
+    end
+
+    ##
+    # Remove all children with a given name
+    def remove_children(name)
+      name = name.to_s
+      self.find(name).each { |n| n.remove! }
+    end
+
+    ##
+    # Pull the content from a child
+    def content_from(name)
+      name = name.to_s
+      (child = self.detect { |n| n.element_name == name }) ? child.content : nil
+    end
+
+    ##
+    # Create a copy
+    def copy(deep = true)
+      self.class.new(self.element_name).inherit(self)
+    end
+
+    ##
+    # Inherit all of <tt>stanza</tt>'s attributes and children
+    def inherit(stanza)
+      inherit_attrs stanza.attributes
+      stanza.children.each { |c| self << c.copy(true) }
+      self
+    end
+
+    ##
+    # Inherit only <tt>stanza</tt>'s attributes
+    def inherit_attrs(attrs)
+      attrs.each  { |a| self[a.name] = a.value }
+      self
+    end
+
+    ##
+    # Turn itself into a string and remove all whitespace between nodes
+    def to_s
+      # TODO: Fix this for HTML nodes (and any other that might require whitespace)
+      super.gsub(">\n<", '><')
+    end
+
+    ##
+    # Override #find to work when a node isn't attached to a document
+    def find(what, nslist = nil)
+      (self.doc ? super(what, nslist) : select { |i| i.element_name == what})
+    end
+  end #XMPPNode
+
+end

data/lib/blather/extensions.rb

@@ -0,0 +1,4 @@
+%w[
+  last_activity
+  version
+].each { |r| require "extensions/#{r}" }

data/lib/blather/extensions/last_activity.rb

@@ -0,0 +1,55 @@
+module Blather
+  module Extensions #:nodoc:
+
+    module LastActivity #:nodoc:
+      def self.included(base)
+        base.class_eval do
+          @@last_activity = Time.now
+
+          alias_method :send_data_without_activity, :send_data
+          def send_data(data)
+            @@last_activity = Time.now
+            send_data_without_activity data
+          end
+        end
+      end
+
+      def last_activity
+        (Time.now - @@last_activity).to_i
+      end
+
+      def receive_last_activity(stanza)
+        send_data stanza.reply!(last_activity) if stanza.type == 'get'
+      end
+    end #LastActivity
+
+    class LastActivityStanza < Query #:nodoc:
+      register :last_activity, nil, 'jabber:iq:last'
+
+      def self.new(type = :get, seconds = nil)
+        elem = super type
+        elem.seconds = seconds
+        elem
+      end
+
+      def seconds=(seconds)
+        query.attributes.remove :seconds
+        query['seconds'] = seconds.to_i.to_s if seconds
+      end
+
+      def seconds
+        (query['seconds'] || 0).to_i
+      end
+
+      def reply(seconds)
+        elem = super()
+        elem.last_activity = seconds
+      end
+
+      def reply!(seconds)
+        self.last_activity = seconds
+        super()
+      end
+    end #LastActivityStanza
+  end
+end

data/lib/blather/extensions/version.rb

@@ -0,0 +1,85 @@
+module Blather
+  module Extensions #:nodoc:
+
+    module Version #:nodoc:
+      def self.included(base)
+        base.class_eval do
+          @@version = {}
+
+          def self.version(name, ver, os = nil)
+            @@version = {:name => name, :version => ver, :os => os}
+          end
+
+          add_callback(:iq, 100) do |c, s|
+            if s.detect { |n| n['xmlns'] == 'jabber:iq:version' }
+              ver = VersionStanza.new('result', c.version)
+              ver.id = s.id
+              ver.from = c.jid
+              ver.to = s.from
+              c.send_data ver
+            end
+          end
+        end
+      end
+
+      def version
+        @@version
+      end
+    end #Version
+
+    class VersionStanza < Iq #:nodoc:
+      def self.new(type = 'result', ver = {})
+        elem = super(type)
+
+        query = XML::Node.new('query')
+        query.xmlns = 'jabber:iq:version'
+        elem << query
+
+        elem.name = ver[:name] if ver[:name]
+        elem.version = ver[:version] if ver[:version]
+        elem.os = ver[:os] if ver[:os]
+
+        elem
+      end
+
+      def query
+        @query ||= self.detect { |n| n.name == 'query' }
+      end
+
+      def name=(name)
+        query.each { |n| n.remove! or break if n.name == 'name' }
+        query << XML::Node.new('name', name)
+      end
+
+      def name
+        if name = query.detect { |n| n.name == 'name' }
+          name.content
+        end
+      end
+
+      def version=(version)
+        query.each { |n| n.remove! or break if n.name == 'version' }
+        query << XML::Node.new('version', version)
+      end
+
+      def version
+        if version = query.detect { |n| n.version == 'version' }
+          version.content
+        end
+      end
+
+      def os=(os)
+        query.each { |n| n.remove! or break if n.name == 'os' }
+        query << XML::Node.new('os', os)
+      end
+
+      def os
+        if os = query.detect { |n| n.os == 'os' }
+          os.content
+        end
+      end
+    end #VersionStanza
+  end
+end
+
+Blather::Client.__send__ :include, Blather::Extensions::Version

data/spec/blather/core/jid_spec.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::JID' do
+  it 'does nothing if creaded from JID' do
+    jid = JID.new 'n@d/r'
+    JID.new(jid).object_id.must_equal jid.object_id
+  end
+
+  it 'creates a new JID from (n,d,r)' do
+    jid = JID.new('n', 'd', 'r')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+    jid.resource.must_equal 'r'
+  end
+
+  it 'creates a new JID from (n,d)' do
+    jid = JID.new('n', 'd')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+  end
+
+  it 'creates a new JID from (n@d)' do
+    jid = JID.new('n@d')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+  end
+
+  it 'creates a new JID from (n@d/r)' do
+    jid = JID.new('n@d/r')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+    jid.resource.must_equal 'r'
+  end
+
+  it 'requires at least a node' do
+    proc { JID.new }.must_raise ArgumentError
+  end
+
+  it 'ensures length of node is no more than 1023 characters' do
+    proc { JID.new('n'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'ensures length of domain is no more than 1023 characters' do
+    proc { JID.new('n', 'd'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'ensures length of resource is no more than 1023 characters' do
+    proc { JID.new('n', 'd', 'r'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'compares JIDs' do
+    (JID.new('a@b/c') <=> JID.new('d@e/f')).must_equal -1
+    (JID.new('a@b/c') <=> JID.new('a@b/c')).must_equal 0
+    (JID.new('d@e/f') <=> JID.new('a@b/c')).must_equal 1
+  end
+
+  it 'checks for equality' do
+    (JID.new('n@d/r') == JID.new('n@d/r')).must_equal true
+  end
+
+  it 'will strip' do
+    jid = JID.new('n@d/r')
+    jid.stripped.must_equal JID.new('n@d')
+    jid.must_equal JID.new('n@d/r')
+  end
+
+  it 'will strip itself' do
+    jid = JID.new('n@d/r')
+    jid.strip!
+    jid.must_equal JID.new('n@d')
+  end
+
+  it 'has a string representation' do
+    JID.new('n@d/r').to_s.must_equal 'n@d/r'
+    JID.new('n', 'd', 'r').to_s.must_equal 'n@d/r'
+    JID.new('n', 'd').to_s.must_equal 'n@d'
+  end
+end

data/spec/blather/core/roster_item_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::RosterItem' do
+  it 'initializes with JID' do
+    jid = JID.new(jid)
+    i = RosterItem.new jid
+    i.jid.must_equal jid
+  end
+
+  it 'initializes with an Iq::RosterItem' do
+    jid = 'n@d/r'
+    i = RosterItem.new Stanza::Iq::Roster::RosterItem.new(jid)
+    i.jid.must_equal JID.new(jid).stripped
+  end
+
+  it 'has a JID setter that strips the JID' do
+    jid = JID.new('n@d/r')
+    i = RosterItem.new nil
+    i.jid = jid
+    i.jid.must_equal jid.stripped
+  end
+
+  it 'has a subscription setter that forces a symbol' do
+    i = RosterItem.new nil
+    i.subscription = 'remove'
+    i.subscription.must_equal :remove
+  end
+
+  it 'forces the type of subscription' do
+    proc { RosterItem.new(nil).subscription = 'foo' }.must_raise Blather::ArgumentError
+  end
+
+  it 'returns :none if the subscription field is blank' do
+    RosterItem.new(nil).subscription.must_equal :none
+  end
+
+  it 'ensure #ask is a symbol' do
+    i = RosterItem.new(nil)
+    i.ask = 'subscribe'
+    i.ask.must_equal :subscribe
+  end
+
+  it 'forces #ask to be :subscribe or nothing at all' do
+    proc { RosterItem.new(nil).ask = 'foo' }.must_raise Blather::ArgumentError
+  end
+
+  it 'generates a stanza with #to_stanza' do
+    jid = JID.new('n@d/r')
+    i = RosterItem.new jid
+    s = i.to_stanza
+    s.must_be_kind_of Stanza::Iq::Roster
+    s.items.first.jid.must_equal jid.stripped
+  end
+
+  it 'returns status based on priority' do
+    setup_item_with_presences
+    @i.status.must_equal @p2
+  end
+
+  it 'returns status based on resource' do
+    setup_item_with_presences
+    @i.status('a').must_equal @p
+  end
+
+  def setup_item_with_presences
+    @jid = JID.new('n@d/r')
+    @i = RosterItem.new @jid
+
+    @p = Stanza::Presence::Status.new(:away)
+    @p.from = 'n@d/a'
+    @p.priority = 0
+
+    @p2 = Stanza::Presence::Status.new(:dnd)
+    @p2.from = 'n@d/b'
+    @p2.priority = -1
+
+    @i.status = @p
+    @i.status = @p2
+  end
+end

data/spec/blather/core/roster_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::Roster' do
+  before do
+    @stream = mock()
+    @stream.stubs(:send_data)
+
+    @stanza = mock()
+    items = []; 4.times { |n| items << JID.new("n@d/#{n}r") }
+    @stanza.stubs(:items).returns(items)
+
+    @roster = Roster.new(@stream, @stanza)
+  end
+
+  it 'initializes with items' do
+    @roster.items.map { |_,i| i.jid.to_s }.must_equal(@stanza.items.map { |i| i.stripped.to_s }.uniq)
+  end
+
+  it 'processes @stanzas with remove requests' do
+    s = @roster['n@d/0r']
+    s.subscription = :remove
+    proc { @roster.process(s.to_stanza) }.must_change('@roster.items', :length, :by => -1)
+  end
+
+  it 'processes @stanzas with add requests' do
+    s = Stanza::Iq::Roster::RosterItem.new('a@b/c').to_stanza
+    proc { @roster.process(s) }.must_change('@roster.items', :length, :by => 1)
+  end
+
+  it 'allows a jid to be pushed' do
+    jid = 'a@b/c'
+    proc { @roster.push(jid) }.must_change('@roster.items', :length, :by => 1)
+    @roster[jid].wont_be_nil
+  end
+
+  it 'allows an item to be pushed' do
+    jid = 'a@b/c'
+    item = RosterItem.new(JID.new(jid))
+    proc { @roster.push(item) }.must_change('@roster.items', :length, :by => 1)
+    @roster[jid].wont_be_nil
+  end
+
+  it 'sends a @roster addition over the wire' do
+    stream = mock()
+    stream.expects(:send_data)
+    roster = Roster.new stream, @stanza
+    roster.push('a@b/c')
+  end
+
+  it 'removes a JID' do
+    proc { @roster.delete 'n@d' }.must_change('@roster.items', :length, :by => -1)
+  end
+
+  it 'sends a @roster removal over the wire' do
+    stream = mock(:send_data => nil)
+    roster = Roster.new stream, @stanza
+    roster.delete('a@b/c')
+  end
+
+  it 'returns an item through []' do
+    item = @roster['n@d']
+    item.must_be_kind_of RosterItem
+    item.jid.must_equal JID.new('n@d')
+  end
+
+  it 'responds to #each' do
+    @roster.must_respond_to :each
+  end
+
+  it 'cycles through the items using #each' do
+    @roster.map { |i| i }.sort.must_equal(@roster.items.sort)
+  end
+
+  it 'returns a duplicate of items through #items' do
+    items = @roster.items
+    items.delete 'n@d'
+    items.wont_equal @roster.items
+  end
+end