hipbot 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,16 @@
+source :rubygems
+
+gem 'rake'
+gem 'eventmachine'
+gem 'em-http-request'
+gem 'xmpp4r'
+gem 'httparty'
+gem 'active_support'
+gem 'i18n'
+gem 'daemons'
+
+gem 'rspec'
+gem 'mocha'
+
+# Plugins
+gem 'google-weather'

data/Gemfile.lock

@@ -0,0 +1,50 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    active_support (3.0.0)
+      activesupport (= 3.0.0)
+    activesupport (3.0.0)
+    addressable (2.2.8)
+    crack (0.1.6)
+    daemons (1.1.8)
+    diff-lcs (1.1.3)
+    em-http-request (0.3.0)
+      addressable (>= 2.0.0)
+      escape_utils
+      eventmachine (>= 0.12.9)
+    escape_utils (0.2.4)
+    eventmachine (0.12.10)
+    google-weather (0.3.0)
+      httparty (~> 0.5.0)
+    httparty (0.5.2)
+      crack (= 0.1.6)
+    i18n (0.6.0)
+    metaclass (0.0.1)
+    mocha (0.11.4)
+      metaclass (~> 0.0.1)
+    rake (0.9.2.2)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    xmpp4r (0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  active_support
+  daemons
+  em-http-request
+  eventmachine
+  google-weather
+  httparty
+  i18n
+  mocha
+  rake
+  rspec
+  xmpp4r

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tomasz Pewiński
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# Hipbot
+
+[![Build Status](https://secure.travis-ci.org/pewniak747/hipbot.png?branch=master)](http://travis-ci.org/pewniak747/hipbot)
+
+Hipbot is a bot for HipChat, written in ruby & eventmachine.
+
+This is a work in progress.
+
+## Usage
+
+Install via RubyGems
+
+```
+gem install hipbot
+```
+
+In bot.rb file, subclass Hipbot::Bot and customize robot responses.
+
+``` ruby
+require 'hipbot'
+
+class MyCompanyBot < Hipbot::Bot
+  configure do |c|
+    c.name = 'robot'
+    c.jid = 'changeme@chat.hipchat.com'
+    c.password = 'secret'
+  end
+
+  # simple reply to '@robot hello!'
+  on /^hello.*/ do
+    reply('hello!')
+  end
+
+  # tasks with arguments: '@robot deploy to production pls'
+  on /deploy to (.*) pls/ do |stage|
+    reply('deploying to #{stage}!')
+    post("http://#{stage}.example.com") do |http|
+      reply("deploy server responded with #{http.response_header.status}")
+    end
+  end
+
+  # global messages
+  on /.*hello everyone.*/, global: true do
+    reply('hello!')
+  end
+end
+
+MyCompanyBot.start!
+```
+
+Run hipbot as daemon by saying:
+
+```
+hipbot start
+```
+
+Run `hipbot` to see all available commands.
+
+## TODO:
+
+* add support for custom response helpers
+* error handling, reconnecting

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default  => :spec

data/bin/hipbot

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'daemons'
+
+Daemons.run('bot.rb')

data/bot.rb

@@ -0,0 +1,92 @@
+require_relative './lib/hipbot'
+
+class MyBot < Hipbot::Bot
+  configure do |c|
+    c.jid = ENV['HIPBOT_JID']
+    c.password = ENV['HIPBOT_PASSWORD']
+    c.name = ENV['HIPBOT_NAME']
+  end
+
+  # Works for message and response
+  # TODO: Reload existing objects? / Full bot restart
+  on /^reload (.*)/, global: true do |clazz|
+    const = clazz.capitalize.to_sym
+    Hipbot.class_eval do
+      remove_const const if const_defined? const
+    end
+    load("./lib/hipbot/" + clazz + ".rb")
+    reply('Reloaded')
+  end
+
+  on /get (.*)/ do |url|
+    get(url) do |http|
+      reply("Server responded with code: #{http.response_header.status}")
+    end
+  end
+
+  on /^wiki (.+)/, global: true do |search|
+    search = URI::encode search
+    get("http://en.wikipedia.org/w/api.php?action=query&format=json&titles=#{search}&prop=extracts&exlimit=3&explaintext=1&exsentences=2") do |http|
+      extracts = JSON.parse http.response.force_encoding 'utf-8'
+      extracts['query']['pages'].each do |page|
+        reply(page[1]['extract'])
+      end
+    end
+  end
+
+  on /^google (.+)/, global: true do |search|
+    search = URI::encode search
+    get("http://ajax.googleapis.com/ajax/services/search/web?v=1.0&safe=off&q=#{search}") do |http|
+      extracts = JSON.parse http.response.force_encoding 'utf-8'
+      extracts['responseData']['results'].each do |page|
+        reply("#{page['url']} - #{page['titleNoFormatting']}")
+      end
+    end
+  end
+
+  on /weather\s(.*)/ do |city|
+    reply("checking weather for #{city}")
+    conditions = ::GoogleWeather.new(city).forecast_conditions.first
+    reply("weather in #{city} - #{conditions.condition}, max #{conditions.high}F")
+  end
+
+  on /^hello.*/ do
+    reply('hello!')
+  end
+
+  on /deploy to (.*) pls/ do |stage|
+    reply("deploying #{room} to #{stage}!")
+    sleep(3)
+    reply("deployed!")
+  end
+
+  on /.*hello everyone.*/, global: true do
+    reply('hello!')
+  end
+
+  on /sleep/, global: true do
+    reply("sleeping...")
+    sleep(10)
+    reply("woke up")
+  end
+
+  on /help|commands/ do
+    commands = []
+    bot.reactions.each do |r|
+      commands << r.regexp
+    end
+    reply(commands.join("\n"))
+  end
+
+  on /^rand (.*)/, global: true do |message|
+    options = message.split(',').map { |s| s.strip }
+    rsp = options[rand(options.length)]
+    reply("And the winner is... #{rsp}") if rsp
+  end
+
+  on /^debug/, global: true do
+    reply "Debug " + (Jabber::debug = !Jabber::debug ? 'on' : 'off')
+  end
+end
+
+MyBot.start!

data/hipbot.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/hipbot/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tomasz Pewiński"]
+  gem.email         = ["pewniak747@gmail.com"]
+  gem.description   = "Hipbot is a bot for HipChat, written in ruby & eventmachine."
+  gem.summary       = "Hipbot is a bot for HipChat, written in ruby & eventmachine."
+  gem.homepage      = "http://github.com/pewniak747/hipbot"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "hipbot"
+  gem.require_paths = ["lib"]
+  gem.version       = Hipbot::VERSION
+end

data/lib/hipbot.rb

@@ -0,0 +1,19 @@
+require 'active_support/all'
+require 'eventmachine'
+require 'em-http-request'
+require 'xmpp4r'
+require 'xmpp4r/muc'
+require 'hipbot/mucclient'
+
+require 'hipbot/adapters/hipchat'
+require 'hipbot/adapters/telnet'
+require 'hipbot/bot'
+require 'hipbot/configuration'
+require 'hipbot/message'
+require 'hipbot/reaction'
+require 'hipbot/response'
+require 'hipbot/room'
+require 'hipbot/version'
+
+# Plugins
+require 'google_weather'

data/lib/hipbot/adapters/hipchat.rb

@@ -0,0 +1,79 @@
+module Hipbot
+  module Adapters
+    module Hipchat
+      delegate :reply, to: :connection
+
+      class Connection
+
+        def initialize bot
+          initialize_bot(bot)
+          initialize_jabber
+          initialize_rooms
+          join_rooms
+        end
+
+        def reply room, message
+          for_room room do |room|
+            puts("Replied to #{room.name} - #{message}")
+            send_message(room, message)
+          end
+        end
+
+        private
+
+        def initialize_rooms
+          @rooms ||= []
+          @muc_browser = Jabber::MUC::MUCBrowser.new(@jabber)
+          @rooms = @muc_browser.muc_rooms('conf.hipchat.com').map { |jid, name|
+            ::Hipbot::Room.new(jid, name)
+          }
+        end
+
+        def initialize_bot bot
+          @bot = bot
+          @bot.connection = self
+        end
+
+        def initialize_jabber
+          @jabber = ::Jabber::Client.new(@bot.jid)
+          @jabber.connect
+          @jabber.auth(@bot.password)
+        end
+
+        def join_rooms
+          rooms.each do |room|
+            puts "joining #{room.name}"
+            room.connection = ::Jabber::MUC::SimpleMUCClient.new(@jabber)
+            room.connection.on_message do |time, sender, message|
+              puts "#{Time.now} <#{sender}> #{message}"
+              @bot.tell(sender, room.name, message)
+            end
+            room.connection.join("#{room.jid}/#{@bot.name}", nil, :history => false)
+          end
+        end
+
+        def for_room room_name
+          room = rooms.find { |r| r.name == room_name }
+          if room.present?
+            yield(room) if block_given?
+          end
+        end
+
+        def send_message room, message
+          room.connection.say(message)
+        end
+
+        def rooms
+          @rooms || []
+        end
+      end
+
+      def start!
+        ::EM::run do
+          Connection.new(self)
+        end
+      end
+
+    end
+  end
+end

data/lib/hipbot/adapters/telnet.rb

@@ -0,0 +1,28 @@
+module Hipbot
+  module Adapters
+    module Telnet
+      def reply room, message
+        connection.send_data("#{self}:#{room}:#{message}\n")
+      end
+
+      class Connection < EM::Connection
+        def initialize bot
+          @bot = bot
+          @bot.connection = self
+        end
+
+        def receive_data(data)
+          sender, room, message = *data.strip.split(':')
+          @bot.tell(sender, room, message)
+        end
+      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

@@ -0,0 +1,72 @@
+module Hipbot
+  class Bot
+    attr_accessor :reactions, :configuration, :connection
+    CONFIGURABLE_OPTIONS = [:name, :jid, :password, :adapter]
+    delegate *CONFIGURABLE_OPTIONS, to: :configuration
+    alias_method :to_s, :name
+
+    def initialize
+      self.configuration = Configuration.new.tap(&self.class.configuration)
+      self.reactions = []
+      self.class.reactions.each do |opts|
+        on(opts[0], opts[1], &opts[-1])
+      end
+      extend(self.adapter || ::Hipbot::Adapters::Hipchat)
+    end
+
+    def on regexp, options={}, &block
+      self.reactions << Reaction.new(self, regexp, 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)
+      end
+    end
+
+    def reactions_list
+      self.reactions.regexp
+    end
+
+    class << self
+
+      def on regexp, options={}, &block
+        @reactions ||= []
+        @reactions << [regexp, options, block]
+      end
+
+      def configure &block
+        @configuration = block
+      end
+
+      def reactions
+        @reactions || []
+      end
+
+      def configuration
+        @configuration || Proc.new{}
+      end
+
+      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}\"")
+      })
+    end
+
+  end
+end

