hipbot 0.2.0 → 1.0.0.rc1

data/lib/hipbot/bot.rb

@@ -1,81 +1,94 @@
 module Hipbot
-  class Bot < Reactable
+  class << self
+    attr_accessor :bot, :plugins
+    delegate :name, to: :bot
+
+    def plugins
+      @plugins ||= []
+    end
+
+    def method_missing name, *params, &block
+      bot.send(name, *params, &block)
+    end
+  end
+
+  class Bot
+    extend Reactable
     include Singleton
-    attr_accessor :configuration, :connection, :error_handler
 
-    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter, :helpers, :plugins, :teams, :rooms, :logger]
+    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
-      super
-      self.configuration = Configuration.new.tap(&self.class.configuration)
-      self.error_handler = self.class.error_handler
-      extend(self.adapter || Adapters::Hipchat)
+      self.configuration ||= Configuration.new
     end
 
-    def reactions
-      defined_reactions + plugin_reactions + default_reactions
+    def react sender, room, message
+      message = Message.new(message, room, sender)
+      matching_reactions(message, sender.reactions, plugin_reactions, default_reactions).each(&:invoke)
     end
 
-    def react sender, room, message
-      Hipbot.logger.info("MESSAGE from #{sender} in #{room}")
-      matching_reactions(sender, room, message) do |matches|
-        Hipbot.logger.info("REACTION #{matches.first.inspect}")
-        matches.first.invoke(sender, room, message)
-      end
+    def setup
+      extend adapter
+      Hipbot.bot = self
+
+      User.send(:include, storage)
+      Room.send(:include, storage)
+      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 }
     end
 
     class << self
-      ACCESSORS = { configure: :configuration, on_preload: :preloader, on_error: :error_handler }
+      def configure &block
+        instance.configuration = Configuration.new.tap(&block)
+      end
 
-      ACCESSORS.each do |setter, getter|
-        define_method(setter) do |&block|
-          instance_variable_set("@#{getter}", block)
-        end
+      def on_preload &block
+        instance.configuration.preloader = block
+      end
 
-        define_method(getter) do
-          instance_variable_get("@#{getter}") || Proc.new{}
-        end
+      def on_error &block
+        instance.configuration.error_handler = block
       end
 
       def start!
         ::EM::run do
-          Jabber.debug = true
-          Jabber.logger = Hipbot::Bot.instance.logger
-          Helpers.module_exec(&preloader)
+          instance.setup
           instance.start!
         end
       end
     end
 
-    def plugin_for(reaction)
-      included_plugins.find { |p| p.defined_reactions.include?(reaction) }
-    end
+    protected
 
-    private
-
-    def plugin_reactions
-      included_plugins.map(&:defined_reactions).flatten
-    end
-
-    def included_plugins
-      @included_plugins ||= begin
-        Array(plugins).map do |object|
-          plugin = object.kind_of?(Plugin) ? object : object.new
-          plugin.bot = self
-          plugin
-        end
+    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 default_reactions
-      super + included_plugins.flat_map(&:default_reactions)
+    def matching_rection message, reaction
+      match = reaction.match_with(message)
+      match.matches? ? match : nil
     end
 
-    def matching_reactions sender, room, message
-      matches = reactions.select{ |r| r.match?(sender, room, message) }
-      yield matches if matches.any?
-    end
   end
 end

data/lib/hipbot/collection.rb

@@ -1,20 +1,41 @@
 module Hipbot
-  class Collection < Struct.new(:id, :name, :params)
-    private_class_method :new
-    alias_method :to_s, :name
+  module Collection
+    extend ActiveSupport::Concern
 
-    def initialize *args
-      super
-      self.params = OpenStruct.new(params)
+    included do
+      extend ClassMethods
+
+      attr_accessor :id, :name, :attributes
+      alias_method :to_s, :name
+    end
+
+    def initialize params
+      self.id         = params.delete(:id)
+      self.name       = params.delete(:name)
+      self.attributes = params
+    end
+
+    def update_attribute key, value
+      if key == :name
+        self.name = value
+      else
+        self.attributes[key] = value
+      end
+    end
+
+    def update_attributes hash
+      hash.each do |k, v|
+        update_attribute k, v
+      end
     end
 
     def delete
       self.class.collection.delete(self.id)
     end
 
