xmpp4r-hipchat 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c86b726905b0644b457090253260866f05b4c2d6
-  data.tar.gz: b7d3c6e6a93f9e683f0eaac4594dd326c02be89a
+  metadata.gz: dd02f79e1cc61f8bdd46302cbe12327ce2bbfeab
+  data.tar.gz: 965a232d7d9358dc15d7d2d50ba6ef4040491fca
 SHA512:
-  metadata.gz: 40b8a1f78cd6e3cf843246b60277b959256d7688920843b968cdffb1860af209fb4745c41b211ce2941a59a221abda5c37882921fc4fa8da148f4a53bddc39c5
-  data.tar.gz: 49ffa540d99c34c845df79542c80d4f97c46ede1737dffb88d1c199dcd0a2df60b89de01576eed92dc4f3d0c33c4ad467c689197498a229b5f4886308a2328c1
+  metadata.gz: '0196c7eb22c8717f3455c233cd2561870dc4e959e3d608a2d84be9525c85c5557ecf6784274c9cc281cead2f0e2712cee7a923922920143759d5f1b04ae0eb58'
+  data.tar.gz: 2fdb5fac322cc4fcd6d501c3d57be8c95ab3f0f51a01e2ceb5f2272326e2eb64edd7d66235728250202ee4b8a948a134bb1fdf63f4c05b7401957781d6cece52

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.ruby-version
+.yardoc
+_yardoc
+coverage
+coverage/*
+doc/
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/README.md

@@ -1,6 +1,6 @@
-# Xmpp4r::Hipchat
+# XMPP4R-Hipchat
 
-TODO: Write a gem description
+This is a HipChat / Slack XMPP adapter using XMPP4R lib.
 
 ## Installation
 
@@ -18,7 +18,7 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Please refer to [Hipbot](https://github.com/pewniak747/hipbot) source code for up-to-date usage example. This gem is still in development.
 
 ## Contributing
 

data/lib/xmpp4r-hipchat.rb

@@ -6,4 +6,16 @@ require 'xmpp4r/muc/iq/mucadmin'
 require 'xmpp4r/dataforms'
 require 'xmpp4r/roster'
 require 'xmpp4r/vcard'
+
+require 'xmpp4r/muc/hipchat/message'
+require 'xmpp4r/muc/hipchat/kick_message'
+
+require 'xmpp4r/muc/hipchat/presence'
+
+require 'xmpp4r/muc/hipchat/received_stanza'
+require 'xmpp4r/muc/hipchat/received_presence'
+require 'xmpp4r/muc/hipchat/received_message'
+require 'xmpp4r/muc/hipchat/room_data'
+require 'xmpp4r/muc/hipchat/vcard'
+require 'xmpp4r/muc/hipchat/user_data'
 require 'xmpp4r/muc/helper/hipchat_client'

data/lib/xmpp4r/hipchat/version.rb

@@ -1,5 +1,5 @@
 module XMPP4R
   module HipChat
-    VERSION = '0.0.4'
+    VERSION = '0.1.0'
   end
 end

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

@@ -1,224 +1,217 @@
 module Jabber
   module MUC
     class HipchatClient
-      attr_accessor :my_jid, :chat_domain, :conference_domain, :stream
+      attr_reader :my_jid
 
-      def initialize(jid)
-        self.my_jid = JID.new(jid)
-        self.stream = Client.new(my_jid.strip) # TODO: Error Handling
-        Jabber::debuglog "Stream initialized"
-        self.chat_domain = my_jid.domain
+      def initialize jid, conference_host = nil
+        @my_jid     = JID.new(jid)
 
-        @callbacks = Hash.new { |hash, key| hash[key] = CallbackList.new }
+        @presence   = HipChat::Presence.new(my_jid)
+        @message    = HipChat::Message.new(my_jid)
+
+        @conference_host = conference_host
       end
 
-      def join(jid, password = nil, opts = { history: false })
-        room_jid = JID.new(jid)
-        xmuc = XMUC.new
-        xmuc.password = password
+      def name
+        my_jid.resource
+      end
 
-        if !opts[:history]
-          history = REXML::Element.new('history').tap{ |h| h.add_attribute('maxstanzas','0') }
-          xmuc.add_element history
-        end
+      def name= resource
+        my_jid.resource = resource
+      end
 
-        room_jid.resource = name
-        set_presence(:available, room_jid, nil, xmuc) # TODO: Handle all join responses
+      ## Actions
+
+      def join room_id, fetch_history = false
+        jid = JID.new(room_id, conference_host)
+        Jabber::debuglog "Joining #{jid}"
+        @presence.get_join(jid, fetch_history).send_to(stream)
       end
 
-      def exit(jid, reason = nil)
-        room_jid = JID.new(jid)
+      def exit room_id, reason = nil
+        jid = JID.new(room_id, conference_host)
         Jabber::debuglog "Exiting #{jid}"
-        set_presence(:unavailable, room_jid, reason)
+        @presence.get_leave(jid, reason).send_to(stream)
       end
 
-      def keep_alive password
-        if stream.is_disconnected?
-          connect(password)
-        end
+      def set_presence status = nil, type = :available, room_id = nil
+        room_jid = room_id ? JID.new(room_id, conference_host) : nil
+        Jabber::debuglog "Setting presence to #{type} in #{room_jid} with #{status}"
+        @presence.get_status(type, room_jid, status).send_to(stream)
       end
 
-      def name
-        my_jid.resource
+      def kick user_ids, room_id
+        room_jid = JID.new(room_id, conference_host)
+        user_jids = user_ids.map{ |id| JID.new(id, chat_host) }
+        Jabber::debuglog "Kicking #{user_jids} from #{room_jid}"
+        HipChat::KickMessage.new(my_jid).make(room_jid, user_jids).send_to(stream)
       end
 
-      def name= resource
-        my_jid.resource = resource
+      def invite user_ids, room_id
+        room_jid = JID.new(room_id, conference_host)
+        user_jids = user_ids.map{ |id| JID.new(id, chat_host) }
+        Jabber::debuglog "Inviting #{user_jids} to #{room_jid}"
+        @message.get_invite(room_jid, user_jids).send_to(stream)
       end
 
-      %w(lobby_presence room_presence room_message private_message invite).each do |callback_name|
-        define_method("on_#{callback_name}") do |prio = 0, ref = nil, &block|
-          @callbacks[callback_name.to_sym].add(prio, ref) do |*args|
-            block.call(*args)
-          end
-        end
+      def send_message type, recipient_id, text, subject = nil
+        jid = JID.new(recipient_id, type == :chat ? chat_host : conference_host)
+        @message.get_text(type, jid, text, subject).send_to(stream)
       end
 
-      def set_presence(type, to = nil, reason = nil, xmuc = nil, &block)
-        pres      = Presence.new(:chat, reason)
-        pres.type = type
-        pres.to   = to if to
-        pres.from = my_jid
-        pres.add(xmuc) if xmuc
-        stream.send(pres) { |r| block.call(r) }
-      end
-
-      def kick(recipients, room_jid)
-        iq      = Iq.new(:set, room_jid)
-        iq.from = my_jid
-        iq.add(IqQueryMUCAdmin.new)
-        recipients.each do |recipient|
-          item      = IqQueryMUCAdminItem.new
-          item.nick = recipient
-          item.role = :none
-          iq.query.add(item)
-        end
-        stream.send_with_id(iq)
-      end
+      ## Fetching
 
-      def invite(recipients, room_jid)
-        msg      = Message.new
-        msg.from = my_jid
-        msg.to   = room_jid
-        x        = msg.add(XMUCUser.new)
-        recipients.each do |jid|
-          x.add(XMUCUserInvite.new(jid))
-        end
-        stream.send(msg)
+      def get_rooms
+        HipChat::RoomData.get_rooms_data(stream, conference_host)
       end
 
-      def send_message(type, jid, text, subject = nil)
-        message = Message.new(JID.new(jid), text.to_s)
-        message.type    = type
-        message.from    = my_jid
-        message.subject = subject
+      def get_users
+        HipChat::UserData.get_users_data(stream)
+      end
 
-        @send_thread.join if !@send_thread.nil? && @send_thread.alive?
-        @send_thread = Thread.new do
-          stream.send(message)
-          sleep(0.2)
-        end
+      def get_user_details user_id
+        HipChat::VCard.get_details(stream, user_id)
       end
 
+      ## Connection
+
       def connect password
         stream.connect
         Jabber::debuglog "Connected to stream"
         stream.auth(password)
         Jabber::debuglog "Authenticated"
-        @muc_browser = MUCBrowser.new(stream)
-        Jabber::debuglog "MUCBrowser initialized"
-        self.conference_domain = @muc_browser.muc_rooms(chat_domain).keys.first
-        Jabber::debuglog "No conference domain found" if conference_domain.nil?
-        @roster = Roster::Helper.new(stream) # TODO: Error handling
-        @vcard  = Vcard::Helper.new(stream) # TODO: Error handling
         true
       end
 
-      def activate_callbacks
-        stream.add_presence_callback(150, self){ |presence| handle_presence(presence) }
-        stream.add_message_callback(150, self){ |message| handle_message(message) }
-        Jabber::debuglog "Callbacks activated"
+      def keep_alive password
+        if stream.is_disconnected?
+          Jabber::debuglog "Stream disconnected. Connecting again..."
+          connect(password)
+        end
       end
 
-      def get_rooms
-        iq = Iq.new(:get, conference_domain)
-        iq.from = stream.jid
-        iq.add(Discovery::IqQueryDiscoItems.new)
-
-        rooms = []
-        stream.send_with_id(iq) do |answer|
-          answer.query.each_element('item') do |item|
-            details = {}
-            item.first.children.each{ |c| details[c.name] = c.text }
-            rooms << {
-              item:    item,
-              details: details
-            }
+      ## Callbacks
+
+      CALLBACKS = %w(lobby_presence room_presence room_message private_message room_invite room_topic error)
+
+      CALLBACKS.each do |callback_name|
+        define_method("on_#{callback_name}") do |prio = 0, ref = nil, &block|
+          callbacks[callback_name.to_sym].add(prio, ref) do |*args|
+            block.call(*args)
           end
         end
-        rooms
       end
 
-      def get_users
-        @roster.wait_for_roster
-        @roster.items.map do |jid, item|
-          {
-                jid: item.jid.to_s,
-               name: item.iname,
-            mention: item.attributes['mention_name'],
-          }
+      def activate_callbacks
+        stream.add_stanza_callback(0, self) do |stanza|
+          case stanza.name
+          when 'message'
+            handle_message(HipChat::ReceivedMessage.new(stanza))
+          when 'presence'
+            handle_presence(HipChat::ReceivedPresence.new(stanza, chat_host))
+          end
         end
-      end
-
-      def get_user_details user_jid
-        vcard = @vcard.get(user_jid)
-        {
-          email: vcard['EMAIL/USERID'],
-          title: vcard['TITLE'],
-          photo: vcard['PHOTO'],
-        }
+        Jabber::debuglog "Callbacks activated"
       end
 
       def deactivate_callbacks
-        stream.delete_presence_callback(self)
-        stream.delete_message_callback(self)
+        stream.delete_stanza_callback(self)
         Jabber::debuglog "Callbacks deactivated"
       end
 
       private
 
-      def handle_presence(presence)
-        from_jid      = presence.from.strip.to_s
-        presence_type = presence.type.to_s
-        user_name     = presence.from.resource
+      def chat_host
+        my_jid.domain
+      end
+
+      def conference_host
+        @conference_host ||= begin
+          MUCBrowser.new(stream).muc_rooms(chat_host).keys.first.domain
+        end
+      rescue => e
+        Jabber.logger.error("Conference host not found")
+        nil
+      end
+
+      def stream
+        @stream ||= Client.new(my_jid.strip) # TODO: Error Handling
+      end
+
+      def callbacks
+        @callbacks ||= Hash.new { |hash, key| hash[key] = CallbackList.new }
+      end
 
-        if presence.from.domain == chat_domain
-          @callbacks[:lobby_presence].process(from_jid, presence_type)
+      def handle_presence presence
+        if presence.lobby?
+          callbacks[:lobby_presence].process(
+            presence.sender_id,
+            presence.type
+          )
         else
-          @callbacks[:room_presence].process(from_jid, user_name, presence_type)
+          callbacks[:room_presence].process(
+            presence.room_id,
+            # presence.user_id,
+            presence.sender_name,
+            presence.type,
+            presence.role,
+          )
         end
       end
 
-      def handle_message(message)
-        if is_invite?(message)
-          handle_invite(message)
-        elsif message.type == :chat
+      def handle_message message
+        case message.type
+        when :chat
           handle_private_message(message)
-        elsif message.type == :groupchat
-          handle_group_message(message)
-        elsif message.type == :error
+        when :groupchat
+          if message.topic?
+            handle_room_topic(message)
+          else
+            handle_group_message(message)
+          end
+        when :error
           handle_error(message)
+        else
+          handle_invite(message)
         end
       end
 
-      def handle_invite(message)
-        room_name = message.children.last.first_element_text('name')
-        topic     = message.children.last.first_element_text('topic')
-        room_jid  = message.from.strip.to_s
-        user_name = message.from.resource
-        @callbacks[:invite].process(room_jid, user_name, room_name, topic)
+      def handle_invite message
+        callbacks[:room_invite].process(
+          message.room_id,
+          message.room_name,
+        )
       end
 
-      def handle_private_message(message)
-        user_jid     = message.from.strip.to_s
-        message_body = message.body.to_s
-        @callbacks[:private_message].process(user_jid, message_body)
+      def handle_private_message message
+        callbacks[:private_message].process(
+          message.sender_id,
+          message.body,
+        )
       end
 
-      def handle_group_message(message)
-        room_jid     = message.from.strip.to_s
-        user_name    = message.from.resource
-        message_body = message.body.to_s
-        topic        = message.subject.to_s
-        @callbacks[:room_message].process(room_jid, user_name, message_body, topic)
+      def handle_group_message message
+        callbacks[:room_message].process(
+          message.room_id,
+          message.sender_name,
+          message.body,
+        )
       end
 
-      def handle_error(message)
-        false
+      def handle_room_topic message
+        callbacks[:room_topic].process(
+          message.room_id,
+          message.topic,
+        )
       end
 
-      def is_invite?(message)
-        !message.x.nil? && message.x.kind_of?(XMUCUser) && message.x.first.kind_of?(XMUCUserInvite)
+      def handle_error message
+        callbacks[:error].process(
+          message.room_id,
+          message.user_id,
+          message.body,
+          message.topic,
+        )
       end
     end
   end

data/lib/xmpp4r/muc/hipchat/kick_message.rb

@@ -0,0 +1,32 @@
+module Jabber
+  module MUC
+    module HipChat
+      class KickMessage < Iq
+        def initialize my_jid
+          super(:set)
+          self.from = my_jid
+          self.add(IqQueryMUCAdmin.new)
+        end
+
+        def make room_jid, recipients
+          self.to = room_jid
+
+          recipients.each do |recipient|
+            add_recipient(recipient)
+          end
+        end
+
+        def add_recipient nick
+          item      = IqQueryMUCAdminItem.new
+          item.nick = nick
+          item.role = :none
+          self.query.add(item)
+        end
+
+        def send_to(stream)
+          stream.send_with_id(self)
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/message.rb

@@ -0,0 +1,55 @@
+module Jabber
+  module MUC
+    module HipChat
+      class Message < Jabber::Message
+        def initialize my_jid
+          super()
+          @my_jid    = my_jid
+          self.from  = my_jid
+          @semaphore = Mutex.new
+        end
+
+        def get_text type, jid, text, subject = nil
+          self.dup.tap do |d|
+            recipient = JID.new(jid)
+            recipient.resource ||= recipient.node
+
+            d.body    = text.to_s
+            d.to      = recipient
+            d.type    = type
+            d.subject = subject if subject
+          end
+        end
+
+        def get_invite room_jid, recipient_jids
+          self.dup.tap do |d|
+            d.to = JID.new(room_jid)
+
+            recipient_jids.each do |recipient_jid|
+              d.add_recipient(recipient_jid)
+            end
+          end
+        end
+
+        def add_recipient jid
+          xmuc_user.add(XMUCUserInvite.new(jid))
+        end
+
+        def send_to stream, &block
+          Thread.new do
+            @semaphore.synchronize {
+              stream.send(self, &block)
+              sleep(0.2)
+            }
+          end
+        end
+
+        private
+
+        def xmuc_user
+          @xmuc_user ||= add(XMUCUser.new)
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/presence.rb

@@ -0,0 +1,52 @@
+module Jabber
+  module MUC
+    module HipChat
+      class Presence < Jabber::Presence
+        def initialize my_jid
+          super(:chat)
+          @my_jid   = my_jid
+          self.from = my_jid
+        end
+
+        def get_leave jid, reason = nil
+          get_status(:unavailable, room_jid(jid), reason)
+        end
+
+        def get_join jid, fetch_history = false
+          get_status(:available, room_jid(jid)) # TODO: Handle all join responses
+        end
+
+        def get_status type, to = nil, status = nil, fetch_history = false
+          self.dup.tap do |d|
+            d.set_status(status)
+            d.set_type(type)
+            d.no_history! unless fetch_history
+            d.to = to
+          end
+        end
+
+        def no_history!
+          element = REXML::Element.new('history').tap do |h|
+            h.add_attribute('maxstanzas', '0')
+          end
+
+          xmuc = XMUC.new
+          xmuc.add_element(element)
+          self.add(xmuc)
+        end
+
+        def send_to stream, &block
+          stream.send(self, &block)
+        end
+
+        private
+
+        def room_jid jid
+          JID.new(jid).tap do |j|
+            j.resource = @my_jid.resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/received_message.rb

@@ -0,0 +1,33 @@
+module Jabber
+  module MUC
+    module HipChat
+      class ReceivedMessage < ReceivedStanza
+        alias_method :recipient_id, :user_id
+
+        def topic
+          @stanza.subject.to_s
+        end
+
+        def body
+          @stanza.body.to_s
+        end
+
+        ## Invite
+
+        def topic?
+          @stanza.children.first.name == "subject"
+        end
+
+        def invite?
+          !@stanza.x.nil? &&
+            @stanza.x.kind_of?(XMUCUser) &&
+            @stanza.x.first.kind_of?(XMUCUserInvite)
+        end
+
+        def room_name
+          @stanza.children.last.first_element_text('name')
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/received_presence.rb

@@ -0,0 +1,32 @@
+module Jabber
+  module MUC
+    module HipChat
+      class ReceivedPresence < ReceivedStanza
+        def initialize stanza, chat_host
+          super stanza
+          @is_lobby = chat_host == host
+        end
+
+        def lobby?
+          @is_lobby
+        end
+
+        def type
+          super || @stanza.show || :available
+        end
+
+        ## Room presence
+
+        def role
+          item.affiliation if item
+        end
+
+        private
+
+        def host
+          @stanza.from.domain if @stanza.from
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/received_stanza.rb

@@ -0,0 +1,42 @@
+module Jabber
+  module MUC
+    module HipChat
+      class ReceivedStanza
+        def initialize stanza
+          @stanza = stanza
+        end
+
+        # Presence Types: :available, :unavailable, ...
+        # Message Types: :chat, :groupchat, :error, ...
+        def type
+          @stanza.type
+        end
+
+        # User ID is available in presences and private messages
+        def user_id
+          item.jid.node if item
+        end
+
+        def sender_id
+          @stanza.from.node
+        end
+        alias_method :room_id, :sender_id
+
+        # Used in room message or presence
+        def sender_name
+          @stanza.from.resource
+        end
+
+        private
+
+        def item
+          @item ||= begin
+            if @stanza.x.respond_to?(:items)
+              @stanza.x.items.first
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/room_data.rb

@@ -0,0 +1,46 @@
+module Jabber
+  module MUC
+    module HipChat
+      class RoomData
+        # ATTRIBUTES = [:id, :topic, :privacy, :is_archived, :guest_url, :owner, :last_active, :num_participants]
+        attr_accessor :attributes
+
+        def initialize room
+          @room       = room
+          @attributes = {
+            "name" => name,
+            "id" => id,
+          }
+
+          room.first.children.each do |c|
+            @attributes[c.name] ||= c.text
+          end
+        end
+
+        def name
+          @room.iname
+        end
+
+        def id
+          @room.jid.node
+        end
+
+        class << self
+          def get_rooms_data stream, conference_host
+            iq = Iq.new(:get, conference_host)
+            iq.from = stream.jid
+            iq.add(Discovery::IqQueryDiscoItems.new)
+
+            rooms = []
+            stream.send_with_id(iq) do |answer|
+              answer.query.each_element('item') do |item|
+                rooms << self.new(item)
+              end
+            end
+            rooms
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/user_data.rb

@@ -0,0 +1,50 @@
+module Jabber
+  module MUC
+    module HipChat
+      class UserData
+        def initialize user
+          @user = user
+        end
+
+        def id
+          @user.jid.node
+        end
+
+        def name
+          @user.iname
+        end
+
+        def mention
+          @user.attributes['mention_name']
+        end
+
+        def attributes
+          {
+               name: name,
+            mention: mention,
+          }
+        end
+
+        class << self
+          def get_users_data stream
+            @stream ||= stream
+            @roster ||= Roster::Helper.new(stream, false) # TODO: Error handling
+
+            loop do
+              rosterget = Iq.new_rosterget
+              rosterget.id = "roster_1"
+              @stream.send(rosterget)
+              @roster.wait_for_roster
+              break if @roster.items.any?
+              sleep(2)
+            end
+
+            @roster.items.map do |_, item|
+              self.new(item)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/muc/hipchat/vcard.rb

@@ -0,0 +1,40 @@
+module Jabber
+  module MUC
+    module HipChat
+      class VCard
+        def initialize vcard
+          @vcard = vcard
+        end
+
+        def email
+          @vcard['EMAIL/USERID']
+        end
+
+        def title
+          @vcard['TITLE']
+        end
+
+        def photo
+          @vcard['PHOTO']
+        end
+
+        def attributes
+          {
+            email: email,
+            title: title,
+            photo: photo,
+          }
+        end
+
+        class << self
+          def get_details stream, user_id
+            @vcard_helper ||= Vcard::Helper.new(stream)
+            user_jid        = JID.new(user_id, stream.host)
+            vcard           = @vcard_helper.get(user_jid)
+            VCard.new(vcard)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/muc/clienttester.rb

@@ -0,0 +1,149 @@
+# =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/
+
+$:.unshift '../lib'
+require 'xmpp4r'
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/semaphore'
+
+# Jabber::debug = true
+$ctdebug = false
+# $ctdebug = true
+
+# This is sane for tests:
+Thread::abort_on_exception = true
+
+# Turn $VERBOSE off to suppress warnings about redefinition
+oldverbose = $VERBOSE
+$VERBOSE = false
+
+module Jabber
+  ##
+  # The ClientTester is a mix-in which provides a setup and teardown
+  # method to prepare a Stream object (@client) and the method
+  # interfacing as the "server side":
+  # * send(xml):: Send a stanza to @client
+  #
+  # The server side is a stream, too: add your callbacks to @server
+  #
+  # ClientTester is written to test complex helper classes.
+  module ClientTester
+    @@SOCKET_PORT = 65223
+
+    def setup
+      servlisten = TCPServer.new(@@SOCKET_PORT)
+      serverwait = Semaphore.new
+      stream = '<stream:stream xmlns:stream="http://etherx.jabber.org/streams">'
+
+      @state = 0
+      @states = []
+
+      Thread.new do
+        Thread.current.abort_on_exception = true
+        serversock = servlisten.accept
+        servlisten.close
+        serversock.sync = true
+        @server = Stream.new
+        @server.add_xml_callback do |xml|
+          if xml.prefix == 'stream' and xml.name == 'stream'
+            send(stream)
+            true
+          else
+            false
+          end
+        end
+        @server.start(serversock)
+
+        serverwait.run
+      end
+
+      clientsock = TCPSocket.new('localhost', @@SOCKET_PORT)
+      clientsock.sync = true
+      @client = Stream.new
+#=begin
+      class << @client
+        def jid
+          begin
+            #raise
+          rescue
+            puts $!.backtrace.join("\n")
+          end
+          JID.new('test@test.com/test')
+        end
+      end
+#=end
+      @client.start(clientsock)
+
+      @processdone_wait = Semaphore.new
+      @nextstate_wait = Semaphore.new
+      serverwait.wait
+      @server.add_stanza_callback { |stanza|
+        # Client prepares everything, then calls wait_state. Problem: because
+        # of a race condition, it is possible that we receive the stanza before
+        # what to do with it is defined. We busy-wait on @states here.
+        n = 0
+        while @state >= @states.size and n < 1000
+          Thread.pass
+          n += 1
+        end
+        if n == 1000
+          puts "Unmanaged stanza in state. Maybe processed by helper?" if $ctdebug
+        else
+          begin
+            puts "Calling #{@states[@state]} for #{stanza.to_s}" if $ctdebug
+            @states[@state].call(stanza)
+          rescue Exception => e
+            puts "Exception in state: #{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+          end
+          @state += 1
+          @nextstate_wait.wait
+          @processdone_wait.run
+        end
+
+        false
+      }
+      @client.send(stream) { |reply| true }
+
+    end
+
+    def teardown
+      # In some cases, we might lost count of some stanzas
+      # (for example, if the handler raises an exception)
+      # so we can't block forever.
+      n = 0
+      while @client.processing > 0 and n < 1000
+        Thread::pass
+        n += 1
+      end
+      n = 0
+      while @server.processing > 0 and n < 1000
+        Thread::pass
+        n += 1
+      end
+      @client.close
+      @server.close
+    end
+
+    def send(xml)
+      @server.send(xml)
+    end
+
+    def state(&block)
+      @states << block
+    end
+
+    def wait_state
+      @nextstate_wait.run
+      @processdone_wait.wait
+    end
+
+    def skip_state
+      @nextstate_wait.run
+    end
+  end
+end
+
+# Restore the old $VERBOSE setting
+$VERBOSE = oldverbose

data/spec/integration/muc/tc_muc_hipchat_client.rb

@@ -0,0 +1,110 @@
+require 'pry'
+require 'test/unit'
+require 'xmpp4r/../../test/lib/clienttester'
+require 'xmpp4r/muc'
+require 'xmpp4r/semaphore'
+# require_relative '../lib/xmpp4r/muc/hipchat_client'
+include Jabber
+
+class HipchatClientTest < Test::Unit::TestCase
+  include ClientTester
+
+  def test_new1
+    m = MUC::HipchatClient.new(@client.jid)
+    assert_equal(@client.jid, m.my_jid)
+    assert_equal(@client.jid.domain, m.chat_domain)
+    assert_equal(nil, m.conference_domain)
+  end
+
+  def test_complex
+    # Jabber.debug = true
+    m = MUC::HipchatClient.new(@client.jid)
+    m.stream = @client
+
+    block_args = []
+    wait = Semaphore.new
+    block = lambda { |*a| block_args = a; wait.run }
+    m.on_message(&block)
+    m.on_private_message(&block)
+    m.on_presence(&block)
+    m.on_invite(&block)
+    # m.on_leave(&block)
+    # m.on_self_leave(&block)
+
+    state { |pres|
+      assert_kind_of(Presence, pres)
+      assert_equal(@client.jid, pres.from)
+      assert_equal(JID.new('darkcave@macbeth.shakespeare.lit/test'), pres.to)
+      send("<presence from='darkcave@macbeth.shakespeare.lit/firstwitch' to='hag66@shakespeare.lit/pda'>" +
+          "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='owner' role='moderator'/></x>" +
+          "</presence>" +
+          "<presence from='darkcave@macbeth.shakespeare.lit/secondwitch' to='hag66@shakespeare.lit/pda'>" +
+          "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='admin' role='moderator'/></x>" +
+          "</presence>" +
+          "<presence from='darkcave@macbeth.shakespeare.lit/thirdwitch' to='hag66@shakespeare.lit/pda'>" +
+          "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='member' role='participant'/></x>" +
+          "</presence>")
+    }
+    # m.my_jid = JID.new('hag66@shakespeare.lit/pda')
+    assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch'))
+    wait_state
+
+    state { |msg|
+      assert_kind_of(Message, msg)
+      assert_equal(:groupchat, msg.type)
+      assert_equal(JID.new('hag66@shakespeare.lit/pda'), msg.from)
+      assert_equal(JID.new('darkcave@macbeth.shakespeare.lit'), msg.to)
+      # assert_equal('TestCasing room', msg.subject)
+      assert_nil(msg.body)
+      send(msg.set_from('darkcave@macbeth.shakespeare.lit/thirdwitch').set_to('hag66@shakespeare.lit/pda'))
+    }
+    # assert_nil(m.subject)
+    # wait.wait
+    # m.subject = 'TestCasing room'
+    # wait_state
+    # wait.wait
+
+    # FIXME : **Intermittently** failing (especially during RCOV run) at this line with:
+    #   1) Failure:
+    #   test_complex(HipchatClientTest) [./test/muc/tc_muc_HipchatClient.rb:71]:
+    #   <[nil, "thirdwitch", "TestCasing room"]> expected but was
+    #   <[nil, "secondwitch"]>.
+    #
+    #assert_equal([nil, 'thirdwitch', 'TestCasing room'], block_args)
+
+    # FIXME : **Intermittently** failing (especially during RCOV run) at this line with:
+    #   1) Failure:
+    # test_complex(HipchatClientTest) [./test/muc/tc_muc_HipchatClient.rb:80]:
+    # <"TestCasing room"> expected but was
+    # <nil>.
+    #
+    #assert_equal('TestCasing room', m.subject)
+
+  end
+
+  def test_kick
+    m = MUC::HipchatClient.new(@client.jid)
+    m.stream = @client
+
+    state { |presence|
+      send("<presence from='test@test/test'/>")
+    }
+    m.join('test@test/test')
+    wait_state
+
+    state { |iq|
+      assert_kind_of(Iq, iq)
+      assert_equal('http://jabber.org/protocol/muc#admin', iq.queryns)
+      assert_kind_of(MUC::IqQueryMUCAdmin, iq.query)
+      assert_equal(1, iq.query.items.size)
+      assert_equal('pistol', iq.query.items[0].nick)
+      assert_equal(:none, iq.query.items[0].role)
+      assert_equal('Avaunt, you cullion!', iq.query.items[0].reason)
+      a = iq.answer(false)
+      a.type = :result
+      send(a)
+    }
+    m.kick('pistol', 'Avaunt, you cullion!')
+    wait_state
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require_relative '../lib/xmpp4r-hipchat'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before(:all) do
+  end
+end

data/spec/unit/hipchat_client_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Jabber
+  module MUC
+    describe HipchatClient do
+      let(:client_jid){ '00000_000000@chat.hipchat.com' }
+      let(:room_jid){ '00000_room@conf.hipchat.com' }
+
+      subject{ described_class.new(client_jid) }
+
+      describe '#initialize' do
+        it 'assigns JID' do
+          expect(subject.my_jid.to_s).to eq(client_jid)
+        end
+
+        it 'assigns chat host' do
+          expect(subject.chat_host).to eq('chat.hipchat.com')
+        end
+
+        it 'creates new stream client' do
+          expect(subject.stream).to be_instance_of(Jabber::Client)
+        end
+      end
+
+      describe '#exit' do
+        it 'sets unavailable presence' do
+          expect(subject).to receive(:set_presence).with(:unavailable, anything, anything)
+          subject.exit(room_jid)
+        end
+      end
+
+      describe '#join' do
+        it 'sets available presence' do
+          expect(subject).to receive(:set_presence).with(:available, anything, anything, anything)
+          subject.join(room_jid)
+        end
+      end
+
+      describe '#name' do
+        it 'returns JID resource' do
+          subject.name = 'client name'
+          expect(subject.name).to eq('client name')
+        end
+      end
+
+      describe '#set_presence' do
+        it 'sends a new presence to the stream' do
+          expect(subject.stream).to receive(:send).with(kind_of(Jabber::Presence))
+          subject.set_presence(:type)
+        end
+      end
+
+    end
+  end
+end

data/xmpp4r-hipchat.gemspec

@@ -5,9 +5,8 @@ Gem::Specification.new do |spec|
   spec.name          = 'xmpp4r-hipchat'
   spec.version       = XMPP4R::HipChat::VERSION
   spec.authors       = ['Bartosz Kopiński']
-  spec.email         = ['bartosz.kopinski@gmail.com']
-  spec.description   = 'HipChat client extension to XMPP4R'
-  spec.summary       = 'HipChat client extension to XMPP4R'
+  spec.email         = ['bartosz@kopinski.pl']
+  spec.summary       = 'HipChat / Slack XMPP Client'
   spec.homepage      = 'https://github.com/bartoszkopinski/xmpp4r-hipchat'
   spec.license       = 'MIT'
 
@@ -15,5 +14,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-  spec.add_runtime_dependency 'xmpp4r', ['~> 0.5']
+  spec.add_runtime_dependency 'xmpp4r', ['~> 0.5.6']
+  spec.add_development_dependency 'rspec', ['>= 2.13.0']
 end

metadata

@@ -1,36 +1,51 @@
 --- !ruby/object:Gem::Specification
 name: xmpp4r-hipchat
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Bartosz Kopiński
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-19 00:00:00.000000000 Z
+date: 2017-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xmpp4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.5.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
-description: HipChat client extension to XMPP4R
+        version: 0.5.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: 
 email:
-- bartosz.kopinski@gmail.com
+- bartosz@kopinski.pl
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
 - Gemfile
 - LICENSE
 - LICENSE.txt
@@ -39,6 +54,19 @@ files:
 - lib/xmpp4r-hipchat.rb
 - lib/xmpp4r/hipchat/version.rb
 - lib/xmpp4r/muc/helper/hipchat_client.rb
+- lib/xmpp4r/muc/hipchat/kick_message.rb
+- lib/xmpp4r/muc/hipchat/message.rb
+- lib/xmpp4r/muc/hipchat/presence.rb
+- lib/xmpp4r/muc/hipchat/received_message.rb
+- lib/xmpp4r/muc/hipchat/received_presence.rb
+- lib/xmpp4r/muc/hipchat/received_stanza.rb
+- lib/xmpp4r/muc/hipchat/room_data.rb
+- lib/xmpp4r/muc/hipchat/user_data.rb
+- lib/xmpp4r/muc/hipchat/vcard.rb
+- spec/integration/muc/clienttester.rb
+- spec/integration/muc/tc_muc_hipchat_client.rb
+- spec/spec_helper.rb
+- spec/unit/hipchat_client_spec.rb
 - xmpp4r-hipchat.gemspec
 homepage: https://github.com/bartoszkopinski/xmpp4r-hipchat
 licenses:
@@ -50,18 +78,22 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
-summary: HipChat client extension to XMPP4R
-test_files: []
+summary: HipChat / Slack XMPP Client
+test_files:
+- spec/integration/muc/clienttester.rb
+- spec/integration/muc/tc_muc_hipchat_client.rb
+- spec/spec_helper.rb
+- spec/unit/hipchat_client_spec.rb