data/lib/hipbot/configuration.rb

@@ -0,0 +1,12 @@
+module Hipbot
+  class Configuration
+    attr_accessor *Bot::CONFIGURABLE_OPTIONS
+
+    def initialize
+      self.name = 'robot'
+      self.jid = 'changeme'
+      self.password = 'changeme'
+    end
+
+  end
+end

data/lib/hipbot/message.rb

@@ -0,0 +1,23 @@
+module Hipbot
+  class Message
+    attr_accessor :body, :sender, :raw_body
+    def initialize body, sender
+      self.raw_body = body
+      self.body = strip_recipient(body)
+      self.sender = sender
+    end
+
+    def recipients
+      results = raw_body.scan(/@(\w+)/) + raw_body.scan(/@"(.*)"/)
+      results.flatten
+    end
+
+    def for? recipient
+      recipients.include? recipient.to_s.gsub(/\s+/, '')
+    end
+
+    def strip_recipient body
+      body.gsub(/^@\w+\W*/, '')
+    end
+  end
+end

data/lib/hipbot/mucclient.rb

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

data/lib/hipbot/reaction.rb

@@ -0,0 +1,46 @@
+module Hipbot
+  class Reaction < Struct.new(:robot, :regexp, :options, :block)
+
+    def invoke sender, room, message
+      message = message_for(message, sender)
+      arguments = arguments_for(message)
+      Response.new(robot, self, room, message).invoke(arguments)
+    end
+
+    def match? sender, room, message
+      message = message_for(message, sender)
+      matches?(message) && matches_scope?(message) && matches_sender?(message)
+    end
+
+    private
+
+    def message_for message, sender
+      Message.new(message, sender)
+    end
+
+    def arguments_for message
+      message.body.match(regexp)[1..-1]
+    end
+
+    def matches?(message)
+      regexp =~ message.body
+    end
+
+    def matches_scope?(message)
+      global? || message.for?(robot)
+    end
+
+    def matches_sender?(message)
+      from_all? || Array(options[:from]).include?(message.sender)
+    end
+
+    def global?
+      options[:global]
+    end
+
+    def from_all?
+      !options[:from]
+    end
+
+  end
+end

