hipbot 1.0.3 → 1.0.4

data/lib/hipbot/adapters/xmpp.rb

@@ -0,0 +1,59 @@
+require 'hipbot/adapters/xmpp/client'
+
+module Hipbot
+  module Adapters
+    class XMPP
+      include Hipbot::Adaptable
+
+      add_config_options :jid, :conference_host
+
+      attr_accessor :client
+
+      def start!
+        self.client = self.class::Client.new.client
+      end
+
+      def restart!
+        start!
+      end
+
+      def invite_to_room(room, users)
+        client.invite(user_ids(users), room.id)
+      end
+
+      def kick_from_room(room, users)
+        client.kick(user_ids(users), room.id)
+      end
+
+      def send_to_room(room, message)
+        client.send_message(:groupchat, room.id, message)
+      end
+
+      def send_to_user(user, message)
+        client.send_message(:chat, user.id, message)
+      end
+
+      def set_topic(room, topic)
+        client.send_message(:groupchat, room.id, nil, topic)
+      end
+
+      def set_presence(status, type)
+        client.set_presence(status, type)
+      end
+
+      def join_room(room)
+        client.join(room.id)
+      end
+
+      def leave_room(room, reason = '')
+        client.exit(room.id, reason)
+      end
+
+      protected
+
+      def user_ids users
+        Array(users).map(&:id)
+      end
+    end
+  end
+end

data/lib/hipbot/adapters/{hipchat/initializer.rb → xmpp/client.rb}

@@ -1,41 +1,52 @@
+require 'xmpp4r-hipchat'
+
 module Hipbot
   module Adapters
-    class Hipchat
-      class Initializer
+    class XMPP
+      class Client
         attr_accessor :client
 
         KEEP_ALIVE_INTERVAL = 60
 
         def initialize
-          Jabber.debug  = true
-          Jabber.logger = Hipbot.logger
+          initialize_logger
+
+          Hipbot.logger.info("INITIALIZE XMPP Client")
           initialize_client do
+            Hipbot.logger.info("INITIALIZE Rooms")
             initialize_rooms
+            Hipbot.logger.info("INITIALIZE Users")
             initialize_users
+            Hipbot.logger.info("INITIALIZE Bot user")
             initialize_bot_user
+            Hipbot.logger.info("INITIALIZE Callbacks")
             initialize_callbacks
+            Hipbot.logger.info("INITIALIZE Keep-alive")
             initialize_keep_alive
           end
         end
 
         protected
 
+        def initialize_logger
+          Jabber.logger = Hipbot.logger
+          if Hipbot.logger.level == Logger::DEBUG
+            Jabber.debug  = true
+          end
+        end
+
         def initialize_client
-          self.client = ::Jabber::MUC::HipchatClient.new(Hipbot.jid)
-          yield if client.connect(Hipbot.password)
+          self.client = ::Jabber::MUC::HipchatClient.new(
+            Hipbot.configuration.jid,
+            Hipbot.configuration.conference_host,
+          )
+          yield if client.connect(Hipbot.configuration.password)
         end
 
         def initialize_rooms
           room_ids = client.get_rooms.map do |room_data|
-            room = Room.find_or_create_by(id: room_data[:item].jid.to_s)
-            room.update_attributes(
-                    name: room_data[:item].iname,
-                   topic: room_data[:details]['topic'],
-                 privacy: room_data[:details]['privacy'],
-              hipchat_id: room_data[:details]['id'],
-                archived: room_data[:details].has_key?('is_archived'),
-               guest_url: room_data[:details]['guest_url'],
-            )
+            room = Room.find_or_create_by(id: room_data.id)
+            room.update_attributes(room_data.attributes)
             room.id
           end
           clean_other_objects(Room, room_ids) if room_ids.any?
@@ -43,11 +54,11 @@ module Hipbot
 
         def initialize_users
           user_ids = client.get_users.map do |user_data|
-            user = User.find_or_create_by(id: user_data.delete(:jid))
-            user.update_attributes(user_data)
+            user = User.find_or_create_by(id: user_data.id)
+            user.update_attributes(user_data.attributes)
 
             if user.attributes['email'].nil?
-              user.update_attributes(client.get_user_details(user.id))
+              user.update_attributes(client.get_user_details(user.id).attributes)
             end
             user.id
           end
@@ -55,18 +66,21 @@ module Hipbot
         end
 
         def clean_other_objects klass, object_ids
-          klass.all.select{ |r| !object_ids.include?(r.id) }.each(&:destroy)
+          klass.all.select{ |r| !object_ids.include?(r.id) }.tap{ |o|
+            Hipbot.logger.info("REMOVING #{o.count} objects from #{klass}")
+          }.each(&:destroy)
         end
 
         def initialize_bot_user
-          Hipbot.configuration.user = User.find(Hipbot.jid)
+          Hipbot.configuration.user = User.find(Jabber::JID.new(Hipbot.configuration.jid).node)
           client.name = Hipbot.user.name
         end
 
         def initialize_callbacks
           client.on_room_message{ |*args| Callbacks::RoomMessage.new(*args) }
