tp-blather 0.8.2

data/lib/blather/roster.rb

@@ -0,0 +1,118 @@
+module Blather
+
+  # Local Roster
+  # Takes care of adding/removing JIDs through the stream
+  class Roster
+    include Enumerable
+
+    # Create a new roster
+    #
+    # @param [Blather::Stream] stream the stream the roster should use to
+    # update roster entries
+    # @param [Blather::Stanza::Roster] stanza a roster stanza used to preload
+    # the roster
+    # @return [Blather::Roster]
+    def initialize(stream, stanza = nil)
+      @stream = stream
+      @items = {}
+      stanza.items.each { |i| push i, false } if stanza
+    end
+
+    # Process any incoming stanzas and either adds or removes the
+    # corresponding RosterItem
+    #
+    # @param [Blather::Stanza::Roster] stanza a roster stanza
+    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
+    #
+    # @param [String, Blather::JID, #jid] elem a JID to add to the roster
+    # @return [self]
+    # @see #push
+    def <<(elem)
+      push elem
+      self
+    end
+
+    # Push a JID into the roster and update the server
+    #
+    # @param [String, Blather::JID, #jid] elem a jid to add to the roster
+    # @param [true, false] send send the update over the wire
+    # @see Blather::JID
+    def push(elem, send = true)
+      jid = elem.respond_to?(:jid) ? elem.jid : JID.new(elem)
+      @items[key(jid)] = node = RosterItem.new(elem)
+
+      @stream.write(node.to_stanza(:set)) if send
+    end
+    alias_method :add, :push
+
+    # Remove a JID from the roster and update the server
+    #
+    # @param [String, Blather::JID] jid the JID to remove from the roster
+    def delete(jid)
+      @items.delete key(jid)
+      item = Stanza::Iq::Roster::RosterItem.new(jid, nil, :remove)
+      @stream.write Stanza::Iq::Roster.new(:set, item)
+    end
+    alias_method :remove, :delete
+
+    # Get a RosterItem by JID
+    #
+    # @param [String, Blather::JID] jid the jid of the item to return
+    # @return [Blather::RosterItem, nil] the associated RosterItem
+    def [](jid)
+      items[key(jid)]
+    end
+
+    # Iterate over all RosterItems
+    #
+    # @yield [Blather::RosterItem] yields each RosterItem
+    def each(&block)
+      items.values.each &block
+    end
+
+    # Get a duplicate of all RosterItems
+    #
+    # @return [Array<Blather::RosterItem>] a duplicate of all RosterItems
+    def items
+      @items.dup
+    end
+
+    # Number of items in the roster
+    #
+    # @return [Integer] the number of items in the roster
+    def length
+      @items.length
+    end
+
+    # A hash of items keyed by group
+    #
+    # @return [Hash<group => Array<RosterItem>>]
+    def grouped
+      @items.values.sort.inject(Hash.new{|h,k|h[k]=[]}) do |hash, item|
+        item.groups.each { |group| hash[group] << item }
+        hash
+      end
+    end
+
+  private
+    # Creates a stripped jid
+    def self.key(jid)
+      JID.new(jid).stripped.to_s
+    end
+
+    # Instance method to wrap around the class method
+    def key(jid)
+      self.class.key(jid)
+    end
+  end  # Roster
+
+end  # Blather

data/lib/blather/roster_item.rb