data/lib/hipbot/response.rb

@@ -0,0 +1,36 @@
+module Hipbot
+  class Response < Struct.new(:bot, :reaction, :room, :message_object)
+
+    def invoke arguments
+      instance_exec(*arguments, &reaction.block)
+    end
+
+    private
+    def reply string
+      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 }
+      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

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

data/lib/hipbot/version.rb

@@ -0,0 +1,3 @@
+module Hipbot
+  VERSION = "0.0.1"
+end

data/spec/integration/hipbot_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+class MyHipbot < Hipbot::Bot
+  configure do |config|
+    config.name = 'robbot'
+    config.jid = 'robbot@chat.hipchat.com'
+  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
+end
+
+describe MyHipbot do
+  describe "configuration" do
+    it "should set robot name" do
+      subject.name.should == 'robbot'
+    end
+
+    it "should set hipchat token" do
+      subject.jid.should == 'robbot@chat.hipchat.com'
+    end
+  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!')
+    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")
+    end
+
+    it "should reply to global message" do
+      subject.expects(:reply).with(room, "hello!")
+      subject.tell(sender, room, "hi everyone!")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require_relative '../lib/hipbot'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/unit/hipbot_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Hipbot::Bot do
+  context "#on" do
+    let(:sender) { stub_everything }
+    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')
+    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')
+    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')
+    end
+
+    it "should say when does not understand" do
+      subject.on /^hello there$/ do
+        reply('hi!')
+      end
+      subject.expects(:reply).with(room, 'I don\'t understand "hello robot!"')
+      subject.tell(sender, room, '@robot hello robot!')
+    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')
+    end
+
+    context "global messages" do
+      it "should reply if callback is global" 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')
+      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')
+      end
+    end
+
+    context "messages from particular sender" do
+      it "should reply" do
+        subject.on /wazzup\?/, from: sender do
+          reply('Wazzup, Tom?')
+        end
+        subject.expects(:reply).with(room, 'Wazzup, Tom?')
+        subject.tell(sender, room, '@robot wazzup?')
+      end
+      it "should reply if sender acceptable" do
+        subject.on /wazzup\?/, from: [stub, sender] do
+          reply('wazzup, tom?')
+        end
+        subject.expects(:reply).with(room, 'wazzup, tom?')
+        subject.tell(sender, room, '@robot wazzup?')
+      end
+      it "should not reply if sender unacceptable" do
+        subject.on /wazzup\?/, from: sender do
+          reply('wazzup, tom?')
+        end
+        subject.expects(:reply).with(room, "I don't understand \"wazzup?\"")
+        subject.tell(stub, room, '@robot wazzup?')
+      end
+      it "should not reply if sender does not match" do
+        subject.on /wazzup\?/, from: [sender] do
+          reply('wazzup, tom?')
+        end
+        subject.expects(:reply).with(room, "I don't understand \"wazzup?\"")
+        subject.tell(stub, room, '@robot wazzup?')
+      end
+    end
+
+    context "default variables" do
+      it "message" do
+        subject.on /.*/ do
+          reply("you said: #{message}")
+        end
+        subject.expects(:reply).with(room, "you said: hello")
+        subject.tell(stub, room, "@robot hello")
+      end
+
+      it "sender" do
+        subject.on /.*/ do
+          reply("you are: #{sender}")
+        end
+        subject.expects(:reply).with(room, "you are: tom")
+        subject.tell('tom', room, "@robot hello")
+      end
+
+      it "recipients" do
+        subject.on /.*/ do
+          reply("recipients: #{recipients.join(', ')}")
+        end
+        subject.expects(:reply).with(room, "recipients: robot, dave")
+        subject.tell('tom', room, "@robot tell @dave hello from me")
+      end
+    end
+  end
+
+  describe "configurable options" do
+    Hipbot::Bot::CONFIGURABLE_OPTIONS.each do |option|
+      it "should delegate #{option} to configuration" do
+        value = stub
+        subject.configuration.expects(option).returns(value)
+        subject.send(option)
+      end
+    end
+  end
+end

