tp-blather 0.8.2

data/lib/blather/stanza/muc/muc_user_base.rb

@@ -0,0 +1,54 @@
+module Blather
+class Stanza
+class MUC
+
+  module MUCUserBase
+    MUC_USER_NAMESPACE = "http://jabber.org/protocol/muc#user"
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def new(*args)
+        super.tap { |e| e.muc_user }
+      end
+    end
+
+    def inherit(node)
+      muc_user.remove
+      super
+      self
+    end
+
+    def password
+      find_password_node && password_node.content
+    end
+
+    def password=(var)
+      password_node.content = var
+    end
+
+    def muc_user
+      unless muc_user = find_first('ns:x', :ns => MUC_USER_NAMESPACE)
+        self << (muc_user = XMPPNode.new('x', self.document))
+        muc_user.namespace = self.class.registered_ns
+      end
+      muc_user
+    end
+
+    def password_node
+      unless pw = find_password_node
+        muc_user << (pw = XMPPNode.new('password', self.document))
+      end
+      pw
+    end
+
+    def find_password_node
+      muc_user.find_first 'ns:password', :ns => MUC_USER_NAMESPACE
+    end
+  end # MUCUserBase
+
+end # MUC
+end # Stanza
+end # Blather

data/lib/blather/stanza/presence.rb

@@ -0,0 +1,172 @@
+module Blather
+class Stanza
+
+  # # Presence Stanza
+  #
+  # [RFC 3921 Section 2.2 - Presence Syntax](http://xmpp.org/rfcs/rfc3921.html#stanzas-presence)
+  #
+  # Within Blather most of the interaction with Presence stanzas will be
+  # through one of its child classes: Status or Subscription.
+  #
+  # Presence stanzas are used to express an entity's current network
+  # availability (offline or online, along with various sub-states of the
+  # latter and optional user-defined descriptive text), and to notify other
+  # entities of that availability. Presence stanzas are also used to negotiate
+  # and manage subscriptions to the presence of other entities.
+  #
+  # ## "Type" Attribute
+  #
+  # The `type` attribute of a presence stanza is optional. A presence stanza
+  # that does not possess a `type` attribute is used to signal to the server
+  # that the sender is online and available for communication. If included,
+  # the `type` attribute specifies a lack of availability, a request to manage
+  # a subscription to another entity's presence, a request for another
+  # entity's current presence, or an error related to a previously-sent
+  # presence stanza. If included, the `type` attribute must have one of the
+  # following values:
+  #
+  # * `:unavailable` -- Signals that the entity is no longer available for
+  #   communication
+  #
+  # * `:subscribe` -- The sender wishes to subscribe to the recipient's
+  #   presence.
+  #
+  # * `:subscribed` -- The sender has allowed the recipient to receive their
+  #   presence.
+  #
+  # * `:unsubscribe` -- The sender is unsubscribing from another entity's
+  #   presence.
+  #
+  # * `:unsubscribed` -- The subscription request has been denied or a
+  #   previously-granted subscription has been cancelled.
+  #
+  # * `:probe` -- A request for an entity's current presence; should be
+  #   generated only by a server on behalf of a user.
+  #
+  # * `:error` -- An error has occurred regarding processing or delivery of a
+  #   previously-sent presence stanza.
+  #
+  # Blather provides a helper for each possible type:
+  #
+  #     Presence#unavailabe?
+  #     Presence#unavailable?
+  #     Presence#subscribe?
+  #     Presence#subscribed?
+  #     Presence#unsubscribe?
+  #     Presence#unsubscribed?
+  #     Presence#probe?
+  #     Presence#error?
+  #
+  # Blather treats the `type` attribute like a normal ruby object attribute
+  # providing a getter and setter. The default `type` is nil.
+  #
+  #     presence = Presence.new
+  #     presence.type                # => nil
+  #     presence.type = :unavailable
+  #     presence.unavailable?        # => true
+  #     presence.error?              # => false
+  #
+  #     presence.type = :invalid   # => RuntimeError
+  #
+  # @handler :presence
+  class Presence < Stanza
+    # @private
+    VALID_TYPES = [ :unavailable,
+                    :subscribe,
+                    :subscribed,
+                    :unsubscribe,
+                    :unsubscribed,
+                    :probe,
+                    :error].freeze
+
+    register :presence
+
+    # Creates a class based on the presence type
+    # either a Status or Subscription object is created based
+    # on the type attribute.
+    # If neither is found it instantiates a Presence object
+    def self.import(node, *decorators) # :nodoc:
+      node.children.each do |e|
+        ns = e.namespace ? e.namespace.href : nil
+        klass = class_from_registration e.element_name, ns
+        decorators << klass if klass
+      end
+
+      case node['type']
+      when nil, 'unavailable'
+        decorators << Status
+      when /subscribe/
+        decorators << Subscription
+      end
+
+      super node, *decorators
+    end
+
+    # Ensure element_name is "presence" for all subclasses
+    def self.new(*args)
+      super :presence
+    end
+
+    # Check if the IQ is of type :unavailable
+    #
+    # @return [true, false]
+    def unavailable?
+      self.type == :unavailable
+    end
+
+    # Check if the IQ is of type :subscribe
+    #
+    # @return [true, false]
+    def subscribe?
+      self.type == :subscribe
+    end
+
+    # Check if the IQ is of type :subscribed
+    #
+    # @return [true, false]
+    def subscribed?
+      self.type == :subscribed
+    end
+
+    # Check if the IQ is of type :unsubscribe
+    #
+    # @return [true, false]
+    def unsubscribe?
+      self.type == :unsubscribe
+    end
+
+    # Check if the IQ is of type :unsubscribed
+    #
+    # @return [true, false]
+    def unsubscribed?
+      self.type == :unsubscribed
+    end
+
+    # Check if the IQ is of type :probe
+    #
+    # @return [true, false]
+    def probe?
+      self.type == :probe
+    end
+
+    # Check if the IQ is of type :error
+    #
+    # @return [true, false]
+    def error?
+      self.type == :error
+    end
+
+    # Ensures type is one of Blather::Stanza::Presence::VALID_TYPES
+    #
+    # @param [#to_sym] type the Presence type. Must be one of VALID_TYPES
+    def type=(type)
+      if type && !VALID_TYPES.include?(type.to_sym)
+        raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}"
+      end
+      super
+    end
+
+  end
+
+end #Stanza
+end

