gmcmillan-xmpp4r 0.5

data/lib/xmpp4r/roster/iq/roster.rb

@@ -0,0 +1,215 @@
+# =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 Roster
+    ##
+    # Class for handling roster updates
+    #
+    # You must do 'client.send(Iq.new_rosterget)' or else you will
+    # have nothing to put in receive_iq()
+    #
+    # You must require 'xmpp4r/rosterquery' to use this class
+    # as its functionality is not needed for a working XMPP implementation.
+    # This will make [IqQuery] convert all Queries with namespace 'jabber:iq:roster'
+    # to [IqQueryRoster]
+    #
+    # This <query/> contains multiple <item/> children. See RosterItem.
+    class IqQueryRoster < IqQuery
+      name_xmlns 'query', 'jabber:iq:roster'
+
+      ##
+      # Iterate through all items
+      # &block:: Yield for every [RosterItem]
+      def each(&block)
+        each_element { |item|
+          # XPath won't work here as it's missing a prefix...
+          yield(item) if item.kind_of?(RosterItem)
+        }
+      end
+
+      ##
+      # Get roster item by JID
+      # jid:: [JID] or [Nil]
+      # result:: [RosterItem]
+      def [](jid)
+        each { |item|
+          return(item) if item.jid == jid
+        }
+        nil
+      end
+
+      ##
+      # Get all items
+      # result:: [Array] of [RosterItem]
+      def to_a
+        a = []
+        each { |item|
+          a.push(item)
+        }
+        a
+      end
+
+      ##
+      # Update roster by <iq/> stanza
+      # (to be fed by an iq_callback)
+      # iq:: [Iq] Containing new roster
+      # filter:: [Boolean] If false import non-roster-like results too
+      def receive_iq(iq, filter=true)
+        if filter && (((iq.type != :set) && (iq.type != :result)) || (iq.queryns != 'jabber:iq:roster'))
+          return
+        end
+
+        import(iq.query)
+      end
+
+      ##
+      # Output for "p"
+      #
+      # JIDs of all contained [RosterItem] elements are joined with a comma
+      # result:: [String]
+      def inspect
+        jids = to_a.collect { |item| item.jid.inspect }
+        jids.join(', ')
+      end
+    end
+
+    ##
+    # Class containing the <item/> elements of the roster
+    #
+    # The 'name' attribute has been renamed to 'iname' here
+    # as 'name' is already used by REXML::Element for the
+    # element's name. It's still name='...' in XML.
+    class RosterItem < XMPPElement
+      name_xmlns 'item', 'jabber:iq:roster'
+
+      ##
+      # Construct a new roster item
+      # jid:: [JID] Jabber ID
+      # iname:: [String] Name in the roster
+      # subscription:: [Symbol] Type of subscription (see RosterItem#subscription=)
+      # ask:: [Symbol] or [Nil] Can be :subscribe
+      def initialize(jid=nil, iname=nil, subscription=nil, ask=nil)
+        super()
+        self.jid = jid
+        self.iname = iname
+        self.subscription = subscription
+        self.ask = ask
+      end
+
+      ##
+      # Get name of roster item
+      #
+      # names can be set by the roster's owner himself
+      # return:: [String]
+      def iname
+        attributes['name']
+      end
+
+      ##
+      # Set name of roster item
+      # val:: [String] Name for this item
+      def iname=(val)
+        attributes['name'] = val
+      end
+
+      ##
+      # Get JID of roster item
+      # Resource of the JID will _not_ be stripped
+      # return:: [JID]
+      def jid
+        (a = attributes['jid']) ? JID.new(a) : nil
+      end
+
+      ##
+      # Set JID of roster item
+      # val:: [JID] or nil
+      def jid=(val)
+        attributes['jid'] = val.nil? ? nil : val.to_s
+      end
+
+      ##
+      # Get subscription type of roster item
+      # result:: [Symbol] or [Nil] The following values are valid according to RFC3921:
+      # * :both
+      # * :from
+      # * :none
+      # * :remove
+      # * :to
+      def subscription
+        case attributes['subscription']
+          when 'both' then :both
+          when 'from' then :from
+          when 'none' then :none
+          when 'remove' then :remove
+          when 'to' then :to
+          else nil
+        end
+      end
+
+      ##
+      # Set subscription type of roster item
+      # val:: [Symbol] or [Nil] See subscription for possible Symbols
+      def subscription=(val)
+        case val
+          when :both then attributes['subscription'] = 'both'
+          when :from then attributes['subscription'] = 'from'
+          when :none then attributes['subscription'] = 'none'
+          when :remove then attributes['subscription'] = 'remove'
+          when :to then attributes['subscription'] = 'to'
+          else attributes['subscription'] = nil
+        end
+      end
+
+      ##
+      # Get if asking for subscription
+      # result:: [Symbol] nil or :subscribe
+      def ask
+        case attributes['ask']
+          when 'subscribe' then :subscribe
+          else nil
+        end
+      end
+
+      ##
+      # Set if asking for subscription
+      # val:: [Symbol] nil or :subscribe
+      def ask=(val)
+        case val
+          when :subscribe then attributes['ask'] = 'subscribe'
+          else attributes['ask'] = nil
+        end
+      end
+
+      ##
+      # Get groups the item belongs to
+      # result:: [Array] of [String] The groups
+      def groups
+        result = []
+        each_element('group') { |group|
+          result.push(group.text)
+        }
+        result.uniq
+      end
+
+      ##
+      # Set groups the item belongs to,
+      # deletes old groups first.
+      #
+      # See JEP 0083 for nested groups
+      # ary:: [Array] New groups, duplicate values will be removed
+      def groups=(ary)
+        # Delete old group elements
+        delete_elements('group')
+
+        # Add new group elements
+        ary.uniq.each { |group|
+          add_element('group').text = group
+        }
+      end
+    end
+  end #Module Roster
+end #Module Jabber