data/spec/unit/message_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Hipbot::Message do
+  subject { Hipbot::Message }
+  let(:sender) { stub }
+
+  it "should have a body" do
+    message = subject.new('this is a message', sender)
+    message.body.should == 'this is a message'
+  end
+
+  it "should have a sender" do
+    message = subject.new('this is a message', sender)
+    message.sender.should == sender
+  end
+
+  it "should have no recipients" do
+    message = subject.new('this is a message', sender)
+    message.recipients.should be_empty
+  end
+
+  it "should have one recipient" do
+    message = subject.new('this is a message for @tom', sender)
+    message.recipients.should include('tom')
+  end
+
+  it "should have one long recipient" do
+    message = subject.new('message for @"tom jones", deal with it', sender)
+    message.recipients.should include('tom jones')
+  end
+
+  it "should have two recipients" do
+    message = subject.new('@dave, this is a message for @tom', sender)
+    message.recipients.should include('tom')
+    message.recipients.should include('dave')
+  end
+
+  it "should strip primary recipient from message" do
+    message = subject.new('@dave this is a message for @tom', sender)
+    message.body.should == 'this is a message for @tom'
+  end
+
+  it "should strip primary recipient from message with commma" do
+    message = subject.new('@dave, this is a message for @tom', sender)
+    message.body.should == 'this is a message for @tom'
+  end
+
+  it "should be for bot" do
+    bot = stub(:to_s => 'robot')
+    message = subject.new('hello @robot!', sender)
+    message.for?(bot).should be_true
+  end
+
+  it "should not be for bot" do
+    bot = stub(:to_s => 'robot')
+    message = subject.new('hello @tom!', sender)
+    message.for?(bot).should be_false
+  end
+end

