hipbot 0.0.5 → 0.1.0

data/lib/hipbot/bot.rb

@@ -1,7 +1,9 @@
 module Hipbot
   class Bot
     attr_accessor :reactions, :configuration, :connection
-    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter, :helpers]
+    cattr_accessor :default_reaction
+
+    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter, :helpers, :teams, :rooms]
     delegate *CONFIGURABLE_OPTIONS, to: :configuration
     alias_method :to_s, :name
 
@@ -11,6 +13,7 @@ module Hipbot
       self.class.reactions.each do |opts|
         on(*opts[0], &opts[-1])
       end
+      on(*default_reaction[0], &default_reaction[-1]) if default_reaction.present?
       extend(self.adapter || ::Hipbot::Adapters::Hipchat)
     end
 
@@ -19,25 +22,21 @@ module Hipbot
       self.reactions << Reaction.new(self, regexps, options, block)
     end
 
-    def tell sender, room, message
-      return if sender == name
+    def react sender, room, message
       matches = matching_reactions(sender, room, message)
-      if matches.size > 0
-        matches.first.invoke(sender, room, message)
-      end
-    end
-
-    def reactions_list
-      self.reactions.regexp
+      matches.first.invoke(sender, room, message) if matches.size > 0
     end
 
     class << self
-
       def on *regexps, &block
         @reactions ||= []
         @reactions << [regexps, block]
       end
 
+      def default &block
+        @@default_reaction = [[/(.*)/], block]
+      end
+
       def configure &block
         @configuration = block
       end
@@ -53,20 +52,12 @@ module Hipbot
       def start!
         new.start!
       end
-
     end
 
     private
 
     def matching_reactions sender, room, message
-      all_reactions = reactions + [default_reaction]
-      all_reactions.select { |r| r.match?(sender, room, message) }
-    end
-
-    def default_reaction
-      @default_reaction ||= Reaction.new(self, [/.*/], {}, Proc.new {
-        reply("I don't understand \"#{message.body}\"")
-      })
+      self.reactions.select { |r| r.match?(sender, room, message) }
     end
 
   end

data/lib/hipbot/collection.rb

@@ -0,0 +1,48 @@
+module Hipbot
+  class Collection < Struct.new(:id, :name, :params)
+    private_class_method :new
+    alias_method :to_s, :name
+
+    def initialize *args
+      super
+      self.params = OpenStruct.new(params)
+    end
+
+    def delete
+      self.class.collection.delete(self.id)
+    end
+
+    class << self
+      attr_accessor :bot
+
+      def create *args, &block
+        collection[args[0]] = new(*args, &block)
+      end
+
+      def collection
+        @collection ||= {}
+      end
+
+      def [] *items
+        items.first.is_a?(Array) ? find_many(*items) : find_one(items.first)
+      end
+
+      def find_one item
+        collection[item] || collection.find{ |_, i| i.name == item }.try(:last)
+      end
+
+      def find_many *items
+        items.flatten!
+        items.map{ |i| find_one(i) }.compact.uniq
+      end
+
+      protected
+
+      def method_missing name, *args, &block
+        return collection.public_send(name, *args, &block) if collection.respond_to?(name)
+        super
+      end
+    end
+  end
+end
+

data/lib/hipbot/configuration.rb

@@ -3,9 +3,11 @@ module Hipbot
     attr_accessor *Bot::CONFIGURABLE_OPTIONS
 
     def initialize
-      self.name = 'robot'
-      self.jid = 'changeme'
+      self.name     = 'robot'
+      self.jid      = 'changeme'
       self.password = 'changeme'
+      self.teams    = {}
+      self.rooms    = {}
     end
 
     def helpers

data/lib/hipbot/message.rb

@@ -1,10 +1,11 @@
 module Hipbot
   class Message
-    attr_accessor :body, :sender, :raw_body
+    attr_reader :body, :sender, :raw_body
+
     def initialize body, sender
-      self.raw_body = body
-      self.body = strip_recipient(body)
-      self.sender = sender
+      @raw_body = body
+      @body     = strip_recipient(body)
+      @sender   = sender
     end
 
     def recipients
