bryanl-xmpp4r 0.3.2

data/lib/xmpp4r/muc/helper/simplemucclient.rb

@@ -0,0 +1,250 @@
+# =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/delay/x/delay'
+require 'xmpp4r/muc/helper/mucclient'
+require 'xmpp4r/muc/iq/mucadminitem'
+
+module Jabber
+  module MUC
+    ##
+    # This class attempts to implement a lot of complexity of the
+    # Multi-User Chat protocol. If you want to implement JEP0045
+    # yourself, use Jabber::MUC::MUCClient for some minor
+    # abstraction.
+    #
+    # Minor flexibility penalty: the on_* callbacks are no
+    # CallbackLists and may therefore only used once. A second
+    # invocation will overwrite the previous set up block.
+    #
+    # *Hint:* the parameter time may be nil if the server didn't
+    # send it.
+    #
+    # Example usage:
+    #   my_muc = Jabber::MUC::SimpleMUCClient.new(my_client)
+    #   my_muc.on_message { |time,nick,text|
+    #     puts (time || Time.new).strftime('%I:%M') + " <#{nick}> #{text}"
+    #   }
+    #   my_muc.join(Jabber::JID.new('jdev@conference.jabber.org/XMPP4R-Bot'))
+    #
+    # Please take a look at Jabber::MUC::MUCClient for
+    # derived methods, such as MUCClient#join, MUCClient#exit,
+    # ...
+    class SimpleMUCClient < MUCClient
+      ##
+      # Initialize a SimpleMUCClient
+      # stream:: [Stream] to operate on
+      # jid:: [JID] room@component/nick
+      # password:: [String] Optional password
+      def initialize(stream)
+        super
+
+        @room_message_block = nil
+        @message_block = nil
+        @private_message_block = nil
+        @subject_block = nil
+
+        @subject = nil
+
+        @join_block = nil
+        add_join_callback(999) { |pres|
+          # Presence time
+          time = nil
+          pres.each_element('x') { |x|
+            if x.kind_of?(Delay::XDelay)
+              time = x.stamp
+            end
+          }
+
+          # Invoke...
+          @join_block.call(time, pres.from.resource) if @join_block
+          false
+        }
+
+        @leave_block = nil
+        @self_leave_block = nil
+        add_leave_callback(999) { |pres|
+          # Presence time
+          time = nil
+          pres.each_element('x') { |x|
+            if x.kind_of?(Delay::XDelay)
+              time = x.stamp
+            end
+          }
+
+          # Invoke...
+          if pres.from == jid
+            @self_leave_block.call(time) if @self_leave_block
+          else
+            @leave_block.call(time, pres.from.resource) if @leave_block
+          end
+          false
+        }
+      end
+
+      private
+
+      def handle_message(msg)
+        super
+
+        # Message time (e.g. history)
+        time = nil
+        msg.each_element('x') { |x|
+          if x.kind_of?(Delay::XDelay)
+            time = x.stamp
+          end
+        }
+        sender_nick = msg.from.resource
+
+
+        if msg.subject
+          @subject = msg.subject
+          @subject_block.call(time, sender_nick, @subject) if @subject_block
+        end
+
+        if msg.body
+          if sender_nick.nil?
+            @room_message_block.call(time, msg.body) if @room_message_block
+          else
+            if msg.type == :chat
+              @private_message_block.call(time, msg.from.resource, msg.body) if @private_message_block
+            elsif msg.type == :groupchat
+              @message_block.call(time, msg.from.resource, msg.body) if @message_block
+            else
+              # ...?
+            end
+          end
+        end
+      end
+
+      public
+
+      ##
+      # Room subject/topic
+      # result:: [String] The subject
+      def subject
+        @subject
+      end
+
+      ##
+      # Change the room's subject/topic
+      #
+      # This will not be reflected by SimpleMUCClient#subject
+      # immediately, wait for SimpleMUCClient#on_subject
+      # s:: [String] New subject
+      def subject=(s)
+        msg = Message.new
+        msg.subject = s
+        send(msg)
+      end
+
+      ##
+      # Send a simple text message
+      # text:: [String] Message body
+      # to:: [String] Optional nick if directed to specific user
+      def say(text, to=nil)
+        send(Message.new(nil, text), to)
+      end
+
+      ##
+      # Request the MUC to invite users to this room
+      #
+      # Sample usage:
+      #   my_muc.invite( {'wiccarocks@shakespeare.lit/laptop' => 'This coven needs both wiccarocks and hag66.',
+      #                   'hag66@shakespeare.lit' => 'This coven needs both hag66 and wiccarocks.'} )
+      # recipients:: [Hash] of [JID] => [String] Reason
+      def invite(recipients)
+        msg = Message.new
+        x = msg.add(XMUCUser.new)
+        recipients.each { |jid,reason|
+          x.add(XMUCUserInvite.new(jid, reason))
+        }
+        send(msg)
+      end
+
+      ##
+      # Administratively remove one or more users from the room.
+      #
+      # Will wait for response, possibly raising ServerError
+      #
+      # Sample usage:
+      #   my_muc.kick 'pistol', 'Avaunt, you cullion!'
+      #   my_muc.kick(['Bill', 'Linus'], 'Stop flaming')
+      #
+      # recipients:: [Array] of, or single [String]: Nicks
+      # reason:: [String] Kick reason
+      def kick(recipients, reason)
+        recipients = [recipients] unless recipients.kind_of? Array
+        items = recipients.collect { |recipient|
+          item = IqQueryMUCAdminItem.new
+          item.nick = recipient
+          item.role = :none
+          item.reason = reason
+          item
+        }
+        send_affiliations(items)
+      end
+
+      ##
+      # Block to be invoked when a message *from* the room arrives
+      #
+      # Example:
+      #   Astro has joined this session
+      # block:: Takes two arguments: time, text
+      def on_room_message(&block)
+        @room_message_block = block
+      end
+
+      ##
+      # Block to be invoked when a message from a participant to
+      # the whole room arrives
+      # block:: Takes three arguments: time, sender nickname, text
+      def on_message(&block)
+        @message_block = block
+      end
+
+      ##
+      # Block to be invoked when a private message from a participant
+      # to you arrives.
+      # block:: Takes three arguments: time, sender nickname, text
+      def on_private_message(&block)
+        @private_message_block = block
+      end
+
+      ##
+      # Block to be invoked when somebody sets a new room subject
+      # block:: Takes three arguments: time, nickname, new subject
+      def on_subject(&block)
+        @subject_block = block
+      end
+
+      ##
+      # Block to be called when somebody enters the room
+      #
+      # If there is a non-nil time passed to the block, chances
+      # are great that this is initial presence from a participant
+      # after you have joined the room.
+      # block:: Takes two arguments: time, nickname
+      def on_join(&block)
+        @join_block = block
+      end
+
+      ##
+      # Block to be called when somebody leaves the room
+      # block:: Takes two arguments: time, nickname
+      def on_leave(&block)
+        @leave_block = block
+      end
+
+      ##
+      # Block to be called when *you* leave the room
+      #
+      # Deactivation occurs *afterwards*.
+      # block:: Takes one argument: time
+      def on_self_leave(&block)
+        @self_leave_block = block
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/iq/mucadmin.rb