data/lib/xmpp4r/roster/x/roster.rb

@@ -0,0 +1,138 @@
+# =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/x'
+require 'xmpp4r/jid'
+
+module Jabber
+  module Roster
+  ##
+  # Implementation of JEP-0144
+  # for <tt><x xmlns='http://jabber.org/protocol/rosterx'/></tt>
+  # attached to <tt><message/></tt> stanzas
+  #
+  # Should be backwards compatible to JEP-0093,
+  # as only action attribute of roster items are missing there.
+  # Pay attention to the namespace which is <tt>jabber:x:roster</tt>
+  # for JEP-0093!
+    class XRoster < X
+      name_xmlns 'x', 'jabber:x:roster'
+    end #Class XRoster
+
+    class RosterX < XRoster
+      name_xmlns 'x', 'http://jabber.org/protocol/rosterx'
+    end
+
+    ##
+    # Class containing an <item/> element
+    #
+    # The 'name' attribute has been renamed to 'iname' here
+    # as 'name' is already used by REXML::Element for the
+    # element's name. It's still name='...' in XML.
+    #
+    # This is all a bit analoguous to Jabber::RosterItem, used by
+    # Jabber::IqQueryRoster. But this class lacks the subscription and
+    # ask attributes.
+    class XRosterItem < XMPPElement
+      name_xmlns 'item', 'jabber:x:roster'
+
+      ##
+      # Construct a new roster item
+      # jid:: [JID] Jabber ID
+      # iname:: [String] Name in the roster
+      def initialize(jid=nil, iname=nil)
+        super()
+        self.jid = jid
+        self.iname = iname
+      end
+
+      ##
+      # Get name of roster item
+      #
+      # names can be set by the roster's owner himself
+      # return:: [String]
+      def iname
+        attributes['name']
+      end
+
+      ##
+      # Set name of roster item
+      # val:: [String] Name for this item
+      def iname=(val)
+        attributes['name'] = val
+      end
+
+      ##
+      # Get JID of roster item
+      # Resource of the JID will _not_ be stripped
+      # return:: [JID]
+      def jid
+        JID.new(attributes['jid'])
+      end
+
+      ##
+      # Set JID of roster item
+      # val:: [JID] or nil
+      def jid=(val)
+        attributes['jid'] = val.nil? ? nil : val.to_s
+      end
+
+      ##
+      # Get action for this roster item
+      # * :add
+      # * :modify
+      # * :delete
+      # result:: [Symbol] (defaults to :add according to JEP-0144)
+      def action
+        case attributes['action']
+          when 'modify' then :modify
+          when 'delete' then :delete
+          else :add
+        end
+      end
+
+      ##
+      # Set action for this roster item
+      # (see action)
+      def action=(a)
+        case a
+          when :modify then attributes['action'] = 'modify'
+          when :delete then attributes['action'] = 'delete'
+          else attributes['action'] = 'add'
+        end
+      end
+
+      ##
+      # Get groups the item belongs to
+      # result:: [Array] of [String] The groups
+      def groups
+        result = []
+        each_element('group') { |group|
+          result.push(group.text)
+        }
+        result
+      end
+
+      ##
+      # Set groups the item belongs to,
+      # deletes old groups first.
+      #
+      # See JEP 0083 for nested groups
+      # ary:: [Array] New groups, duplicate values will be removed
+      def groups=(ary)
+        # Delete old group elements
+        delete_elements('group')
+
+        # Add new group elements
+        ary.uniq.each { |group|
+          add_element('group').text = group
+        }
+      end
+    end #Class XRosterItem
+
+    class RosterXItem < XRosterItem
+      name_xmlns 'item', 'http://jabber.org/protocol/rosterx'
+    end
+  end #Module Roster
+end #Module Jabber