@@ -20,12 +21,8 @@ module Hipbot
       body.gsub(/^@\w+\W*/, '')
     end
 
-    def sender_name
-      sender.split.first
-    end
-
     def mentions
-      recipients[1..-1]
+      recipients[1..-1] # TODO: Fix global message case
     end
   end
 end

data/lib/hipbot/patches/hipchat_client.rb

@@ -0,0 +1,192 @@
+require 'xmpp4r/muc/x/muc'
+require 'xmpp4r/muc/iq/mucowner'
+require 'xmpp4r/muc/iq/mucadmin'
+require 'xmpp4r/dataforms'
+require 'xmpp4r/roster'
+require 'xmpp4r/vcard'
+
+module Jabber
+  module MUC
+    class HipchatClient
+
+      def initialize(jid)
+        @my_jid  = JID.new(jid)
+
+        @stream = Client.new(@my_jid.strip) # TODO: Error Handling
+        Jabber::debuglog "Stream initialized"
+        @chat_domain = @my_jid.domain
+
+        @presence_cbs = CallbackList.new
+        @message_cbs = CallbackList.new
+        @private_message_cbs = CallbackList.new
+        @invite_cbs = CallbackList.new
+      end
+
+      def join(jid, password = nil, opts = { :history => false })
+        room_jid = JID.new(jid)
+        xmuc = XMUC.new
+        xmuc.password = password
+
+        if !opts[:history]
+          history = REXML::Element.new('history').tap{ |h| h.add_attribute('maxstanzas','0') }
+          xmuc.add_element history
+        end
+
+        room_jid.resource = name
+        set_presence(:available, room_jid, nil, xmuc) # TODO: Handle all join responses
+      end
+
+      def exit(jid, reason = nil)
+        room_jid = JID.new(jid)
+        Jabber::debuglog "Exiting #{jid}"
+        set_presence(:unavailable, room_jid, reason)
+      end
+
+      def keep_alive password
+        if @stream.is_disconnected?
+          connect(password)
+        end
+      end
+
+      def name
+        @my_jid.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)
+          false
+        end
+      end
+
+      def on_message(prio = 0, ref = nil, &block)
+        @message_cbs.add(prio, ref) do |room_jid, user_name, message|
+          block.call(room_jid, user_name, message)
+          false
+        end
+      end
+
+      def on_private_message(prio = 0, ref = nil, &block)
+        @private_message_cbs.add(prio, ref) do |user_jid, message|
+          block.call(user_jid, message)
+          false
+        end
+      end
+
+      def on_invite(prio = 0, ref = nil, &block)
+        @invite_cbs.add(prio, ref) do |room_jid, user_name, room_name, topic|
+          block.call(room_jid, user_name, room_name, topic)
+          false
+        end
+      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 send_message(type, jid, text, subject = nil)
+        message = Message.new(JID.new(jid), text)
+        message.type = type
+        message.from = @my_jid
+        message.subject = subject
+
+        @send_thread.join if @send_thread.present? && @send_thread.alive?
+        @send_thread = Thread.new {
+          @stream.send(message)
+          sleep(0.2)
+        }
+      end
+
+      def connect password
+        begin
+          @stream.connect
+          Jabber::debuglog "Connected to stream"
+          @stream.auth(password)
+          Jabber::debuglog "Authenticated"
+          @muc_browser = MUCBrowser.new(@stream)
+          Jabber::debuglog "MUCBrowser initialized"
+          @conference_domain = @muc_browser.muc_rooms(@chat_domain).keys.first
+          Jabber::debuglog "No conference domain found" if !@conference_domain.present?
+          true
+        rescue => e
+          Jabber::debuglog "Connection failed"
+          false
+        end
+      end
+
+      def activate_callbacks
+        @stream.add_presence_callback(150, self) { |presence|
+          @presence_cbs.process(presence.from.strip, presence.from.resource, presence.type.to_s)
+        }
+
+        @stream.add_message_callback(150, self) { |message|
+          handle_message(message)
+        }
+        Jabber::debuglog "Callbacks activated"
+      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
+            }
+          end
+        end
+        rooms
+      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|
+          {
+            :item => item,
+            :vcard => vcard.get(jid)
+          }
+        end.compact
+      end
+
+      def deactivate_callbacks
+        @stream.delete_presence_callback(self)
+        @stream.delete_message_callback(self)
+        Jabber::debuglog "Callbacks deactivated"
+      end
+
+      private
+
+      def handle_message(message)
+        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)
+        elsif message.type == :chat
+          @private_message_cbs.process(message.from.strip, message)
+        elsif message.type == :groupchat
+          @message_cbs.process(message.from.strip, message.from.resource, message)
+        elsif message.type == :error
+          false
+        end
+      end
+
+      def is_invite?(message)
+        !message.x.nil? && message.x.kind_of?(XMUCUser) && message.x.first.kind_of?(XMUCUserInvite)
+      end
+
+    end
+  end
+end