data/lib/blather/stanza/presence/c.rb

@@ -0,0 +1,100 @@
+module Blather
+class Stanza
+class Presence
+
+  # # Entity Capabilities Stanza
+  #
+  # [XEP-0115 - Entity Capabilities](http://http://xmpp.org/extensions/xep-0115.html)
+  #
+  # Blather handles c nodes through this class. It provides a set of helper methods
+  # to quickly deal with capabilites presence stanzas.
+  #
+  # @handler :c
+  class C < Presence
+    register :c, :c, 'http://jabber.org/protocol/caps'
+
+    # @private
+    VALID_HASH_TYPES = %w[md2 md5 sha-1 sha-224 sha-256 sha-384 sha-512].freeze
+
+    def self.new(node = nil, ver = nil, hash = 'sha-1')
+      new_node = super()
+      new_node.c
+      new_node.hash = hash
+      new_node.node = node
+      new_node.ver = ver
+      parse new_node.to_xml
+    end
+
+    module InstanceMethods
+
+      # @private
+      def inherit(node)
+        c.remove
+        super
+        self
+      end
+
+      # Get the name of the node
+      #
+      # @return [String, nil]
+      def node
+        c[:node]
+      end
+
+      # Set the name of the node
+      #
+      # @param [String, nil] node the new node name
+      def node=(node)
+        c[:node] = node
+      end
+
+      # Get the name of the hash
+      #
+      # @return [Symbol, nil]
+      def hash
+        c[:hash] && c[:hash].to_sym
+      end
+
+      # Set the name of the hash
+      #
+      # @param [String, nil] hash the new hash name
+      def hash=(hash)
+        if hash && !VALID_HASH_TYPES.include?(hash.to_s)
+          raise ArgumentError, "Invalid Hash Type (#{hash}), use: #{VALID_HASH_TYPES*' '}"
+        end
+        c[:hash] = hash
+      end
+
+      # Get the ver
+      #
+      # @return [String, nil]
+      def ver
+        c[:ver]
+      end
+
+      # Set the ver
+      #
+      # @param [String, nil] ver the new ver
+      def ver=(ver)
+        c[:ver] = ver
+      end
+
+      # C node accessor
+      # If a c node exists it will be returned.
+      # Otherwise a new node will be created and returned
+      #
+      # @return [Blather::XMPPNode]
+      def c
+        unless c = find_first('ns:c', :ns => C.registered_ns)
+          self << (c = XMPPNode.new('c', self.document))
+          c.namespace = self.class.registered_ns
+        end
+        c
+      end
+    end
+
+    include InstanceMethods
+  end # C
+end #Presence
+end #Stanza
+end