@@ -0,0 +1,146 @@
+module Blather
+
+  # RosterItems hold internal representations of the user's roster
+  # including each JID's status.
+  class RosterItem
+    # @private
+    VALID_SUBSCRIPTION_TYPES = [:both, :from, :none, :remove, :to].freeze
+
+    attr_reader :jid,
+                :ask,
+                :statuses
+
+    attr_accessor :name,
+                  :groups
+
+    # @private
+    def self.new(item)
+      return item if item.is_a?(self)
+      super
+    end
+
+    # Create a new RosterItem
+    #
+    # @overload initialize(jid)
+    #   Create a new RosterItem based on a JID
+    #   @param [Blather::JID] jid the JID object
+    # @overload initialize(jid)
+    #   Create a new RosterItem based on a JID string
+    #   @param [String] jid a JID string
+    # @overload initialize(node)
+    #   Create a new RosterItem based on a stanza
+    #   @param [Blather::Stanza::Iq::Roster::RosterItem] node a RosterItem
+    #   stanza
+    # @return [Blather::RosterItem] the new RosterItem
+    def initialize(item)
+      @statuses = []
+      @groups = []
+
+      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| @groups << g }
+      end
+
+      @groups = [nil] if @groups.empty?
+    end
+
+    # Set the jid
+    #
+    # @param [String, Blather::JID] jid the new jid
+    # @see Blather::JID
+    def jid=(jid)
+      @jid = JID.new(jid).stripped
+    end
+
+    # Set the subscription
+    # Ensures it is one of VALID_SUBSCRIPTION_TYPES
+    #
+    # @param [#to_sym] sub the new subscription
+    def subscription=(sub)
+      if sub && !VALID_SUBSCRIPTION_TYPES.include?(sub = sub.to_sym)
+        raise ArgumentError, "Invalid Type (#{sub}), use: #{VALID_SUBSCRIPTION_TYPES*' '}"
+      end
+      @subscription = sub ? sub : :none
+    end
+
+    # Get the current subscription
+    #
+    # @return [:both, :from, :none, :remove, :to]
+    def subscription
+      @subscription || :none
+    end
+
+    # Set the ask value
+    #
+    # @param [nil, :subscribe] ask the new ask
+    def ask=(ask)
+      if ask && (ask = ask.to_sym) != :subscribe
+        raise ArgumentError, "Invalid Type (#{ask}), can only be :subscribe"
+      end
+      @ask = ask ? ask : nil
+    end
+
+    # Set the status then sorts them according to priority
+    #
+    # @param [Blather::Stanza::Status] the new status
+    def status=(presence)
+      @statuses.delete_if { |s| s.from == presence.from || s.state == :unavailable }
+      @statuses << presence
+      @statuses.sort!
+    end
+
+    # The status with the highest priority
+    #
+    # @param [String, nil] resource the resource to get the status of
+    def status(resource = nil)
+      top = if resource
+        @statuses.detect { |s| s.from.resource == resource }
+      else
+        @statuses.last
+      end
+    end
+
+    # Translate the RosterItem into a proper stanza that can be sent over the
+    # stream
+    #
+    # @return [Blather::Stanza::Iq::Roster]
+    def to_stanza(type = nil)
+      Stanza::Iq::Roster.new type, to_node
+    end
+
+    def to_node
+      Stanza::Iq::Roster::RosterItem.new jid, name, subscription, ask, groups
+    end
+
+    # Compare two RosterItems by their JID
+    #
+    # @param [Blather::JID] other the JID to compare against
+    # @return [Fixnum<-1, 0, 1>]
+    def <=>(other)
+      JID.new(self.jid) <=> JID.new(other.jid)
+    end
+
+    # Compare two RosterItem objects by name, type and category
+    # @param [RosterItem] o the Identity object to compare against
+    # @return [true, false]
+    def eql?(o, *fields)
+      o.is_a?(self.class) &&
+      o.jid == self.jid &&
+      o.groups == self.groups
+    end
+
+    # @private
+    def ==(o)
+      eql?(o)
+    end
+  end #RosterItem
+
+end

data/lib/blather/stanza.rb