data/lib/hipbot/reaction.rb

@@ -1,54 +1,61 @@
 module Hipbot
-  class Reaction < Struct.new(:robot, :regexps, :options, :block)
+  class Reaction < Struct.new(:bot, :regexps, :options, :block)
 
     def invoke sender, room, message
-      message = message_for(message, sender)
+      message   = message_for(message, sender)
       arguments = arguments_for(message)
-      Response.new(robot, self, room, message).invoke(arguments)
+      Response.new(bot, self, room, message).invoke(arguments)
     end
 
     def match? sender, room, message
       message = message_for(message, sender)
-      matches_regexp?(message) && matches_scope?(message) && matches_sender?(message) && matches_room?(room)
+      matches_regexp?(message) && matches_scope?(room, message) && matches_sender?(message) && matches_room?(room)
     end
 
-    private
+    protected
 
-    # TODO: this is pointless since we can get actual message object from xmpp4r
     def message_for message, sender
       Message.new(message, sender)
     end
 
     def arguments_for message
-      message.body.match(matching_regexp(message))[1..-1]
+      (global? ? message.raw_body : message.body).match(matching_regexp(message))[1..-1]
     end
 
     def matches_regexp?(message)
       matching_regexp(message).present?
     end
 
-    def matches_room?(room)
-      !options[:room] || Array(options[:room]).include?(room.name)
+    def matching_regexp(message)
+      regexps.find{ |regexp| regexp =~ (global? ? message.raw_body : message.body) }
     end
 
-    def matches_scope?(message)
-      global? || message.for?(robot)
+    def matches_scope?(room, message)
+      global? || message.for?(bot) || room.nil?
     end
 
-    def matches_sender?(message)
-      from_all? || Array(options[:from]).include?(message.sender)
+    def matches_room?(room)
+      !options[:room] || rooms.include?(room.name) || room.nil?
     end
 
-    def matching_regexp(message)
-      regexps.find { |regexp| regexp =~ message.body }
+    def matches_sender?(message)
+      from_all? || users.include?(message.sender.name)
     end
 
     def global?
-      options[:global]
+      !!options[:global]
     end
 
     def from_all?
-      !options[:from]
+      options[:from].blank?
+    end
+
+    def rooms
+      Array(options[:room]).flat_map{ |v| bot.rooms[v].presence || [v] }
+    end
+
+    def users
+      Array(options[:from]).flat_map{ |v| bot.teams[v].presence || [v] }
     end
   end
 end

data/lib/hipbot/response.rb

@@ -14,15 +14,15 @@ module Hipbot
     private
 
     def reply string, room = self.room
-      bot.reply(room, string)
+      return bot.send_to_user(sender, string) if room.nil?
+      bot.send_to_room(room, string)
     end
 
     [:get, :post, :put, :delete].each do |http_verb|
-      define_method http_verb do |url, query={}, &block|
+      define_method http_verb do |url, query = {}, &block|
         http = ::EM::HttpRequest.new(url).send(http_verb, :query => query)
         http.callback { block.call(::Hipbot::HttpResponse.new(http)) if block }
       end
     end
-
   end
 end