-    class << self
-      def create *args, &block
-        collection[args[0]] = new(*args, &block)
+    module ClassMethods
+      def create params, &block
+        collection[params[:id]] = new(params, &block)
       end
 
       def collection
@@ -34,6 +55,10 @@ module Hipbot
         items.map{ |i| find_one(i) }.compact.uniq
       end
 
+      def find_or_create_by params
+        find_one(params[:id] || params[:name]) || create(params)
+      end
+
       protected
 
       def method_missing name, *args, &block

data/lib/hipbot/configuration.rb

@@ -3,13 +3,21 @@ module Hipbot
     attr_accessor *Bot::CONFIGURABLE_OPTIONS
 
     def initialize
-      self.name     = 'robot'
-      self.jid      = 'changeme'
-      self.password = 'changeme'
-      self.teams    = {}
-      self.rooms    = {}
-      self.helpers  = Module.new
-      self.logger   = Hipbot::Logger.new($stdout)
+      self.adapter       = Adapters::Hipchat
+      self.error_handler = Proc.new{}
+      self.helpers       = Module.new
+      self.jid           = ''
+      self.logger        = Logger.new($stdout)
+      self.password      = ''
+      self.plugins       = Hipbot.plugins
+      self.preloader     = Proc.new{}
+      self.rooms         = {}
+      self.storage       = Collection
+      self.teams         = {}
+    end
+
+    def user
+      @user ||= User.new(name: 'robot')
     end
   end
 end

data/lib/hipbot/helpers.rb

@@ -7,10 +7,16 @@ module Hipbot
         conn = ::EM::HttpRequest.new(url, :connect_timeout => 5, :inactivity_timeout => 10)
         http = conn.send(http_verb, :query => query)
         http.callback do
-          response = HttpResponse.new(http)
-          Hipbot.logger.info("HTTP-RESPONSE: #{response}")
-          block.call(response)
+          begin
+            response = HttpResponse.new(http)
+            Hipbot.logger.info("HTTP-RESPONSE: #{response}")
+            block.call(response)
+          rescue => e
+            Hipbot.logger.error(e)
+            instance_exec(e, &Hipbot.error_handler)
+          end
         end if block.present?
+
         http.errback do
           Hipbot.logger.error("HTTP-RESPONSE-ERROR: #{url}")
         end
@@ -33,7 +39,7 @@ module Hipbot
       end
 
       def json
-        @json ||= JSON.parse(body) rescue {}
+        @json ||= JSON.parse(body)
       end
     end
   end

data/lib/hipbot/logger.rb

@@ -8,8 +8,4 @@ module Hipbot
       super(severity, "[#{severity_name}][#{Time.now}] #{msg}")
     end
   end
-
-  def self.logger
-    Hipbot::Bot.instance.logger
-  end
 end

data/lib/hipbot/match.rb

@@ -0,0 +1,48 @@
+module Hipbot
+  class Match < Struct.new(:reaction, :message)
+    def matches?
+      matches_regexp? && matches_scope? && matches_sender? && matches_place?
+    end
+
+    def invoke
+      Response.new(reaction, message).invoke(params)
+    end
+
+    protected
+
+    def params
+      reaction.anything? ? [message.body] : regexp_match[1..-1]
+    end
+
+    def matches_regexp?
+      reaction.anything? || regexp_match.present?
+    end
+
+    def regexp_match
+      @regexp_match ||= reaction.regexps.inject(nil) do |result, regexp|
+        break result if result
+        message_text.match(regexp)
+      end
+    end
+
+    def matches_scope?
+      reaction.global? || message.for?(Hipbot.user) || message.private?
+    end
+
+    def matches_place?
+      reaction.anywhere? || (message.room.present? ? matches_room? : reaction.private_message_only?)
+    end
+
+    def matches_room?
+      reaction.any_room? || reaction.rooms.include?(message.room.name)
+    end
+
+    def matches_sender?
+      reaction.from_all? || reaction.users.include?(message.sender.name)
+    end
+
+    def message_text
+      reaction.global? ? message.raw_body : message.body
+    end
+  end
+end

data/lib/hipbot/message.rb

@@ -1,28 +1,28 @@
 module Hipbot
-  class Message
-    attr_reader :body, :sender, :raw_body
+  class Message < Struct.new(:raw_body, :room, :sender)
+    attr_accessor :body, :recipients
 