@@ -0,0 +1,167 @@
+module Blather
+
+  # # Base XMPP Stanza
+  #
+  # All stanzas inherit this class. It provides a set of methods and helpers
+  # common to all XMPP Stanzas
+  #
+  # @handler :stanza
+  class Stanza < XMPPNode
+    # @private
+    @@last_id = 0
+    # @private
+    @@handler_list = []
+
+    class_attribute :handler_hierarchy
+    attr_writer :handler_hierarchy
+
+    # Registers a callback onto the callback stack
+    #
+    # @param [Symbol] handler the name of the handler
+    # @param [Symbol, String, nil] name the name of the first element in the
+    #        stanza. If nil the inherited name will be used. If that's nil the
+    #        handler name will be used.
+    # @param [String, nil] ns the namespace of the stanza
+    def self.register(handler, name = nil, ns = nil)
+      @@handler_list << handler
+      self.handler_hierarchy ||= [:stanza]
+      self.handler_hierarchy = [handler] + self.handler_hierarchy
+
+      name = name || self.registered_name || handler
+      super name, ns
+    end
+
+    def initialize(*args)
+      super
+      @handler_hierarchy = []
+    end
+
+    def handler_hierarchy
+      @handler_hierarchy + self.class.handler_hierarchy
+    end
+
+    # The handler stack for the current stanza class
+    #
+    # @return [Array<Symbol>]
+    def self.handler_list
+      @@handler_list
+    end
+
+    # Helper method that creates a unique ID for stanzas
+    #
+    # @return [String] a new unique ID
+    def self.next_id
+      @@last_id += 1
+      'blather%04x' % @@last_id
+    end
+
+    # Check if the stanza is an error stanza
+    #
+    # @return [true, false]
+    def error?
+      self.type == :error
+    end
+
+    # Creates a copy with to and from swapped
+    #
+    # @param [Hash] opts options to pass to reply!
+    # @option opts [Boolean] :remove_children Wether or not to remove child nodes when replying
+    #
+    # @return [Blather::Stanza]
+    def reply(opts = {})
+      self.dup.reply! opts
+    end
+
+    # Swaps from and to
+    #
+    # @param [Hash] opts Misc options
+    # @option opts [Boolean] :remove_children Wether or not to remove child nodes when replying
+    #
+    # @return [self]
+    def reply!(opts = {})
+      opts = {:remove_children => false}.merge opts
+      self.to, self.from = self.from, self.to
+      self.children.remove if opts[:remove_children]
+      self
+    end
+
+    # Get the stanza's ID
+    #
+    # @return [String, nil]
+    def id
+      read_attr :id
+    end
+
+    # Set the stanza's ID
+    #
+    # @param [#to_s] id the new stanza ID
+    def id=(id)
+      write_attr :id, id
+    end
+
+    # Get the stanza's to
+    #
+    # @return [Blather::JID, nil]
+    def to
+      JID.new(self[:to]) if self[:to]
+    end
+
+    # Set the stanza's to field
+    #
+    # @param [#to_s] to the new JID for the to field
+    def to=(to)
+      write_attr :to, to
+    end
+
+    # Get the stanza's from
+    #
+    # @return [Blather::JID, nil]
+    def from
+      JID.new(self[:from]) if self[:from]
+    end
+
+    # Set the stanza's from field
+    #
+    # @param [#to_s] from the new JID for the from field
+    def from=(from)
+      write_attr :from, from
+    end
+
+    # Get the stanza's type
+    #
+    # @return [Symbol, nil]
+    def type
+      read_attr :type, :to_sym
+    end
+
+    # Set the stanza's type
+    #
+    # @param [#to_s] type the new stanza type
+    def type=(type)
+      write_attr :type, type
+    end
+
+    # Create an error stanza from the current stanza
+    #
+    # @param [String] name the error name
+    # @param [<Blather::StanzaError::VALID_TYPES>] type the error type
+    # @param [String, nil] text the error text
+    # @param [Array<XML::Node>] extras an array of extra nodes to attach to
+    # the error
+    #
+    # @return [Blather::StanzaError]
+    def as_error(name, type, text = nil, extras = [])
+      StanzaError.new self, name, type, text, extras
+    end
+
+  protected
+    # @private
+    def reply_if_needed!
+      unless @reversed_endpoints
+        reply!
+        @reversed_endpoints = true
+      end
+      self
+    end
+  end
+end

data/lib/blather/stanza/disco.rb

@@ -0,0 +1,32 @@
+module Blather
+class Stanza
+
+  # # Disco Base class
+  #
+  # Use Blather::Stanza::DiscoInfo or Blather::Stanza::DiscoItems
+  class Disco < Iq::Query
+
+    # Get the name of the node
+    #
+    # @return [String] the node name
+    def node
+      query[:node]
+    end
+
+    # Set the name of the node
+    #
+    # @param [#to_s] node the new node name
+    def node=(node)
+      query[:node] = node
+    end
+
+    # Compare two Disco objects by name, type and category
+    # @param [Disco] o the Identity object to compare against
+    # @return [true, false]
+    def eql?(o, *fields)
+      super o, *(fields + [:node])
+    end
+  end
+
+end # Stanza
+end # Blather