blather 0.1

data/lib/blather/core/errors.rb

@@ -0,0 +1,24 @@
+module Blather
+  # Main error class
+  class BlatherError < StandardError; end
+
+    # Stream errors
+    class StreamError < BlatherError
+      attr_accessor :type, :text
+
+      def initialize(node)
+        @type = node.detect { |n| n.name != 'text' && n['xmlns'] == 'urn:ietf:params:xml:ns:xmpp-streams' }
+        @text = node.detect { |n| n.name == 'text' }
+
+        @extra = node.detect { |n| n['xmlns'] != 'urn:ietf:params:xml:ns:xmpp-streams' }
+      end
+
+      def to_s
+        "Stream Error (#{type.name}) #{"[#{@extra.name}]" if @extra}: #{text.content if text}"
+      end
+    end
+
+    # Stanza errors
+    class StanzaError < BlatherError; end
+      class ArgumentError < StanzaError; end
+end

data/lib/blather/core/jid.rb

@@ -0,0 +1,101 @@
+module Blather
+
+  ##
+  # This is a simple modification of the JID class from XMPP4R
+  class JID
+    include Comparable
+
+    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/
+
+    begin
+      require 'idn'
+      USE_STRINGPREP = true
+    rescue LoadError
+      USE_STRINGPREP = false
+    end
+
+    # Get the JID's node
+    attr_reader :node
+
+    # Get the JID's domain
+    attr_reader :domain
+
+    # Get the JID's resource
+    attr_reader :resource
+
+    def self.new(node, domain = nil, resource = nil)
+      node.is_a?(JID) ? node : super
+    end
+
+    ##
+    # Create a new JID. If called as new('a@b/c'), parse the string and
+    # split (node, domain, resource)
+    def initialize(node, domain = nil, resource = nil)
+      @resource = resource
+      @domain = domain
+      @node = node
+
+      if @domain.nil? && @resource.nil?
+        @node, @domain, @resource = @node.to_s.scan(PATTERN).first
+      end
+
+      if USE_STRINGPREP
+        @node = IDN::Stringprep.nodeprep(@node)             if @node
+        @domain = IDN::Stringprep.nameprep(@domain)         if @domain
+        @resource = IDN::Stringprep.resourceprep(@resource) if @resource
+      else
+        @node.downcase!   if @node
+        @domain.downcase! if @domain
+      end
+
+      raise ArgumentError, 'Node too long'      if (@node || '').length > 1023
+      raise ArgumentError, 'Domain too long'    if (@domain || '').length > 1023
+      raise ArgumentError, 'Resource too long'  if (@resource || '').length > 1023
+    end
+
+    ##
+    # Returns a string representation of the JID
+    # * ""
+    # * "domain"
+    # * "node@domain"
+    # * "domain/resource"
+    # * "node@domain/resource"
+    def to_s
+      s = @domain
+      s = "#{@node}@#{s}" if @node
+      s = "#{s}/#{@resource}" if @resource
+      s
+    end
+
+    ##
+    # Returns a new JID with resource removed.
+    # return:: [JID]
+    def stripped
+      self.class.new @node, @domain
+    end
+
+    ##
+    # Removes the resource (sets it to nil)
+    # return:: [JID] self
+    def strip!
+      @resource = nil
+      self
+    end
+
+    ##
+    # Compare two JIDs,
+    # helpful for sorting etc.
+    #
+    # String representations are compared, see JID#to_s
+    def <=>(o)
+      to_s <=> o.to_s
+    end
+
+    ##
+    # Test if JID is stripped
+    def stripped?
+      @resource.nil?
+    end
+  end
+
+end

data/lib/blather/core/roster.rb

@@ -0,0 +1,84 @@
+module Blather
+
+  ##
+  # Local Roster 
+  # Takes care of adding/removing JIDs through the stream
+  class Roster
+    include Enumerable
+
+    def initialize(stream, stanza = nil)
+      @stream = stream
+      @items = {}
+      stanza.items.each { |i| push i, false } if stanza
+    end
+
+    ##
+    # Process any incoming stanzas adn either add or remove the
+    # corresponding RosterItem
+    def process(stanza)
+      stanza.items.each do |i|
+        case i.subscription
+        when :remove then @items.delete(key(i.jid))
+        else @items[key(i.jid)] = RosterItem.new(i)
+        end
+      end
+    end
+
+    ##
+    # Pushes a JID into the roster
+    # then returns self to allow for chaining
+    def <<(elem)
+      push elem
+      self
+    end
+
+    ##
+    # Push a JID into the roster
+    # Will send the new item to the server
+    # unless overridden by calling #push(elem, false)
+    def push(elem, send = true)
+      jid = elem.respond_to?(:jid) ? elem.jid : JID.new(elem)
+      @items[key(jid)] = node = RosterItem.new(elem)
+
+      @stream.send_data(node.to_stanza(:set)) if send
+    end
+    alias_method :add, :push
+
+    ##
+    # Remove a JID from the roster
+    # Sends a remove query stanza to the server
+    def delete(jid)
+      @items.delete key(jid)
+      @stream.send_data Stanza::Iq::Roster.new(:set, Stanza::Iq::Roster::RosterItem.new(jid, nil, :remove))
+    end
+    alias_method :remove, :delete
+
+    ##
+    # Get a RosterItem by JID
+    def [](jid)
+      items[key(jid)]
+    end
+
+    ##
+    # Iterate over all RosterItems
+    def each(&block)
+      items.each &block
+    end
+
+    ##
+    # Returns a duplicate of all RosterItems
+    def items
+      @items.dup
+    end
+
+  private
+    def self.key(jid)
+      JID.new(jid).stripped.to_s
+    end
+
+    def key(jid)
+      self.class.key(jid)
+    end
+  end #Roster
+
+end

data/lib/blather/core/roster_item.rb

@@ -0,0 +1,92 @@
+module Blather
+
+  ##
+  # RosterItems hold internal representations of the user's roster
+  # including each JID's status.
+  class RosterItem
+    VALID_SUBSCRIPTION_TYPES = [:both, :from, :none, :remove, :to]
+
+    attr_reader :jid,
+                :ask,
+                :statuses
+
+    attr_accessor :name,
+                  :groups
+
+    ##
+    # item:: can be a JID, String (a@b) or a Stanza
+    def initialize(item)
+      @statuses = []
+
+      case item
+      when JID
+        self.jid = item.stripped
+      when String
+        self.jid = JID.new(item).stripped
+      when XMPPNode
+        self.jid          = JID.new(item['jid']).stripped
+        self.name         = item['name']
+        self.subscription = item['subscription']
+        self.ask          = item['ask']
+        item.groups.each { |g| self.groups << g }
+      end
+    end
+
+    ##
+    # Set the jid
+    def jid=(jid)
+      @jid = JID.new(jid).stripped
+    end
+
+    ##
+    # Set the subscription
+    # Ensures it is one of VALID_SUBSCRIPTION_TYPES
+    def subscription=(sub)
+      raise ArgumentError, "Invalid Type (#{sub}), use: #{VALID_SUBSCRIPTION_TYPES*' '}" if
+        sub && !VALID_SUBSCRIPTION_TYPES.include?(sub = sub.to_sym)
+      @subscription = sub ? sub : :none
+    end
+
+    ##
+    # Get the current subscription
+    # returns:: :both, :from, :none, :remove, :to or :none
+    def subscription
+      @subscription || :none
+    end
+
+    ##
+    # Set the ask value
+    # ask:: must only be nil or :subscribe
+    def ask=(ask)
+      raise ArgumentError, "Invalid Type (#{ask}), can only be :subscribe" if ask && (ask = ask.to_sym) != :subscribe
+      @ask = ask ? ask : nil
+    end
+
+    ##
+    # Set the status then sorts them according to priority
+    # presence:: Status
+    def status=(presence)
+      @statuses.delete_if { |s| s.from == presence.from }
+      @statuses << presence
+      @statuses.sort!
+    end
+
+    ##
+    # Return the status with the highest priority
+    # if resource is set find the status of that specific resource 
+    def status(resource = nil)
+      top = resource ? @statuses.detect { |s| s.from.resource == resource } : @statuses.first
+    end
+
+    ##
+    # Translate the RosterItem into a proper stanza that can be sent over the stream
+    def to_stanza(type = nil)
+      r = Stanza::Iq::Roster.new type
+      n = Stanza::Iq::Roster::RosterItem.new jid, name, subscription, ask
+      r.query << n
+      n.groups = groups
+      r
+    end
+  end #RosterItem
+
+end

data/lib/blather/core/stanza.rb

@@ -0,0 +1,116 @@
+module Blather
+  ##
+  # Base XMPP Stanza
+  class Stanza < XMPPNode
+    @@registered_callbacks = []
+
+    def self.registered_callbacks
+      @@registered_callbacks
+    end
+
+    class_inheritable_array :callback_heirarchy
+
+    ##
+    # Registers a callback onto the callback heirarchy stack
+    #
+    # Thanks to help from ActiveSupport every class
+    # that inherits Stanza can register a callback for itself
+    # which is added to a list and iterated over when looking for
+    # a callback to use
+    def self.register(callback_type, name = nil, xmlns = nil)
+      @@registered_callbacks << callback_type
+
+      self.callback_heirarchy ||= []
+      self.callback_heirarchy.unshift callback_type
+
+      name = name || self.name || callback_type
+      super name, xmlns
+    end
+
+    ##
+    # Helper method that creates a unique ID for stanzas
+    def self.next_id
+      @@last_id ||= 0
+      @@last_id += 1
+      'blather%04x' % @@last_id
+    end
+
+    ##
+    # Creates a new stanza with the same name as the node
+    # then inherits all the node's attributes and properties
+    def self.import(node)
+      self.new(node.element_name).inherit(node)
+    end
+
+    ##
+    # Creates a new Stanza with the name given
+    # then attaches an ID and document (to enable searching)
+    def self.new(elem_name = nil)
+      elem = super
+      elem.id = next_id
+      XML::Document.new.root = elem
+      elem
+    end
+
+    def error?
+      self.type == :error
+    end
+
+    ##
+    # Copies itself then swaps from and to
+    # then returns the new stanza
+    def reply
+      self.copy(true).reply!
+    end
+
+    ##
+    # Swaps from and to
+    def reply!
+      self.to, self.from = self.from, self.to
+      self
+    end
+
+    def id=(id)
+      attributes.remove :id
+      self['id'] = id if id
+    end
+
+    def id
+      self['id']
+    end
+
+    def to=(to)
+      attributes.remove :to
+      self['to'] = to.to_s if to
+    end
+
+    ##
+    # returns:: JID created from the "to" value of the stanza
+    def to
+      JID.new(self['to']) if self['to']
+    end
+
+    def from=(from)
+      attributes.remove :from
+      self['from'] = from.to_s if from
+    end
+
+    ##
+    # returns:: JID created from the "from" value of the stanza
+    def from
+      JID.new(self['from']) if self['from']
+    end
+
+    def type=(type)
+      attributes.remove :type
+      self['type'] = type.to_s
+    end
+
+    ##
+    # returns:: a symbol of the type
+    def type
+      self['type'].to_sym if self['type']
+    end
+
+  end
+end

data/lib/blather/core/stanza/iq.rb

@@ -0,0 +1,27 @@
+module Blather
+class Stanza
+
+  ##
+  # Base Iq stanza
+  class Iq < Stanza
+    register :iq
+
+    def self.import(node)
+      raise "Import missmatch #{[node.element_name, self.name].inspect}" if node.element_name != self.name.to_s
+      klass = nil
+      node.each { |e| break if klass = class_from_registration(e.element_name, e.xmlns) }
+      (klass || self).new(node['type']).inherit(node)
+    end
+
+    def self.new(type, to = nil, id = nil)
+      elem = super :iq
+      elem.xmlns = nil
+      elem.type = type
+      elem.to = to
+      elem.id = id if id
+      elem
+    end
+  end
+
+end #Stanza
+end