hipbot 0.0.3 → 0.0.5

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

@@ -0,0 +1,16 @@
+module Hipbot
+  module Adapters
+    module Telnet
+      def reply room, message
+        connection.send_data("#{self}:#{room}:#{message}\n")
+      end
+
+      def start!
+        ::EM::run do
+          ::EM::connect('0.0.0.0', 3001, Connection, self)
+        end
+      end
+    end
+  end
+end
+

data/lib/hipbot/bot.rb

@@ -1,7 +1,7 @@
 module Hipbot
   class Bot
     attr_accessor :reactions, :configuration, :connection
-    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter]
+    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter, :helpers]
     delegate *CONFIGURABLE_OPTIONS, to: :configuration
     alias_method :to_s, :name
 
@@ -9,20 +9,21 @@ module Hipbot
       self.configuration = Configuration.new.tap(&self.class.configuration)
       self.reactions = []
       self.class.reactions.each do |opts|
-        on(opts[0], opts[1], &opts[-1])
+        on(*opts[0], &opts[-1])
       end
       extend(self.adapter || ::Hipbot::Adapters::Hipchat)
     end
 
-    def on regexp, options={}, &block
-      self.reactions << Reaction.new(self, regexp, options, block)
+    def on *regexps, &block
+      options = regexps[-1].kind_of?(Hash) ? regexps.pop : {}
+      self.reactions << Reaction.new(self, regexps, options, block)
     end
 
     def tell sender, room, message
       return if sender == name
       matches = matching_reactions(sender, room, message)
       if matches.size > 0
-        matches[0].invoke(sender, room, message)
+        matches.first.invoke(sender, room, message)
       end
     end
 
@@ -32,9 +33,9 @@ module Hipbot
 
     class << self
 
-      def on regexp, options={}, &block
+      def on *regexps, &block
         @reactions ||= []
-        @reactions << [regexp, options, block]
+        @reactions << [regexps, block]
       end
 
       def configure &block
@@ -63,8 +64,8 @@ module Hipbot
     end
 
     def default_reaction
