hipbot 1.0.0.rc2 → 1.0.0

data/Rakefile

@@ -1,4 +1,4 @@
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task :default  => :spec
+task default:  :spec

data/bin/hipbot

@@ -2,11 +2,11 @@
 
 require 'daemons'
 
-hipbot_file = 'bot.rb'
+HIPBOT_FILE = 'bot.rb'
 
-if File.exists?(hipbot_file)
-  Daemons.run(hipbot_file)
+if File.exists?(HIPBOT_FILE)
+  Daemons.run(HIPBOT_FILE)
 else
-  puts "File #{hipbot_file} not found!"
+  puts "File #{HIPBOT_FILE} not found!"
   exit 1
 end

data/hipbot.gemspec

@@ -1,12 +1,13 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 require File.expand_path('../lib/hipbot/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Bartosz Kopiński", "Tomasz Pewiński"]
   gem.email         = ["bartosz.kopinski@netguru.pl", "pewniak747@gmail.com"]
-  gem.description   = "Hipbot is a bot for HipChat, written in ruby & eventmachine."
-  gem.summary       = "Hipbot is a bot for HipChat, written in ruby & eventmachine."
+  gem.description   = "Hipbot is a XMPP bot for HipChat, written in Ruby with EventMachine."
+  gem.summary       = "Hipbot is a XMPP bot for HipChat, written in Ruby with EventMachine."
   gem.homepage      = "http://github.com/pewniak747/hipbot"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -14,12 +15,11 @@ Gem::Specification.new do |gem|
   gem.name          = "hipbot"
   gem.require_paths = ["lib"]
   gem.version       = Hipbot::VERSION
-  gem.add_runtime_dependency "daemons", ["~> 1.1.8"]
-  gem.add_runtime_dependency "activesupport", ["~> 3.2.12"]
-  gem.add_runtime_dependency "i18n", ["~> 0.6.0"]
-  gem.add_runtime_dependency "eventmachine", ["~> 1.0.3"]
-  gem.add_runtime_dependency "em-http-request", ["~> 1.0.3"]
-  gem.add_runtime_dependency "xmpp4r", ["~> 0.5"]
+  gem.add_runtime_dependency "xmpp4r-hipchat", [">= 0.0.3"]
+  gem.add_runtime_dependency "daemons", [">= 1.1.8"]
+  gem.add_runtime_dependency "activesupport", [">= 3.2.12"]
+  gem.add_runtime_dependency "eventmachine", [">= 1.0.3"]
+  gem.add_runtime_dependency "em-http-request", [">= 1.0.3"]
   gem.add_development_dependency "rspec", ['~> 2.13.0']
   gem.add_development_dependency "guard-rspec", ['~> 2.5.1']
   gem.add_development_dependency "mocha", ['~> 0.13.3']

data/lib/hipbot.rb

@@ -1,23 +1,40 @@
-require 'active_support/all'
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
 require 'ostruct'
+require 'json'
 require 'eventmachine'
 require 'em-http-request'
-require 'xmpp4r'
-require 'xmpp4r/muc'
+require 'xmpp4r-hipchat'
 
-require 'hipbot/patches/hipchat_client'
+require 'hipbot/cache'
 require 'hipbot/patches/encoding'
-
 require 'hipbot/logger'
-require 'hipbot/adapters/hipchat/hipchat'
-require 'hipbot/adapters/hipchat/connection'
-require 'hipbot/adapters/telnet/telnet'
-require 'hipbot/adapters/telnet/connection'
+require 'hipbot/callbacks/base'
+require 'hipbot/callbacks/message'
+require 'hipbot/callbacks/private_message'
+require 'hipbot/callbacks/room_message'
+require 'hipbot/callbacks/presence'
+require 'hipbot/callbacks/lobby_presence'
+require 'hipbot/callbacks/room_presence'
+require 'hipbot/callbacks/invite'
+require 'hipbot/adapter'
+require 'hipbot/adapters/hipchat/initializer'
+require 'hipbot/adapters/hipchat'
+require 'hipbot/adapters/telnet'
+require 'hipbot/adapters/shell'
+require 'hipbot/reaction_factory'
 require 'hipbot/reactable'
+require 'hipbot/matchable'
+require 'hipbot/configuration'
+require 'hipbot/configurable'
 require 'hipbot/bot'
 require 'hipbot/plugin'
-require 'hipbot/configuration'
-require 'hipbot/collection'
+require 'hipbot/storages/base'
+require 'hipbot/storages/hash'
+require 'hipbot/http'
 require 'hipbot/helpers'
 require 'hipbot/match'
 require 'hipbot/message'

data/lib/hipbot/adapter.rb

@@ -0,0 +1,80 @@
+module Hipbot
+  module Adapter
+    attr_accessor :connection
+
+    def start!
+      logger.info("STARTING")
+      self.connection = adapter.new
+      connection.start!
+      set_presence(status)
+      join_rooms(join)
+    end
+
+    def restart!
+      logger.info("RESTARTING")
+      leave_all_rooms
+      connection.restart!
+    end
+
+    def join_room(room)
+      logger.info("JOINING #{room}")
+      connection.join_room(room)
+    end
+
+    def leave_room(room)
+      logger.info("LEAVING #{room}")
+      connection.leave_room(room)
+    end
+
+    def invite_to_room(room, users)
+      logger.info("INVITING to #{room}: #{users}")
+      connection.invite_to_room(room, users)
+    end
+
+    def kick_from_room(room, users)
+      logger.info("KICKING from #{room}: #{users}")
+      connection.kick_from_room(room, users)
+    end
+
+    def send_to_room(room, message)
+      logger.info("REPLY in #{room}")
+      connection.send_to_room(room, message)
+    end
+
+    def send_to_user(user, message)
+      logger.info("REPLY to #{user}")
+      connection.send_to_user(user, message)
+    end
+
+    def set_topic(room, topic)
+      logger.info("TOPIC seting in #{room} to '#{topic}'")
+      connection.set_topic(room, topic)
+    end
+
+    def set_presence(status, type = :available)
+      logger.info("PRESENCE set to #{type} with '#{status}'")
+      connection.set_presence(status, type)
+    end
+
+    protected
+
+    def join_rooms criteria
+      rooms_to_join(criteria).each(&:join)
+    end
+
+    def rooms_to_join criteria
+      case criteria
+        when :all then Room.all
+        when :private then Room.where(privacy: 'private')
+        when :public then Room.where(privacy: 'public')
+        when Array then criteria.flat_map{ |c| rooms_to_join(c) }.uniq
+        when String then Room.where(name: criteria)
+        else []
+      end.reject(&:archived?)
+    end
+
+    def leave_all_rooms
+      Room.all.each(&:leave)
+    end
+  end
+end

data/lib/hipbot/adapters/hipchat.rb

@@ -0,0 +1,53 @@
+module Hipbot
+  module Adapters
+    class Hipchat
+      attr_accessor :client
+
+      def start!
+        self.client = Initializer.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(type, nil, status)
+      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

@@ -0,0 +1,83 @@
+module Hipbot
+  module Adapters
+    class Hipchat
+      class Initializer
+        attr_accessor :client
+
+        KEEP_ALIVE_INTERVAL = 60
+
+        def initialize
+          Jabber.debug  = true
+          Jabber.logger = Hipbot.logger
+          initialize_client do
+            initialize_rooms
+            initialize_users
+            initialize_bot_user
+            initialize_callbacks
+            initialize_keep_alive
+          end
+        end
+
+        protected
+
+        def initialize_client
+          self.client = ::Jabber::MUC::HipchatClient.new(Hipbot.jid)
+          yield if client.connect(Hipbot.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.id
+          end
+          clean_other_objects(Room, room_ids) if room_ids.any?
+        end
+
+        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)
+
+            if user.attributes['email'].nil?
+              # user.update_attributes(client.get_user_details(user.id))
+            end
+            user.id
+          end
+          clean_other_objects(User, user_ids) if user_ids.any?
+        end
+
+        def clean_other_objects klass, object_ids
+          klass.all.select{ |r| !object_ids.include?(r.id) }.each(&:destroy)
+        end
+
+        def initialize_bot_user
+          Hipbot.configuration.user = User.find(Hipbot.jid)
+          client.name = Hipbot.user.name
+        end
+
+        def initialize_callbacks
+          client.on_room_message{ |*args| Callbacks::RoomMessage.new(*args) }
+          client.on_private_message{ |*args| Callbacks::PrivateMessage.new(*args) }
+          client.on_invite{ |*args| Callbacks::Invite.new(*args) }
+          client.on_lobby_presence{ |*args| Callbacks::LobbyPresence.new(*args) }
+          client.on_room_presence{ |*args| Callbacks::RoomPresence.new(*args) }
+          client.activate_callbacks
+        end
+
+        def initialize_keep_alive
+          ::EM::add_periodic_timer(KEEP_ALIVE_INTERVAL) do
+            client.keep_alive(Hipbot.password) unless client.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/adapters/shell.rb

@@ -0,0 +1,37 @@
+module Hipbot
+  module Adapters
+    class Shell
+      attr_accessor :connection
+
+      def start!
+        EM.open_keyboard(KeyboardHandler, self)
+      end
+
+      def invite_to_room(*); end
+      def join_room(*); end
+      def kick_from_room(*); end
+      def leave_room(*); end
+      def restart!; end
+      def send_to_room(*); end
+      def set_presence(*); end
+      def set_topic(*); end
+
+      module KeyboardHandler
+        include EM::Protocols::LineText2
+        include Cache
+
+        def initialize adapter
+          adapter.connection = self
+        end
+
+        attr_cache :user do
+          Hipbot::User.find_or_create_by(name: 'Shell User')
+        end
+
+        def receive_line data
+          Hipbot.react(user, nil, data.strip)
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/adapters/telnet.rb

@@ -0,0 +1,41 @@
+module Hipbot
+  module Adapters
+    class Telnet
+      attr_accessor :connection
+
+      def start!
+        ::EM::start_server('0.0.0.0', 3001, Connection, self)
+      end
+
+      def send_to_user user, message
+        connection.send_data("#{self}:#{user}:#{message}\n")
+      end
+
+      def invite_to_room(*); end
+      def join_room(*); end
+      def kick_from_room(*); end
+      def leave_room(*); end
+      def restart!; end
+      def send_to_room(*); end
+      def set_presence(*); end
+      def set_topic(*); end
+
+      class Connection < EM::Connection
+        include Cache
+
+        def initialize adapter
+          adapter.connection = self
+        end
+
+        attr_cache :user do
+          Hipbot::User.find_or_create_by(name: 'Telnet User')
+        end
+
+        def receive_data data
+          message = data.strip
+          Hipbot.react(user, nil, message)
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/bot.rb

@@ -13,27 +13,15 @@ module Hipbot
   end
 
   class Bot
-    extend Reactable
+    include Adapter
+    include Configurable
     include Singleton
+    include Matchable
+    extend Reactable
 
-    attr_accessor :configuration, :connection
-
-    CONFIGURABLE_OPTIONS = [:adapter, :error_handler, :helpers, :jid, :logger, :password, :plugins, :preloader, :rooms, :storage, :teams, :user]
-    delegate *CONFIGURABLE_OPTIONS, to: :configuration
-    delegate :name, to: :user
-    alias_method :to_s, :name
-
-    def initialize
-      self.configuration ||= Configuration.new
-    end
-
-    def react sender, room, message
-      message = Message.new(message, room, sender)
-      matching_reactions(message, sender.reactions, plugin_reactions, default_reactions).each(&:invoke)
-    end
+    delegate :name, :to_s, to: :user
 
     def setup
-      extend adapter
       Hipbot.bot = self
 
       User.send(:include, storage)
@@ -41,54 +29,29 @@ module Hipbot
       Response.send(:include, helpers)
 
       helpers.module_exec(&preloader)
-      plugins.append(self)
-      Jabber.debug  = true
-      Jabber.logger = logger
-    end
-
-    def plugin_reactions
-      plugins.flat_map{ |p| p.class.reactions }
-    end
-
-    def default_reactions
-      plugins.flat_map{ |p| p.class.default_reactions }
+      plugins << self
     end
 
     class << self
-      def configure &block
-        instance.configuration = Configuration.new.tap(&block)
-      end
-
       def on_preload &block
         instance.configuration.preloader = block
       end
 
-      def on_error &block
-        instance.configuration.error_handler = block
+      def on_exception &block
+        instance.configuration.exception_handler = block
       end
 
       def start!
-        ::EM::run do
+        ::EM.error_handler(&instance.configuration.exception_handler)
+        ::EM.run do
           instance.setup
-          instance.start!
+          begin
+            instance.start!
+          rescue Exception => e
+            instance_exec(e, &instance.configuration.exception_handler)
+          end
         end
       end
     end
-
-    protected
-
-    def matching_reactions message, *reaction_sets
-      reaction_sets.each do |reactions|
-        matches = reactions.map{ |reaction| matching_rection(message, reaction) }.compact
-        return matches if matches.any?
-      end
-      []
-    end
-
-    def matching_rection message, reaction
-      match = reaction.match_with(message)
-      match.matches? ? match : nil
-    end
-
   end
 end