+          client.on_room_topic{ |*args| Callbacks::RoomTopic.new(*args) }
           client.on_private_message{ |*args| Callbacks::PrivateMessage.new(*args) }
-          client.on_invite{ |*args| Callbacks::Invite.new(*args) }
+          client.on_room_invite{ |*args| Callbacks::RoomInvite.new(*args) }
           client.on_lobby_presence{ |*args| Callbacks::LobbyPresence.new(*args) }
           client.on_room_presence{ |*args| Callbacks::RoomPresence.new(*args) }
           client.activate_callbacks

data/lib/hipbot/bot.rb

@@ -1,12 +1,16 @@
 module Hipbot
   class << self
-    attr_accessor :bot, :plugins
+    attr_accessor :bot, :plugins, :adapters
     delegate :name, to: :bot
 
     def plugins
       @plugins ||= []
     end
 
+    def adapters
+      @adapters ||= []
+    end
+
     def method_missing name, *params, &block
       bot.send(name, *params, &block)
     end

data/lib/hipbot/callbacks/base.rb

@@ -4,11 +4,29 @@ module Hipbot
       protected
 
       def with_room params
-        yield Room.find_or_create_by(params)
+        yield Room.find_or_create_by(params) if valid_params?(params)
       end
 
       def with_user params
-        yield User.find_or_create_by(params)
+        yield User.find_or_create_by(params) if valid_params?(params)
+      end
+
+      def with_user_by_name_or_mention name_or_mention
+        return if !valid_value?(name_or_mention)
+
+        yield User.where(mention: name_or_mention).first ||
+          User.where(name: name_or_mention).first ||
+          User.create(name: name_or_mention, mention: name_or_mention)
+      end
+
+      private
+
+      def valid_params? params
+        params.any?{ |_, v| valid_value?(v) }
+      end
+
+      def valid_value? value
+        !value.nil? && value.present?
       end
     end
   end

data/lib/hipbot/callbacks/lobby_presence.rb

@@ -5,7 +5,8 @@ module Hipbot
         self.presence = presence
 
         with_user(id: user_id) do |user|
-          user.update_attribute(:is_online, online_presence?)
+          Hipbot.logger.info("PRESENCE from #{user}: #{presence}")
+          user.update_attribute(:is_online, !offline_presence?)
         end
       end
     end

data/lib/hipbot/callbacks/presence.rb

@@ -5,12 +5,8 @@ module Hipbot
 
       protected
 
-      def online_presence?
-        presence.empty?
-      end
-
       def offline_presence?
-        presence == 'unavailable'
+        presence == :unavailable
       end
     end
   end

data/lib/hipbot/callbacks/room_invite.rb

@@ -0,0 +1,13 @@
+module Hipbot
+  module Callbacks
+    class RoomInvite < Base
+      def initialize room_id, room_name
+        return unless Hipbot.configuration.join_on_invite
+
+        with_room(id: room_id, name: room_name) do |room|
+          Hipbot.join_room(room)
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/callbacks/room_message.rb

@@ -1,21 +1,15 @@
 module Hipbot
   module Callbacks
     class RoomMessage < Message
-      def initialize room_id, user_name, message_body, topic
+      def initialize room_id, user_name_or_mention, message_body
         with_room(id: room_id) do |room|
-          update_topic(room, topic)
-          with_user(name: user_name) do |user|
+          with_user_by_name_or_mention(user_name_or_mention) do |user|
             return if ignore_message?(user, message_body)
+
             Hipbot.react(user, room, message_body)
           end
         end
       end
-
-      protected
-
-      def update_topic room, topic
-        room.update_attribute(:topic, topic) unless topic.empty?
-      end
     end
   end
 end

data/lib/hipbot/callbacks/room_presence.rb

@@ -1,12 +1,13 @@
 module Hipbot
   module Callbacks
     class RoomPresence < Presence
-      attr_accessor :room_id, :user_name
+      attr_accessor :room_id, :user_name_or_mention
+
+      def initialize room_id, user_name_or_mention, presence, role
+        self.room_id = room_id
+        self.user_name_or_mention = user_name_or_mention
+        self.presence = presence
 
-      def initialize room_id, user_name, presence
-        self.presence  = presence
-        self.user_name = user_name
-        self.room_id   = room_id
         handle_room_presence
       end
 
@@ -14,13 +15,14 @@ module Hipbot
 
       def handle_room_presence
         with_room(id: room_id) do |room|
-          with_user(name: user_name) do |user|
+          with_user_by_name_or_mention(user_name_or_mention) do |user|
+            Hipbot.logger.info("PRESENCE in ##{room} from #{user}: #{presence}")
             Hipbot.react_to_presence(user, presence, room)
+
             if offline_presence?
               room.on_leave(user)
-            elsif online_presence? && !room.users.include?(user)
-              room.on_join(user)
             else
+              room.on_join(user) if !room.users.include?(user)
               # TODO: Availability status change handling
             end
           end

data/lib/hipbot/callbacks/room_topic.rb

@@ -0,0 +1,18 @@
+module Hipbot
+  module Callbacks
+    class RoomTopic < Message
+      def initialize room_id, topic
+        with_room(id: room_id) do |room|
+          Hipbot.logger.info("TOPIC in ##{room}: #{topic}")
+          update_topic(room, topic)
+        end
+      end
+
+      protected
+
+      def update_topic room, topic
+        room.update_attribute(:topic, topic)
+      end
+    end
+  end
+end

data/lib/hipbot/configuration.rb

@@ -1,24 +1,29 @@
 module Hipbot
   class Configuration
     OPTIONS = [
-      :adapter, :exception_handler, :helpers, :jid, :join, :logger, :password,
-      :plugins, :preloader, :rooms, :status, :storage, :teams, :user
+      :adapter, :case_insensitive, :exception_handler, :helpers, :join, :join_on_invite,
+      :logger, :password, :plugins, :preloader, :rooms, :status, :storage, :teams, :user
     ]
     attr_accessor *OPTIONS
 
     def initialize
-      self.adapter       = Adapters::Hipchat
-      self.exception_handler = Proc.new do |e|
+      self.class.class_eval do
+        attr_accessor *Hipbot.adapters.flat_map(&:options).compact
+      end
+
+      self.adapter        = Adapters::Hipchat
+      self.case_insensitive  = true
+      self.exception_handler = proc do |e|
         Hipbot.logger.error(e.message)
         e.backtrace.each { |line| Hipbot.logger.error(line) }
       end
       self.helpers       = Module.new
-      self.jid           = ''
       self.join          = :all
+      self.join_on_invite = true
       self.logger        = Logger.new($stdout)
       self.password      = ''
       self.plugins       = Hipbot.plugins
-      self.preloader     = Proc.new{}
+      self.preloader     = proc {}
       self.rooms         = {}
       self.status        = ''
       self.storage       = Storages::Hash

data/lib/hipbot/helpers.rb

@@ -1,3 +1,5 @@
+require 'hipbot/helpers/http'
+
 module Hipbot
   module Helpers
     [:get, :post, :put, :delete].each do |method|

data/lib/hipbot/{http.rb → helpers/http.rb}

@@ -1,13 +1,17 @@
+# encoding: utf-8
 module Hipbot
   module Http
-    class Request < Struct.new(:url, :query, :method)
+    class Request < Struct.new(:url, :params, :method)
       DEFAULT_HEADERS     = { 'accept-encoding' => 'gzip, compressed' }.freeze
       CONNECTION_SETTINGS = { connect_timeout: 5, inactivity_timeout: 10 }.freeze
       ERROR_CALLBACK      = ->(error){ Hipbot.logger.error(error) }
 
       def initialize *args
         super
-        Hipbot.logger.info("HTTP-REQUEST: #{url} #{query}")
+        self.params ||= {}
+        self.params = params.has_key?(:query) ? params : { query: params }
+        self.params = { head: DEFAULT_HEADERS }.merge(params)
+        Hipbot.logger.info("HTTP-REQUEST: #{url} #{params}")
       end
 
       def call &success_block
@@ -21,16 +25,16 @@ module Hipbot
 
       def success
         yield Http::Response.new(http)
-      rescue => e
-        instance_exec(e, &Hipbot.exception_handler)
       end
 
-      def http
-        @http ||= connection.send(method, query: query.merge(head: DEFAULT_HEADERS))
+      def http options = {}
+        @http ||= connection.send(method, params.merge(options))
+      rescue => e
+        instance_exec(e, &Hipbot.exception_handler)
       end
 
       def connection
-        EM::HttpRequest.new(url, CONNECTION_SETTINGS)
+        @connection ||= EM::HttpRequest.new(url, CONNECTION_SETTINGS)
       end
     end
 

data/lib/hipbot/message.rb

@@ -5,11 +5,11 @@ module Hipbot
 
     attr_accessor :body
 
-    MENTION_REGEXP = /@(\p{Word}++)/.freeze
+    MENTION_REGEXP = /@(\p{Word}++):?/.freeze
 
     def initialize *args
       super
-      Hipbot.logger.info("MESSAGE from #{sender} in #{room}")
+      Hipbot.logger.info("MESSAGE from #{sender} in ##{room}")
       self.raw_body = raw_body.force_encoding('UTF-8')
       self.body     = strip_bot_mention
     end

data/lib/hipbot/presence.rb

@@ -1,11 +1,5 @@
 module Hipbot
   class Presence < Struct.new(:sender, :body, :room)
-
-    def initialize *args
-      super
-      Hipbot.logger.info("PRESENCE from #{sender} in #{room}")
-    end
-
     def for? _
       true
     end