-      @default_reaction ||= Reaction.new(self, /.*/, {}, Proc.new {
-        reply("I don't understand \"#{message}\"")
+      @default_reaction ||= Reaction.new(self, [/.*/], {}, Proc.new {
+        reply("I don't understand \"#{message.body}\"")
       })
     end
 

data/lib/hipbot/configuration.rb

@@ -8,5 +8,8 @@ module Hipbot
       self.password = 'changeme'
     end
 
+    def helpers
+      @helpers ||= Module.new
+    end
   end
 end

data/lib/hipbot/http_response.rb

@@ -0,0 +1,15 @@
+module Hipbot
+  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
+  end
+end

data/lib/hipbot/message.rb

@@ -9,7 +9,7 @@ module Hipbot
 
     def recipients
       results = raw_body.scan(/@(\w+)/) + raw_body.scan(/@"(.*)"/)
-      results.flatten
+      results.flatten.uniq
     end
 
     def for? recipient
@@ -19,5 +19,13 @@ module Hipbot
     def strip_recipient body
       body.gsub(/^@\w+\W*/, '')
     end
+
+    def sender_name
+      sender.split.first
+    end
+
+    def mentions
+      recipients[1..-1]
+    end
   end
 end

data/lib/hipbot/patches/mucclient.rb

@@ -0,0 +1,147 @@
+module Jabber
+  module MUC
+
+    class MUCClient
+
+      def join(jid, password=nil, opts={})
+        if active?
+          raise "MUCClient already active"
+        end
+
+        @jid = (jid.kind_of?(JID) ? jid : JID.new(jid))
+        activate
+
+        # Joining
+        pres = Presence.new
+        pres.to = @jid
+        pres.from = @my_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
+
+        pres.add(xmuc)
+
+        # We don't use Stream#send_with_id here as it's unknown
+        # if the MUC component *always* uses our stanza id.
+        error = nil
+        @stream.send(pres) { |r|
+          if from_room?(r.from) and r.kind_of?(Presence) and r.type == :error
+            # Error from room
+            error = r.error
+            true
+          # type='unavailable' may occur when the MUC kills our previous instance,
+          # but all join-failures should be type='error'
+          elsif r.from == jid and r.kind_of?(Presence) and r.type != :unavailable
+            # Our own presence reflected back - success
+            if r.x(XMUCUser) and (i = r.x(XMUCUser).items.first)
+              @affiliation = i.affiliation  # we're interested in if it's :owner
+              @role = i.role                # :moderator ?
+            end
+
+            handle_presence(r, false)
+            true
+          else
+            # Everything else
+            false
+          end
+        }
+
+        if error
+          deactivate
+          raise ServerError.new(error)
+        end
+
+        self
+      end
+
+      private
+      def activate  # :nodoc:
+        @active = true
+
+        # Callbacks
+        @stream.add_presence_callback(150, self) { |presence|
+          if from_room?(presence.from)
+            handle_presence(presence)
+            true
+          else
+            false
+          end
+        }
+
+        @stream.add_message_callback(150, self) { |message|
+          # Not sure if this was hipchat or client bug,
+          # but this callback didn't allow chat (private) messages since
+          # they don't belong to any conference room
+          if from_room?(message.from) || is_chat?(message.type)
+            handle_message(message)
+            true
+          else
+            false
+          end
+        }
+      end
+
+      def is_chat?(type)
+        type == :chat
+      end
+
+      def send(stanza, to = nil)
+        if stanza.kind_of? Message
+          stanza.type = to || stanza.to ? :chat : :groupchat
+        end
+        stanza.from = @my_jid
+        # We don't want to override existing message JID
+        stanza.to = JID.new(jid.node, jid.domain, to) if stanza.to.nil?
+        @stream.send(stanza)
+      end
+
+    end
+
+    class SimpleMUCClient < MUCClient
+
+      def say(text, jid = nil)
+        send(Message.new(jid, text))
+      end
+
+      private
+
+      def handle_message(msg)
+        super
+
+        time = Time.now # Hipchat doesn't provide time stamp for message elements
+        msg.each_element('x') { |x|
+          if x.kind_of?(Delay::XDelay)
+            time = x.stamp
+          end
+        }
+        sender_nick = msg.from.resource
+
+
+        if msg.subject
+          @subject = msg.subject
+          @subject_block.call(time, sender_nick, @subject) if @subject_block
+        end
+
+        if msg.body
+          if sender_nick.nil?
+            @room_message_block.call(time, msg.body) if @room_message_block
+          else
+            if msg.type == :chat
+              # We need to send full jid here (msg.from)
+              @private_message_block.call(time, msg.from, msg.body) if @private_message_block
+            elsif msg.type == :groupchat
+              @message_block.call(time, msg.from.resource, msg.body) if @message_block
+            else
+              # ...?
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hipbot/reaction.rb

@@ -1,5 +1,5 @@
 module Hipbot
-  class Reaction < Struct.new(:robot, :regexp, :options, :block)
+  class Reaction < Struct.new(:robot, :regexps, :options, :block)
 
     def invoke sender, room, message
       message = message_for(message, sender)
@@ -9,21 +9,26 @@ module Hipbot
 
     def match? sender, room, message
       message = message_for(message, sender)
-      matches?(message) && matches_scope?(message) && matches_sender?(message)
+      matches_regexp?(message) && matches_scope?(message) && matches_sender?(message) && matches_room?(room)
     end
 
     private
 
+    # 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(regexp)[1..-1]
+      message.body.match(matching_regexp(message))[1..-1]
     end
 
-    def matches?(message)
-      regexp =~ message.body
+    def matches_regexp?(message)
+      matching_regexp(message).present?
+    end
+
+    def matches_room?(room)
+      !options[:room] || Array(options[:room]).include?(room.name)
     end
 
     def matches_scope?(message)
@@ -34,6 +39,10 @@ module Hipbot
       from_all? || Array(options[:from]).include?(message.sender)
     end
 
+    def matching_regexp(message)
+      regexps.find { |regexp| regexp =~ message.body }
+    end
+
     def global?
       options[:global]
     end
@@ -41,6 +50,5 @@ module Hipbot
     def from_all?
       !options[:from]
     end
-
   end
 end

data/lib/hipbot/response.rb

@@ -1,36 +1,28 @@
 module Hipbot
-  class Response < Struct.new(:bot, :reaction, :room, :message_object)
+  class Response < Struct.new(:bot, :reaction, :room, :message)
+    delegate :sender, :recipients, :body, :to => :message
+
+    def initialize bot, reaction, room, message
+      super
+      extend(bot.helpers)
+    end
 
     def invoke arguments
       instance_exec(*arguments, &reaction.block)
     end
 
     private
-    def reply string
+
+    def reply string, room = self.room
       bot.reply(room, string)
     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(http) if block }
+        http.callback { block.call(::Hipbot::HttpResponse.new(http)) if block }
       end
     end
 
-    def first_name
-      message_object.sender.split(' ').first
-    end
-
-    def message
-      message_object.body
-    end
-
-    def sender
-      message_object.sender
-    end
-
-    def recipients
-      message_object.recipients
-    end
   end
 end

data/lib/hipbot/room.rb

@@ -1,10 +1,7 @@
 module Hipbot
   class Room < Struct.new(:jid, :name)
-    attr_accessor :connection
-
-    def to_s
-      name
-    end
+    attr_accessor :connection, :users
+    alias_method :to_s, :name
 
   end
 end

data/lib/hipbot/version.rb

@@ -1,3 +1,3 @@
 module Hipbot
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

data/spec/integration/hipbot_spec.rb

@@ -1,9 +1,20 @@
 require 'spec_helper'
 
+module HipbotHelpers
+  def project_name
+    "#{room.name} project"
+  end
+
+  def sender_first_name
+    "you are #{message.sender.split[0]}"
+  end
+end
+
 class MyHipbot < Hipbot::Bot
   configure do |config|
     config.name = 'robbot'
     config.jid = 'robbot@chat.hipchat.com'
+    config.helpers = HipbotHelpers
   end
 
   on /^hello hipbot!$/ do
@@ -15,9 +26,19 @@ class MyHipbot < Hipbot::Bot
   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(sender_first_name)
+  end
 end
 
 describe MyHipbot do
+  # TODO: replace with actual objects
+  let(:room) { Hipbot::Room.new('123', 'private') }
+  let(:sender) { 'John Doe' }
+
   describe "configuration" do
     it "should set robot name" do
       subject.name.should == 'robbot'
@@ -29,10 +50,6 @@ describe MyHipbot do
   end
 
   describe "replying" do
-    # TODO: replace with actual objects
-    let(:room) { stub_everything }
-    let(:sender) { stub_everything }
-
     it "should reply to hello" do
       subject.expects(:reply).with(room, 'hello!')
       subject.tell(sender, room, '@robbot hello hipbot!')
@@ -48,4 +65,16 @@ describe MyHipbot do
       subject.tell(sender, room, "hi everyone!")
     end
   end
+
+  describe "custom helpers" do
+    it "should have access to room variable" do
+      subject.expects(:reply).with(room, 'private project')
+      subject.tell(sender, room, '@robbot tell me the project name')
+    end
+
+    it "should have access to message variable" do
+      subject.expects(:reply).with(room, 'you are John')
+      subject.tell(sender, room, '@robbot tell me my name')
+    end
+  end
 end