data/test_server.rb

@@ -0,0 +1,23 @@
+require 'eventmachine'
+
+$connections = []
+
+class ChatServer < EM::Connection
+  def post_init
+    $connections << self
+  end
+
+  def receive_data data
+    messages = data.split("\n").map{ |m| "#{m}\n" }.each do |msg|
+      sender, room, message = *msg.strip.split(':')
+      $connections.reject{|c| c==self}.each do |connection|
+        connection.send_data msg
+      end
+      puts "#{sender}@#{room} > #{message}"
+    end
+  end
+end
+
+EM::run do
+  EM::start_server('0.0.0.0', 3001, ChatServer)
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: hipbot
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tomasz Pewiński
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-20 00:00:00.000000000 Z
+dependencies: []
+description: Hipbot is a bot for HipChat, written in ruby & eventmachine.
+email:
+- pewniak747@gmail.com
+executables:
+- hipbot
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/hipbot
+- bot.rb
+- hipbot.gemspec
+- lib/hipbot.rb
+- lib/hipbot/adapters/hipchat.rb
+- lib/hipbot/adapters/telnet.rb
+- lib/hipbot/bot.rb
+- lib/hipbot/configuration.rb
+- lib/hipbot/message.rb
+- lib/hipbot/mucclient.rb
+- lib/hipbot/reaction.rb
+- lib/hipbot/response.rb
+- lib/hipbot/room.rb
+- lib/hipbot/version.rb
+- spec/integration/hipbot_spec.rb
+- spec/spec_helper.rb
+- spec/unit/hipbot_spec.rb
+- spec/unit/message_spec.rb
+- test_server.rb
+homepage: http://github.com/pewniak747/hipbot
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Hipbot is a bot for HipChat, written in ruby & eventmachine.
+test_files:
+- spec/integration/hipbot_spec.rb
+- spec/spec_helper.rb
+- spec/unit/hipbot_spec.rb
+- spec/unit/message_spec.rb
+has_rdoc: