hipbot 0.0.5 → 0.1.0

data/lib/hipbot/room.rb

@@ -1,7 +1,22 @@
 module Hipbot
-  class Room < Struct.new(:jid, :name)
-    attr_accessor :connection, :users
-    alias_method :to_s, :name
+  class Room < Collection
+    attr_accessor :user_ids
 
+    def initialize *args
+      super
+      self.user_ids = []
+    end
+
+    def set_topic topic
+      self.class.bot.set_topic(self, topic)
+    end
+
+    def send_message message
+      self.class.bot.send_to_room(self, message)
+    end
+
+    def users
+      user_ids.map{ |id| User[id] }
+    end
   end
 end

data/lib/hipbot/user.rb

@@ -0,0 +1,11 @@
+module Hipbot
+  class User < Collection
+    def send_message message
+      self.class.bot.send_to_user name, message
+    end
+
+    def first_name
+      name.split.first
+    end
+  end
+end

data/lib/hipbot/version.rb

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

data/spec/integration/hipbot_spec.rb

@@ -30,14 +30,14 @@ class MyHipbot < Hipbot::Bot
     reply(project_name)
   end
   on /tell me my name/ do
-    reply(sender_first_name)
+    reply("you are #{sender.first_name}")
   end
 end
 
 describe MyHipbot do
   # TODO: replace with actual objects
-  let(:room) { Hipbot::Room.new('123', 'private') }
-  let(:sender) { 'John Doe' }
+  let(:room)   { Hipbot::Room.create('1', 'private', topic: 'topic') }
+  let(:sender) { Hipbot::User.create('1', 'John Doe') }
 
   describe "configuration" do
     it "should set robot name" do
@@ -51,30 +51,30 @@ describe MyHipbot do
 
   describe "replying" do
     it "should reply to hello" do
-      subject.expects(:reply).with(room, 'hello!')
-      subject.tell(sender, room, '@robbot hello hipbot!')
+      subject.expects(:send_to_room).with(room, 'hello!')
+      subject.react(sender, room, '@robbot hello hipbot!')
     end
 
     it "should reply with argument" do
-      subject.expects(:reply).with(room, "I know I'm cool")
-      subject.tell(sender, room, "@robbot you're cool, robot")
+      subject.expects(:send_to_room).with(room, "I know I'm cool")
+      subject.react(sender, room, "@robbot you're cool, robot")
     end
 
     it "should reply to global message" do
-      subject.expects(:reply).with(room, "hello!")
-      subject.tell(sender, room, "hi everyone!")
+      subject.expects(:send_to_room).with(room, "hello!")
+      subject.react(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')
+      subject.expects(:send_to_room).with(room, 'private project')
+      subject.react(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')
+      subject.expects(:send_to_room).with(room, 'you are John')
+      subject.react(sender, room, '@robbot tell me my name')
     end
   end
 end

data/spec/unit/hipbot_spec.rb

@@ -2,46 +2,47 @@ require 'spec_helper'
 
 describe Hipbot::Bot do
   context "#on" do
-    let(:sender) { stub_everything }
-    let(:room) { stub_everything }
+    let(:sender) { stub_everything(name: 'Tom Smith') }
+    let(:room)   { stub_everything }
 
     it "should reply to no arguments" do
       subject.on /^hello there$/ do
         reply('hi!')
       end
-      subject.expects(:reply).with(room, 'hi!')
-      subject.tell(sender, room, '@robot hello there')
+      subject.expects(:send_to_room).with(room, 'hi!')
+      subject.react(sender, room, '@robot hello there')
     end
 
     it "should reply with one argument" do
       subject.on /^you are (.*), robot$/ do |adj|
         reply("i know i'm #{adj}!")
       end
-      subject.expects(:reply).with(room, "i know i'm cool!")
-      subject.tell(sender, room, '@robot you are cool, robot')
+      subject.expects(:send_to_room).with(room, "i know i'm cool!")
+      subject.react(sender, room, '@robot you are cool, robot')
     end
 
     it "should reply with multiple arguments" do
       subject.on /^send "(.*)" to (.*@.*)$/ do |message, recipient|
         reply("sent \"#{message}\" to #{recipient}")
       end
-      subject.expects(:reply).with(room, 'sent "hello!" to robot@robots.org')
-      subject.tell(sender, room, '@robot send "hello!" to robot@robots.org')
+      subject.expects(:send_to_room).with(room, 'sent "hello!" to robot@robots.org')
+      subject.react(sender, room, '@robot send "hello!" to robot@robots.org')
     end
 
     it "should say when does not understand" do
-      subject.on /^hello there$/ do
-        reply('hi!')
+      Hipbot::Bot.default do |message|
+        reply("I don't understand \"#{message}\"")
       end
-      subject.expects(:reply).with(room, 'I don\'t understand "hello robot!"')
-      subject.tell(sender, room, '@robot hello robot!')
+      subject.expects(:send_to_room).with(room, 'I don\'t understand "hello robot!"')
+      subject.react(sender, room, '@robot hello robot!')
+      Hipbot::Bot.class_variable_set :@@default_reaction, nil
     end
 
     it "should choose first option when multiple options match" do
       subject.on /hello there/ do reply('hello there') end
       subject.on /hello (.*)/ do reply('hello') end
-      subject.expects(:reply).with(room, 'hello there')
-      subject.tell(sender, room, '@robot hello there')
+      subject.expects(:send_to_room).with(room, 'hello there')
+      subject.react(sender, room, '@robot hello there')
     end
 
     context "multiple regexps" do
@@ -52,18 +53,18 @@ describe Hipbot::Bot do
       end
 
       it "should understand simple english" do |msg|
-        subject.expects(:reply).with(room, 'hello tom')
-        subject.tell(sender, room, '@robot hello tom')
+        subject.expects(:send_to_room).with(room, 'hello tom')
+        subject.react(sender, room, '@robot hello tom')
       end
 
       it "should understand english" do |msg|
-        subject.expects(:reply).with(room, 'hello tom')
-        subject.tell(sender, room, '@robot good morning tom')
+        subject.expects(:send_to_room).with(room, 'hello tom')
+        subject.react(sender, room, '@robot good morning tom')
       end
 
       it "should understand german" do |msg|
-        subject.expects(:reply).with(room, 'hello tom')
-        subject.tell(sender, room, '@robot guten tag tom')
+        subject.expects(:send_to_room).with(room, 'hello tom')
+        subject.react(sender, room, '@robot guten tag tom')
       end
     end
 
@@ -72,122 +73,125 @@ describe Hipbot::Bot do
         subject.on /^you are (.*)$/, global: true do |adj|
           reply("i know i'm #{adj}!")
         end
-        subject.expects(:reply).with(room, "i know i'm cool!")
-        subject.tell(sender, room, 'you are cool')
+        subject.expects(:send_to_room).with(room, "i know i'm cool!")
+        subject.react(sender, room, 'you are cool')
       end
 
       it "should not reply if callback not global" do
         subject.on /^you are (.*)$/ do |adj|
           reply("i know i'm #{adj}!")
         end
-        subject.expects(:reply).never
-        subject.tell(sender, room, 'you are cool')
+        subject.expects(:send_to_room).never
+        subject.react(sender, room, 'you are cool')
       end
     end
 
     context "messages from particular sender" do
+      let(:other_user) { stub(name: "John") }
       it "should reply" do
-        subject.on /wazzup\?/, from: sender do
+        subject.on /wazzup\?/, from: sender.name do
           reply('Wazzup, Tom?')
         end
-        subject.expects(:reply).with(room, 'Wazzup, Tom?')
-        subject.tell(sender, room, '@robot wazzup?')
+        subject.expects(:send_to_room).with(room, 'Wazzup, Tom?')
+        subject.react(sender, room, '@robot wazzup?')
       end
       it "should reply if sender acceptable" do
-        subject.on /wazzup\?/, from: [stub, sender] do
+        subject.on /wazzup\?/, from: [stub, sender.name] do
           reply('wazzup, tom?')
         end
-        subject.expects(:reply).with(room, 'wazzup, tom?')
-        subject.tell(sender, room, '@robot wazzup?')
+        subject.expects(:send_to_room).with(room, 'wazzup, tom?')
+        subject.react(sender, room, '@robot wazzup?')
       end
       it "should not reply if sender unacceptable" do
-        subject.on /wazzup\?/, from: sender do
+        subject.on /wazzup\?/, from: sender.name do
           reply('wazzup, tom?')
         end
-        subject.expects(:reply).with(room, "I don't understand \"wazzup?\"")
-        subject.tell(stub, room, '@robot wazzup?')
+        subject.expects(:send_to_room).never
+        subject.react(other_user, room, '@robot wazzup?')
       end
       it "should not reply if sender does not match" do
-        subject.on /wazzup\?/, from: [sender] do
+        subject.on /wazzup\?/, from: [sender.name] do
           reply('wazzup, tom?')
         end
-        subject.expects(:reply).with(room, "I don't understand \"wazzup?\"")
-        subject.tell(stub, room, '@robot wazzup?')
+        subject.expects(:send_to_room).never
+        subject.react(other_user, room, '@robot wazzup?')
       end
     end
 
     context "messages in particular room" do
-      let(:room) { stub(:name => 'room') }
+      let(:room)       { stub(:name => 'room') }
       let(:other_room) { stub(:name => 'other_room') }
       it "should reply" do
         subject.on /wazzup\?/, room: 'room' do
           reply('Wazzup, Tom?')
         end
-        subject.expects(:reply).with(room, 'Wazzup, Tom?')
-        subject.tell(sender, room, '@robot wazzup?')
+        subject.expects(:send_to_room).with(room, 'Wazzup, Tom?')
+        subject.react(sender, room, '@robot wazzup?')
       end
       it "should reply if room acceptable" do
         subject.on /wazzup\?/, room: ['other_room', 'room'] do
           reply('wazzup, tom?')
         end
-        subject.expects(:reply).with(room, 'wazzup, tom?')
-        subject.tell(sender, room, '@robot wazzup?')
+        subject.expects(:send_to_room).with(room, 'wazzup, tom?')
+        subject.react(sender, room, '@robot wazzup?')
       end
       it "should not reply if room unacceptable" do
         subject.on /wazzup\?/, room: 'room' do
           reply('wazzup, tom?')
         end
-        subject.expects(:reply).with(other_room, "I don't understand \"wazzup?\"")
-        subject.tell(sender, other_room, '@robot wazzup?')
+        subject.expects(:send_to_room).never
+        subject.react(sender, other_room, '@robot wazzup?')
       end
       it "should not reply if room does not match" do
         subject.on /wazzup\?/, room: ['other_room'] do
           reply('wazzup, tom?')
         end
-        subject.expects(:reply).with(room, "I don't understand \"wazzup?\"")
-        subject.tell(sender, room, '@robot wazzup?')
+        subject.expects(:send_to_room).never
+        subject.react(sender, room, '@robot wazzup?')
       end
     end
 
     context "response helper" do
+      let(:user){ stub(name: 'Tom Smith', first_name: 'Tom') }
+
       it "message" do
         subject.on /.*/ do
           reply("you said: #{message.body}")
         end
-        subject.expects(:reply).with(room, "you said: hello")
-        subject.tell(stub, room, "@robot hello")
+        subject.expects(:send_to_room).with(room, "you said: hello")
+        subject.react(user, room, "@robot hello")
       end
 
       it "sender" do
         subject.on /.*/ do
-          reply("you are: #{sender}")
+          reply("you are: #{sender.name}")
         end
-        subject.expects(:reply).with(room, "you are: tom")
-        subject.tell('tom', room, "@robot hello")
+        subject.expects(:send_to_room).with(room, "you are: Tom Smith")
+        subject.react(user, room, "@robot hello")
       end
 
       it "recipients" do
         subject.on /.*/ do
           reply("recipients: #{message.recipients.join(', ')}")
         end
-        subject.expects(:reply).with(room, "recipients: robot, dave")
-        subject.tell('tom', room, "@robot tell @dave hello from me")
+        subject.expects(:send_to_room).with(room, "recipients: robot, dave")
+        subject.react(user, room, "@robot tell @dave hello from me")
       end
 
       it "sender name" do
         subject.on /.*/ do
-          reply(message.sender_name)
+          reply(message.sender.first_name)
         end
-        subject.expects(:reply).with(room, 'Tom')
-        subject.tell('Tom Smith', room, '@robot What\'s my name?')
+        subject.expects(:send_to_room).with(room, 'Tom')
+        subject.react(user, room, '@robot What\'s my name?')
       end
 
       it "mentions" do
         subject.on /.*/ do
           reply(message.mentions.join(' '))
         end
-        subject.expects(:reply).with(room, 'dave rachel')
-        subject.tell('Tom Smith', room, '@robot do you know @dave? @dave is @rachel father')
+        subject.expects(:send_to_room).with(room, 'dave rachel')
+        subject.react(user, room, '@robot do you know @dave? @dave is @rachel father')
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hipbot
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-29 00:00:00.000000000 Z
+date: 2013-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daemons
@@ -155,6 +155,8 @@ files:
 - README.md
 - Rakefile
 - bin/hipbot
+- examples/cleverbot.rb
+- examples/google_images.rb
 - hipbot.gemspec
 - lib/hipbot.rb
 - lib/hipbot/adapters/hipchat/connection.rb
@@ -162,14 +164,16 @@ files:
 - lib/hipbot/adapters/telnet/connection.rb
 - lib/hipbot/adapters/telnet/telnet.rb
 - lib/hipbot/bot.rb
+- lib/hipbot/collection.rb
 - lib/hipbot/configuration.rb
 - lib/hipbot/http_response.rb
 - lib/hipbot/message.rb
 - lib/hipbot/patches/encoding.rb
-- lib/hipbot/patches/mucclient.rb
+- lib/hipbot/patches/hipchat_client.rb
 - lib/hipbot/reaction.rb
 - lib/hipbot/response.rb
 - lib/hipbot/room.rb
+- lib/hipbot/user.rb
 - lib/hipbot/version.rb
 - spec/integration/hipbot_spec.rb
 - spec/spec_helper.rb

data/lib/hipbot/patches/mucclient.rb

@@ -1,147 +0,0 @@
-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