-    def initialize body, sender
-      @raw_body = body
-      @body     = strip_recipient(body)
-      @sender   = sender
-    end
-
-    def recipients
-      results = raw_body.scan(/@(\w+)/) + raw_body.scan(/@"(.*)"/)
-      results.flatten.uniq
+    def initialize *args
+      super
+      Hipbot.logger.info("MESSAGE from #{sender} in #{room}")
+      self.body       = strip_recipient(raw_body)
+      self.recipients = raw_body.scan(/@(\p{Word}++)/).flatten.compact.uniq
     end
 
     def for? recipient
-      recipients.include? recipient.to_s.gsub(/\s+/, '')
+      recipients.include? recipient.mention
     end
 
     def strip_recipient body
-      body.gsub(/^@\w+\W*/, '')
+      body.gsub(/^@\p{Word}++[^\p{Word}]*/, '').strip
     end
 
     def mentions
       recipients[1..-1] || [] # TODO: Fix global message case
     end
+
+    def private?
+      room.nil?
+    end
   end
 end

data/lib/hipbot/patches/hipchat_client.rb

@@ -52,6 +52,10 @@ module Jabber
         @my_jid.resource
       end
 
+      def name= resource
+        @my_jid.resource = resource
+      end
+
       def on_presence(prio = 0, ref = nil, &block)
         @presence_cbs.add(prio, ref) do |room_jid, user_name, pres_type|
           block.call(room_jid, user_name, pres_type)
@@ -89,6 +93,30 @@ module Jabber
         @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
+
+      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)
+      end
+
       def send_message(type, jid, text, subject = nil)
         message = Message.new(JID.new(jid), text.to_s)
         message.type = type
@@ -112,6 +140,8 @@ module Jabber
           Jabber::debuglog "MUCBrowser initialized"
           @conference_domain = @muc_browser.muc_rooms(@chat_domain).keys.first
           Jabber::debuglog "No conference domain found" if !@conference_domain.present?
+          @roster = Roster::Helper.new(@stream) # TODO: Error handling
+          @vcard = Vcard::Helper.new(@stream) # TODO: Error handling
           true
         rescue => e
           Jabber::debuglog "Connection failed"
@@ -121,7 +151,7 @@ module Jabber
 
       def activate_callbacks
         @stream.add_presence_callback(150, self) { |presence|
-          @presence_cbs.process(presence.from.strip, presence.from.resource, presence.type.to_s)
+          @presence_cbs.process(presence.from.strip.to_s, presence.from.resource, presence.type.to_s)
         }
 
         @stream.add_message_callback(150, self) { |message|
@@ -141,7 +171,7 @@ module Jabber
             details = {}
             item.first.children.each{ |c| details[c.name] = c.text }
             rooms << {
-              :item => item,
+              :item    => item,
               :details => details
             }
           end
@@ -150,15 +180,23 @@ module Jabber
       end
 
       def get_users
-        roster = Roster::Helper.new(@stream) # TODO: Error handling
-        vcard = Vcard::Helper.new(@stream) # TODO: Error handling
-        roster.wait_for_roster
-        roster.items.map do |jid, item|
+        @roster.wait_for_roster
+        @roster.items.map do |jid, item|
           {
-            :item => item,
-            :vcard => vcard.get(jid)
+                jid: item.jid.to_s,
+               name: item.iname,
+            mention: item.attributes['mention_name'],
           }
-        end.compact
+        end
+      end
+
+      def get_user_details user_jid
+        vcard = @vcard.get(user_jid)
+        {
+          email: vcard['EMAIL/USERID'],
+          title: vcard['TITLE'],
+          photo: vcard['PHOTO'],
+        }
       end
 
       def deactivate_callbacks
@@ -173,11 +211,11 @@ module Jabber
         if is_invite?(message)
           room_name = message.children.last.first_element_text('name')
           topic = message.children.last.first_element_text('topic')
-          @invite_cbs.process(message.from.strip, message.from.resource, room_name, topic)
+          @invite_cbs.process(message.from.strip.to_s, message.from.resource, room_name, topic)
         elsif message.type == :chat
-          @private_message_cbs.process(message.from.strip, message)
+          @private_message_cbs.process(message.from.strip.to_s, message)
         elsif message.type == :groupchat
-          @message_cbs.process(message.from.strip, message.from.resource, message)
+          @message_cbs.process(message.from.strip.to_s, message.from.resource, message)
         elsif message.type == :error
           false
         end