hipbot 0.1.0 → 0.2.0

data/lib/hipbot/adapters/hipchat/hipchat.rb

@@ -2,16 +2,7 @@ module Hipbot
   module Adapters
     module Hipchat
       def start!
-        ::EM::run do
-          ::EM.error_handler do |e|
-            puts e.inspect
-            e.backtrace.each do |line|
-              puts line
-            end
-          end
-
-          Connection.new(self)
-        end
+        connection = Connection.new(self)
       end
 
       def method_missing(sym, *args, &block)

data/lib/hipbot/adapters/telnet/telnet.rb

@@ -6,9 +6,7 @@ module Hipbot
       end
 
       def start!
-        ::EM::run do
-          ::EM::connect('0.0.0.0', 3001, Connection, self)
-        end
+        ::EM::connect('0.0.0.0', 3001, Connection, self)
       end
     end
   end

data/lib/hipbot/bot.rb

@@ -1,64 +1,81 @@
 module Hipbot
-  class Bot
-    attr_accessor :reactions, :configuration, :connection
-    cattr_accessor :default_reaction
+  class Bot < Reactable
+    include Singleton
+    attr_accessor :configuration, :connection, :error_handler
 
-    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter, :helpers, :teams, :rooms]
+    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter, :helpers, :plugins, :teams, :rooms, :logger]
     delegate *CONFIGURABLE_OPTIONS, to: :configuration
     alias_method :to_s, :name
 
     def initialize
+      super
       self.configuration = Configuration.new.tap(&self.class.configuration)
-      self.reactions = []
-      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)
+      self.error_handler = self.class.error_handler
+      extend(self.adapter || Adapters::Hipchat)
     end
 
-    def on *regexps, &block
-      options = regexps[-1].kind_of?(Hash) ? regexps.pop : {}
-      self.reactions << Reaction.new(self, regexps, options, block)
+    def reactions
+      defined_reactions + plugin_reactions + default_reactions
     end
 
     def react sender, room, message
-      matches = matching_reactions(sender, room, message)
-      matches.first.invoke(sender, room, message) if matches.size > 0
+      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
     end
 
     class << self
-      def on *regexps, &block
-        @reactions ||= []
-        @reactions << [regexps, block]
-      end
+      ACCESSORS = { configure: :configuration, on_preload: :preloader, on_error: :error_handler }
 
-      def default &block
-        @@default_reaction = [[/(.*)/], block]
-      end
+      ACCESSORS.each do |setter, getter|
+        define_method(setter) do |&block|
+          instance_variable_set("@#{getter}", block)
+        end
 
-      def configure &block
-        @configuration = block
+        define_method(getter) do
+          instance_variable_get("@#{getter}") || Proc.new{}
+        end
       end
 
-      def reactions
-        @reactions || []
+      def start!
+        ::EM::run do
+          Jabber.debug = true
+          Jabber.logger = Hipbot::Bot.instance.logger
+          Helpers.module_exec(&preloader)
+          instance.start!
+        end
       end
+    end
 
-      def configuration
-        @configuration || Proc.new{}
-      end
+    def plugin_for(reaction)
+      included_plugins.find { |p| p.defined_reactions.include?(reaction) }
+    end
 
-      def start!
-        new.start!
+    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
       end
     end
 
-    private
+    def default_reactions
+      super + included_plugins.flat_map(&:default_reactions)
+    end
 
     def matching_reactions sender, room, message