data/lib/xmpp4r/rpc.rb

@@ -0,0 +1,2 @@
+require 'xmpp4r/rpc/helper/client'
+require 'xmpp4r/rpc/helper/server'

data/lib/xmpp4r/rpc/helper/client.rb

@@ -0,0 +1,123 @@
+require 'xmlrpc/server'
+require 'xmlrpc/parser'
+require 'xmlrpc/create'
+require 'xmlrpc/config'
+require 'xmlrpc/utils'         # ParserWriterChooseMixin
+
+require 'xmpp4r/dataforms/x/data'
+require 'xmpp4r/rpc/iq/rpc'
+require 'xmpp4r/rpc/helper/xmlrpcaddons'
+
+module Jabber
+  module RPC
+
+    ##
+    # XMLRPC Client
+    class Client
+
+      include XMLRPC::ParserWriterChooseMixin
+      include XMLRPC::ParseContentType
+
+      attr_accessor :my_jid
+
+      ##
+      # xmppstream
+      # stream:: [Stream]
+      # jid where you want to send the rpc requests to
+      # jid:: [JID] rpcserver@jabberserver/ressource
+      def initialize(stream,jid)
+        @jid    = JID.new(jid)
+        @my_jid = stream.jid
+        @stream =  stream
+        @parser = nil
+        @create = XMLRPC::Create.new
+      end
+
+      ##
+      # automatically trys to find a method
+      # thanx to eric cestari  :)
+      def method_missing(methodname, *args)
+        send("call", methodname,*args)
+      end
+
+
+      def call(method, *args)
+        ok, param = call2(method, *args)
+        if ok
+          param
+        else
+          raise param
+        end
+      end
+
+      def call2(method, *args)
+        request = @create.methodCall(method, *args)
+        data = do_rpc(request)
+        parser().parseMethodResponse(data)
+      end
+
+      ##
+      # adds multi rpcalls to the query
+      # methods:: [Array]
+      def multicall(*methods)
+        ok, params = multicall2(*methods)
+        if ok
+          params
+        else
+          raise params
+        end
+      end
+
+      ##
+      # generate a multicall
+      # methods:: [Array]
+      def multicall2(*methods)
+        gen_multicall(methods)
+      end
+
+      def do_rpc(xmlrpc)
+        iq = Iq.new(:set, @jid)
+        iq.from = @my_jid
+        iq.id = IdGenerator::generate_id
+        rpcquery = iq.add(IqQueryRPC.new)
+        rpcquery.typed_add(xmlrpc)
+
+        result = nil
+        @stream.send_with_id(iq) do |iqreply|
+          if iqreply.query.kind_of?(IqQueryRPC)
+            result = iqreply.query.to_s
+          end
+        end
+
+        result
+      end
+
+      private
+
+      def gen_multicall(methods=[])
+        ok, params = call2("system.multicall",
+          methods.collect { |m|
+            {
+              'methodName' => m[0],
+              'params' => m[1..-1]
+            }
+          }
+        )
+
+        if ok
+          params = params.collect{ |param|
+            if param.is_a? Array
+              param[0]
+            elsif param.is_a? Hash
+              XMLRPC::FaultException.new(param["faultCode"], param["faultString"])
+            else
+              raise "Wrong multicall return value"
+            end
+          }
+        end
+
+        return ok, params
+      end
+    end
+  end  # Helpers
+end   # Jabber