@@ -0,0 +1,23 @@
+# =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'
+
+module Jabber
+  module MUC
+    class IqQueryMUCAdmin < IqQuery
+      name_xmlns 'query', 'http://jabber.org/protocol/muc#admin'
+
+      include XParent
+
+      def items
+        r = []
+        each_element('item') { |item|
+          r << item if item.kind_of? IqQueryMUCAdminItem
+        }
+        r
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/iq/mucadminitem.rb

@@ -0,0 +1,20 @@
+# =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/muc/item'
+
+module Jabber
+  module MUC
+    class IqQueryMUCAdminItem < MUC::UserItem
+      name_xmlns 'item', 'http://jabber.org/protocol/muc#admin'
+
+      def initialize(affiliation=nil, role=nil, jid=nil)
+        super()
+        set_affiliation(affiliation)
+        set_role(role)
+        set_jid(jid)
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/iq/mucowner.rb

@@ -0,0 +1,15 @@
+# =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'
+
+module Jabber
+  module MUC
+    class IqQueryMUCOwner < IqQuery
+      name_xmlns 'query', 'http://jabber.org/protocol/muc#owner'
+
+      include XParent
+    end
+  end
+end

data/lib/xmpp4r/muc/item.rb

@@ -0,0 +1,143 @@
+# =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/
+
+module Jabber
+  module MUC
+    ##
+    # Don't use this. It is the base class (unifying shared
+    # attributes) of XMUCUserItem and IqQueryMUCAdminItem
+    class UserItem < XMPPElement
+      def affiliation
+        case attributes['affiliation']
+          when 'admin' then :admin
+          when 'member' then :member
+          when 'none' then :none
+          when 'outcast' then :outcast
+          when 'owner' then :owner
+          else nil
+        end
+      end
+
+      def affiliation=(v)
+        case v
+          when :admin then attributes['affiliation'] = 'admin'
+          when :member then attributes['affiliation'] = 'member'
+          when :none then attributes['affiliation'] = 'none'
+          when :outcast then attributes['affiliation'] = 'outcast'
+          when :owner then attributes['affiliation'] = 'owner'
+          else attributes['affiliation'] = nil
+        end
+      end
+
+      def set_affiliation(v)
+        self.affiliation = v
+        self
+      end
+
+      def jid
+        attributes['jid'].nil? ? nil : JID.new(attributes['jid'])
+      end
+
+      def jid=(j)
+        attributes['jid'] = j.nil? ? nil : j.to_s
+      end
+
+      def set_jid(j)
+        self.jid = j
+        self
+      end
+
+      def nick
+        attributes['nick']
+      end
+
+      def nick=(n)
+        attributes['nick'] = n
+      end
+
+      def set_nick(n)
+        self.nick = n
+        self
+      end
+
+      def role
+        case attributes['role']
+          when 'moderator' then :moderator
+          when 'none' then :none
+          when 'participant' then :participant
+          when 'visitor' then :visitor
+          else nil
+        end
+      end
+
+      def role=(r)
+        case r
+          when :moderator then attributes['role'] = 'moderator'
+          when :none then attributes['role'] = 'none'
+          when :participant then attributes['role'] = 'participant'
+          when :visitor then attributes['role'] = 'visitor'
+          else attributes['role'] = nil
+        end
+      end
+
+      def set_role(r)
+        self.role = r
+        self
+      end
+
+      def reason
+        text = nil
+        each_element('reason') { |xe| text = xe.text }
+        text
+      end
+
+      def reason=(s)
+        delete_elements('reasion')
+        add_element('reason').text = s
+      end
+
+      def set_reason(s)
+        self.reason = s
+        self
+      end
+
+      def continue
+        c = nil
+        each_element('continue') { |xe| c = xe }
+        c.nil?
+      end
+
+      def continue=(c)
+        delete_elements('continue')
+        add_element('continue') if c
+      end
+
+      def set_continue(c)
+        self.continue = c
+        self
+      end
+
+      def actors
+        a = []
+        each_element('actor') { |xe|
+          a.push(JID.new(xe.attributes['jid']))
+        }
+        a
+      end
+
+      def actors=(a)
+        delete_elements('actor')
+        a.each { |jid|
+          e = add_element('actor')
+          e.attributes['jid'] = jid.to_s
+        }
+      end
+
+      def set_actors(a)
+        self.actors = a
+        self
+      end
+    end
+  end
+end