-      self.reactions.select { |r| r.match?(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

@@ -13,8 +13,6 @@ module Hipbot
     end
 
     class << self
-      attr_accessor :bot
-
       def create *args, &block
         collection[args[0]] = new(*args, &block)
       end
@@ -28,7 +26,7 @@ module Hipbot
       end
 
       def find_one item
-        collection[item] || collection.find{ |_, i| i.name == item }.try(:last)
+        collection[item] || find{ |i| i.name == item }
       end
 
       def find_many *items
@@ -39,7 +37,7 @@ module Hipbot
       protected
 
       def method_missing name, *args, &block
-        return collection.public_send(name, *args, &block) if collection.respond_to?(name)
+        return collection.values.public_send(name, *args, &block) if Array.instance_methods.include?(name)
         super
       end
     end

data/lib/hipbot/configuration.rb

@@ -8,10 +8,8 @@ module Hipbot
       self.password = 'changeme'
       self.teams    = {}
       self.rooms    = {}
-    end
-
-    def helpers
-      @helpers ||= Module.new
+      self.helpers  = Module.new
+      self.logger   = Hipbot::Logger.new($stdout)
     end
   end
 end

data/lib/hipbot/helpers.rb

@@ -0,0 +1,40 @@
+module Hipbot
+  module Helpers
+    [:get, :post, :put, :delete].each do |http_verb|
+      define_method http_verb do |url, query = {}, &block|
+        Hipbot.logger.info("HTTP-REQUEST: #{url} #{query}")
+        query.merge!({ :head => {'accept-encoding' => 'gzip, compressed'} })
+        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)
+        end if block.present?
+        http.errback do
+          Hipbot.logger.error("HTTP-RESPONSE-ERROR: #{url}")
+        end
+      end
+
+      module_function http_verb
+    end
+
+    class HttpResponse < Struct.new(:raw_response)
+      def body
+        raw_response.response
+      end
+
+      def code
+        raw_response.response_header.status
+      end
+
+      def headers
+        raw_response.response_header
+      end
+
+      def json
+        @json ||= JSON.parse(body) rescue {}
+      end
+    end
+  end
+end

data/lib/hipbot/logger.rb

@@ -0,0 +1,15 @@
+require 'logger'
+
+module Hipbot
+  class Logger < ::Logger
+    def add(severity, message = nil, progname = nil, &block)
+      msg = message || (block_given? and block.call) || progname
+      severity_name = { 0 => "DEBUG", 1 => "INFO", 2 => "WARN", 3 => "ERROR", 4 => "FATAL", 5 => "UNKNOWN" }[severity]
+      super(severity, "[#{severity_name}][#{Time.now}] #{msg}")
+    end
+  end
+
+  def self.logger
+    Hipbot::Bot.instance.logger
+  end
+end

data/lib/hipbot/message.rb

@@ -22,7 +22,7 @@ module Hipbot
     end
 
     def mentions
-      recipients[1..-1] # TODO: Fix global message case
+      recipients[1..-1] || [] # TODO: Fix global message case
     end
   end
 end

data/lib/hipbot/patches/hipchat_client.rb

@@ -90,7 +90,7 @@ module Jabber
       end
 
       def send_message(type, jid, text, subject = nil)
-        message = Message.new(JID.new(jid), text)
+        message = Message.new(JID.new(jid), text.to_s)
         message.type = type
         message.from = @my_jid
         message.subject = subject

data/lib/hipbot/plugin.rb

@@ -0,0 +1,11 @@
+module Hipbot
+  class Plugin < Reactable
+    attr_accessor :bot
+
+    private
+
+    def reaction_target
+      bot
+    end
+  end
+end

data/lib/hipbot/reactable.rb

@@ -0,0 +1,60 @@
+module Hipbot
+  class Reactable
+    def on *regexps, &block
+      @defined_reactions ||= []
+      @defined_reactions << to_reaction(regexps, block)
+    end
+
+    def defined_reactions
+      @defined_reactions ||= []
+      @defined_reactions + class_reactions
+    end
+
+    def default_reactions
+      @default_reactions ||= begin
+        if reaction = self.class.default_reaction
+          [ to_reaction(reaction[0], reaction[-1]) ]
+        else
+          []
+        end
+      end
+    end
+
+    class << self
+      def on *regexps, &block
+        @reactions ||= []
+        @reactions << [regexps, block]
+      end
+
+      def reactions
+        @reactions || []
+      end
+
+      def default &block
+        @default_reaction = [[/(.*)/], block]
+      end
+
+      def default_reaction
+        @default_reaction
+      end
+    end
+
+    private
+
+    def class_reactions
+      @class_reactions ||= self.class.reactions.map do |opts|
+        to_reaction(opts[0], opts[-1])
+      end
+    end
+
+    def to_reaction(regexps, block)
+      regexps = regexps.dup
+      options = regexps[-1].kind_of?(Hash) ? regexps.pop : {}
+      Reaction.new(reaction_target, regexps, options, block)
+    end
+
+    def reaction_target
+      self
+    end
+  end
+end

data/lib/hipbot/reaction.rb

@@ -12,6 +12,10 @@ module Hipbot
       matches_regexp?(message) && matches_scope?(room, message) && matches_sender?(message) && matches_room?(room)
     end
 
+    def inspect
+      "#<Hipbot::Reaction #{regexps} #{options}>"
+    end
+
     protected
 
     def message_for message, sender
@@ -35,7 +39,8 @@ module Hipbot
     end
 
     def matches_room?(room)
-      !options[:room] || rooms.include?(room.name) || room.nil?
+      return true if options[:room].nil?
+      room.present? && (rooms.include?(room.name) || options[:room] == true)
     end
 
     def matches_sender?(message)

data/lib/hipbot/response.rb

@@ -1,6 +1,7 @@
 module Hipbot
   class Response < Struct.new(:bot, :reaction, :room, :message)
     delegate :sender, :recipients, :body, :to => :message
+    include Helpers
 
     def initialize bot, reaction, room, message
       super
@@ -9,20 +10,20 @@ module Hipbot
 
     def invoke arguments
       instance_exec(*arguments, &reaction.block)
+    rescue Exception => e
+      Hipbot.logger.error(e)
+      instance_exec(e, &bot.error_handler)
     end
 
     private
 
-    def reply string, room = self.room
-      return bot.send_to_user(sender, string) if room.nil?
-      bot.send_to_room(room, string)
+    def reply message, room = self.room
+      Hipbot.logger.info("REPLY in #{room}: #{message}")
+      room.nil? ? bot.send_to_user(sender, message) : bot.send_to_room(room, message)
     end
 
-    [:get, :post, :put, :delete].each do |http_verb|
-      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
+    def plugin
+      bot.plugin_for(reaction)
     end
   end
 end

data/lib/hipbot/room.rb

@@ -8,15 +8,15 @@ module Hipbot
     end
 
     def set_topic topic
-      self.class.bot.set_topic(self, topic)
+      Bot.instance.set_topic(self, topic)
     end
 
     def send_message message
-      self.class.bot.send_to_room(self, message)
+      Bot.instance.send_to_room(self, message)
     end
 
     def users
-      user_ids.map{ |id| User[id] }
+      User.find_many(user_ids)
     end
   end
 end

data/lib/hipbot/user.rb

@@ -1,7 +1,7 @@
 module Hipbot
   class User < Collection
     def send_message message
-      self.class.bot.send_to_user name, message
+      Bot.instance.send_to_user name, message
     end
 
     def first_name

data/lib/hipbot/version.rb

@@ -1,3 +1,3 @@
 module Hipbot
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/integration/hipbot_spec.rb

@@ -10,32 +10,54 @@ module HipbotHelpers
   end
 end
 
+class AwesomePlugin < Hipbot::Plugin
+  on /respond awesome/ do
+    reply("awesome responded")
+  end
+end
+
+class CoolPlugin < Hipbot::Plugin
+  on /respond cool/ do
+    reply("cool responded")
+  end
+end
+
 class MyHipbot < Hipbot::Bot
   configure do |config|
     config.name = 'robbot'
     config.jid = 'robbot@chat.hipchat.com'
     config.helpers = HipbotHelpers
+    config.plugins = [ AwesomePlugin, CoolPlugin.new ]
   end
 
   on /^hello hipbot!$/ do
     reply("hello!")
   end
+
   on /you're (.*), robot/ do |adj|
     reply("I know I'm #{adj}")
   end
+
   on /hi everyone!/, global: true do
     reply('hello!')
   end
+
   on /tell me the project name/ do
     reply(project_name)
   end
+
   on /tell me my name/ do
     reply("you are #{sender.first_name}")
   end
+
+  default do
+    reply("I didn't understand you")
+  end
 end
 
 describe MyHipbot do
-  # TODO: replace with actual objects
+  subject { described_class.instance }
+
   let(:room)   { Hipbot::Room.create('1', 'private', topic: 'topic') }
   let(:sender) { Hipbot::User.create('1', 'John Doe') }
 
@@ -64,6 +86,11 @@ describe MyHipbot do
       subject.expects(:send_to_room).with(room, "hello!")
       subject.react(sender, room, "hi everyone!")
     end
+
+    it "should respond with default reply" do
+      subject.expects(:send_to_room).with(room, "I didn't understand you")
+      subject.react(sender, room, "@robbot blahlblah")
+    end
   end
 
   describe "custom helpers" do
@@ -77,4 +104,16 @@ describe MyHipbot do
       subject.react(sender, room, '@robbot tell me my name')
     end
   end
+
+  describe "plugins" do
+    it "should reply to reaction defined in plugin" do
+      subject.expects(:send_to_room).with(room, 'awesome responded')
+      subject.react(sender, room, '@robbot respond awesome')
+    end
+
+    it "should reply to reaction defined in second plugin" do
+      subject.expects(:send_to_room).with(room, 'cool responded')
+      subject.react(sender, room, '@robbot respond cool')
+    end
+  end
 end