data/lib/blather/stanza/presence/muc.rb

@@ -0,0 +1,35 @@
+module Blather
+class Stanza
+class Presence
+
+  class MUC < Status
+    register :muc_join, :x, "http://jabber.org/protocol/muc"
+
+    def self.new(*args)
+      new_node = super
+      new_node.muc
+      new_node
+    end
+
+    module InstanceMethods
+      def inherit(node)
+        muc.remove
+        super
+        self
+      end
+
+      def muc
+        unless muc = find_first('ns:x', :ns => MUC.registered_ns)
+          self << (muc = XMPPNode.new('x', self.document))
+          muc.namespace = self.class.registered_ns
+        end
+        muc
+      end
+    end
+
+    include InstanceMethods
+  end # MUC
+
+end # Presence
+end # Stanza
+end # Blather

data/lib/blather/stanza/presence/muc_user.rb

@@ -0,0 +1,147 @@
+require 'blather/stanza/muc/muc_user_base'
+
+module Blather
+class Stanza
+class Presence
+
+  class MUCUser < Presence
+    include Blather::Stanza::MUC::MUCUserBase
+
+    def self.decorator_modules
+      super + [Blather::Stanza::MUC::MUCUserBase]
+    end
+
+    register :muc_user_presence, :x, MUC_USER_NAMESPACE
+
+    module InstanceMethods
+
+      def affiliation
+        item.affiliation
+      end
+
+      def affiliation=(val)
+        item.affiliation = val
+      end
+
+      def role
+        item.role
+      end
+
+      def role=(val)
+        item.role = val
+      end
+
+      def jid
+        item.jid
+      end
+
+      def jid=(val)
+        item.jid = val
+      end
+
+      def status_codes
+        status.map &:code
+      end
+
+      def status_codes=(val)
+        muc_user.remove_children :status
+        val.each do |code|
+          muc_user << Status.new(code)
+        end
+      end
+
+      def item
+        if item = muc_user.find_first('ns:item', :ns => MUCUser.registered_ns)
+          Item.new item
+        else
+          muc_user << (item = Item.new nil, nil, nil, self.document)
+          item
+        end
+      end
+
+      def status
+        muc_user.find('ns:status', :ns => MUCUser.registered_ns).map do |status|
+          Status.new status
+        end
+      end
+    end
+
+    include InstanceMethods
+
+    class Item < XMPPNode
+      def self.new(affiliation = nil, role = nil, jid = nil, document = nil)
+        new_node = super :item, document
+
+        case affiliation
+        when self
+          affiliation.document ||= document
+          return affiliation
+        when Nokogiri::XML::Node
+          new_node.inherit affiliation
+        when Hash
+          new_node.affiliation = affiliation[:affiliation]
+          new_node.role = affiliation[:role]
+          new_node.jid = affiliation[:jid]
+        else
+          new_node.affiliation = affiliation
+          new_node.role = role
+          new_node.jid = jid
+        end
+        new_node
+      end
+
+      def affiliation
+        read_attr :affiliation, :to_sym
+      end
+
+      def affiliation=(val)
+        write_attr :affiliation, val
+      end
+
+      def role
+        read_attr :role, :to_sym
+      end
+
+      def role=(val)
+        write_attr :role, val
+      end
+
+      def jid
+        read_attr :jid
+      end
+
+      def jid=(val)
+        write_attr :jid, val
+      end
+    end
+
+    class Status < XMPPNode
+      def self.new(code = nil)
+        new_node = super :status
+
+        case code
+        when self.class
+          return code
+        when Nokogiri::XML::Node
+          new_node.inherit code
+        when Hash
+          new_node.code = code[:code]
+        else
+          new_node.code = code
+        end
+        new_node
+      end
+
+      def code
+        read_attr :code, :to_i
+      end
+
+      def code=(val)
+        write_attr :code, val
+      end
+    end
+  end # MUC
+
+end # Presence
+end # Stanza
+end # Blather