lita-hipchat 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 161a81fd8834b27403dfd7e86aa4b0b733e099bd
+  data.tar.gz: 7904f55d5dcc2d0731673f93ba787c9db8f5d1be
+SHA512:
+  metadata.gz: a2c21e123f3b466bc7ebc355bcc3fc91d47c2d775b10729543e12a0f0ab5635cee9ab3c34e820897d34b8f66052b513e09928a07fbb08b05afb339d0bab4a986
+  data.tar.gz: fd312cce8cd98d536fbf8d009d7613b5c85daaa56611023d32293a40f111c8095eb36ce937f1eaafc83b706d17eb239fb5aa6d10c937588e32df0b1065041abd

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+lita_config.rb

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.0.0
+script: bundle exec rspec
+before_install:
+  - gem update --system

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,52 @@
+# lita-hipchat
+
+[![Build Status](https://travis-ci.org/jimmycuadra/lita-hipchat.png)](https://travis-ci.org/jimmycuadra/lita-hipchat)
+[![Code Climate](https://codeclimate.com/github/jimmycuadra/lita-hipchat.png)](https://codeclimate.com/github/jimmycuadra/lita-hipchat)
+[![Coverage Status](https://coveralls.io/repos/jimmycuadra/lita-hipchat/badge.png)](https://coveralls.io/r/jimmycuadra/lita-hipchat)
+
+**lita-hipchat** is an adapter for [Lita](https://github.com/jimmycuadra/lita) that allows you to use the robot with [HipChat](https://www.hipchat.com/).
+
+## Installation
+
+Add lita-hipchat to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-hipchat"
+```
+
+## Configuration
+
+Values for all of the following attributes can be found on the "XMPP/Jabber info" page of the account settings on the HipChat website. A JID (Jabber ID) looks like "12345_123456@chat.hipchat.com".
+
+### Required attributes
+
+* `jid` (String) - The JID of your robot's HipChat account. Default: `nil`.
+* `password` (String) - The password for your robot's HipChat account. Default: `nil`.
+
+### Optional attributes
+
+* `debug` (Boolean) - If `true`, turns on the underlying Jabber library's (xmpp4r) logger, which is fairly verbose. Default: `false`.
+* `rooms` (Symbol, Array<String>) - An array of room JIDs that Lita should join upon connection. Can also be the symbol `:all`, which will cause Lita to discover and join all rooms. Default: `nil` (no rooms).
+* `muc_domain` (String) - The XMPP Multi-User Chat domain to use. Default: `"conf.hipchat.com"`.
+
+**Note: You must set the robot's name to the value shown as "Room nickname" on the XMPP settings page.**
+
+There's no need to set `config.robot.mention_name` manually. The adapter will load the proper mention name from the XMPP roster upon connection.
+
+### Example
+
+``` ruby
+Lita.configure do |config|
+  config.robot.name = "Lita Bot"
+  config.robot.adapter = :hipchat
+  config.adapter.jid = "12345_123456@chat.hipchat.com"
+  config.adapter.password = "secret"
+  config.adapter.debug = false
+  config.adapter.rooms = :all
+  config.adapter.muc_domain = "conf.hipchat.com"
+end
+```
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/lita/adapters/hipchat/callback.rb

@@ -0,0 +1,67 @@
+module Lita
+  module Adapters
+    class HipChat < Adapter
+      class Callback
+        attr_reader :robot, :roster
+
+        def initialize(robot, roster)
+          @robot = robot
+          @roster = roster
+        end
+
+        def private_message(client)
+          client.add_message_callback do |m|
+            next if m.type == :error || m.body.nil?
+            user = user_by_jid(m.from)
+            source = Source.new(user)
+            message = Message.new(robot, m.body, source)
+            message.command!
+            Lita.logger.debug("Dispatching PM to Lita from #{user.id}.")
+            robot.receive(message)
+          end
+        end
+
+        def muc_message(muc)
+          muc.on_message do |time, nick, text|
+            user = user_by_name(nick)
+            source = Source.new(user, muc.jid.bare.to_s)
+            message = Message.new(robot, text, source)
+            Lita.logger.debug(
+              "Dispatching message to Lita from #{user.id} in MUC #{muc.jid}."
+            )
+            robot.receive(message)
+          end
+        end
+
+        def roster_update
+          roster.add_update_callback do |old_item, item|
+            jid = item.attributes["jid"]
+            Lita.logger.debug("Updating record for user with ID: #{jid}.")
+            create_user(item.attributes)
+          end
+        end
+
+        private
+
+        def create_user(user_data)
+          User.create(
+            user_data["jid"],
+            name: user_data["name"],
+            mention_name: user_data["mention_name"]
+          )
+        end
+
+        def user_by_jid(jid)
+          Lita.logger.debug("Looking up user with JID: #{jid}.")
+          create_user(roster[jid].attributes)
+        end
+
+        def user_by_name(name)
+          Lita.logger.debug("Looking up user with name: #{name}.")
+          jid = roster.items.detect { |jid, item| item.iname == name }.first
+          user_by_jid(jid)
+        end
+      end
+    end
+  end
+end

data/lib/lita/adapters/hipchat/connector.rb

@@ -0,0 +1,131 @@
+require "lita/encoding_patches"
+require "lita/adapters/hipchat/callback"
+
+require "xmpp4r"
+require "xmpp4r/roster/helper/roster"
+require "xmpp4r/muc/helper/simplemucclient"
+require "xmpp4r/muc/helper/mucbrowser"
+
+module Lita
+  module Adapters
+    class HipChat < Adapter
+      class Connector
+        attr_reader :robot, :client, :roster
+
+        def initialize(robot, jid, password, debug: false)
+          @robot = robot
+          @jid = normalized_jid(jid, "chat.hipchat.com", "bot")
+          @password = password
+          @client = Jabber::Client.new(@jid)
+          if debug
+            Lita.logger.info("Enabling Jabber log.")
+            Jabber.debug = true
+          end
+        end
+
+        def jid
+          @jid.to_s
+        end
+
+        def connect
+          client_connect
+          load_roster
+          register_message_callback
+          send_presence
+        end
+
+        def join_rooms(muc_domain, rooms)
+          rooms.each do |room_name|
+            muc = Jabber::MUC::SimpleMUCClient.new(client)
+            room_jid = normalized_jid(room_name, muc_domain, robot.name)
+            mucs[room_jid.bare.to_s] = muc
+            register_muc_message_callback(muc)
+            Lita.logger.info("Joining room: #{room_jid}.")
+            muc.join(room_jid)
+          end
+        end
+
+        def list_rooms(muc_domain)
+          Lita.logger.debug("Querying server for list of rooms.")
+          browser = Jabber::MUC::MUCBrowser.new(client)
+          browser.muc_rooms(muc_domain).map { |jid, name| jid.to_s }
+        end
+
+        def message_jid(user_jid, strings)
+          strings.each do |s|
+            Lita.logger.debug("Sending message to JID #{user_jid}: #{s}")
+            message = Jabber::Message.new(user_jid, s)
+            message.type = :chat
+            client.send(message)
+          end
+        end
+
+        def message_muc(room_jid, strings)
+          muc = mucs[room_jid]
+          strings.each do |s|
+            Lita.logger.debug("Sending message to MUC #{room_jid}: #{s}")
+            muc.say(s)
+          end if muc
+        end
+
+        def mucs
+          @mucs ||= {}
+        end
+
+        def set_topic(room_jid, topic)
+          muc = mucs[room_jid]
+          if muc
+            Lita.logger.debug("Setting topic for MUC #{room_jid}: #{topic}")
+            muc.subject = topic
+          end
+        end
+
+        def shut_down
+          Lita.logger.info("Disconnecting from HipChat.")
+          client.close
+        end
+
+        private
+
+        def send_presence
+          Lita.logger.debug("Sending initial XMPP presence.")
+          client.send(Jabber::Presence.new(:chat))
+        end
+
+        def client_connect
+          Lita.logger.info("Connecting to HipChat.")
+          client.connect
+          Lita.logger.debug("Authenticating with HipChat.")
+          client.auth(@password)
+        end
+
+        def register_message_callback
+          Callback.new(robot, roster).private_message(client)
+        end
+
+        def register_muc_message_callback(muc)
+          Callback.new(robot, roster).muc_message(muc)
+        end
+
+        def load_roster
+          Lita.logger.debug("Loading roster.")
+          @roster = Jabber::Roster::Helper.new(client, false)
+          Callback.new(robot, roster).roster_update
+          roster.get_roster
+          roster.wait_for_roster
+          robot.mention_name = roster[jid].attributes["mention_name"]
+        end
+
+        def normalized_jid(jid, domain, resource)
+          jid = Jabber::JID.new(jid)
+          jid.resource = resource
+          unless jid.node
+            jid.node = jid.domain
+            jid.domain = domain
+          end
+          jid
+        end
+      end
+    end
+  end
+end

data/lib/lita/adapters/hipchat.rb

@@ -0,0 +1,70 @@
+require "lita"
+require "lita/adapters/hipchat/connector"
+
+module Lita
+  module Adapters
+    class HipChat < Adapter
+      require_configs :jid, :password
+
+      attr_reader :connector
+
+      def initialize(robot)
+        super
+
+        set_default_config_values
+
+        @connector = Connector.new(
+          robot,
+          config.jid,
+          config.password,
+          debug: config.debug
+        )
+      end
+
+      def run
+        connector.connect
+        connector.join_rooms(config.muc_domain, rooms)
+        sleep
+      rescue Interrupt
+        shut_down
+      end
+
+      def send_messages(target, strings)
+        if target.room
+          connector.message_muc(target.room, strings)
+        else
+          connector.message_jid(target.user.id, strings)
+        end
+      end
+
+      def set_topic(target, topic)
+        connector.set_topic(target.room, topic)
+      end
+
+      def shut_down
+        connector.shut_down
+      end
+
+      private
+
+      def config
+        Lita.config.adapter
+      end
+
+      def rooms
+        if config.rooms == :all
+          connector.list_rooms(config.muc_domain)
+        else
+          Array(config.rooms)
+        end
+      end
+
+      def set_default_config_values
+        config.debug = false if config.debug.nil?
+        config.muc_domain = "conf.hipchat.com" if config.muc_domain.nil?
+      end
+    end
+
+    Lita.register_adapter(:hipchat, HipChat)
+  end
+end

data/lib/lita/encoding_patches.rb

@@ -0,0 +1,27 @@
+# xmpp4r and REXML are bad and should feel bad.
+# https://github.com/ln/xmpp4r/issues/3#issuecomment-1739952
+require 'socket'
+class TCPSocket
+  def external_encoding
+    Encoding::BINARY
+  end
+end
+
+require 'rexml/source'
+class REXML::IOSource
+  alias_method :encoding_assign, :encoding=
+  def encoding=(value)
+    encoding_assign(value) if value
+  end
+end
+
+begin
+  # OpenSSL is optional and can be missing
+  require 'openssl'
+  class OpenSSL::SSL::SSLSocket
+    def external_encoding
+      Encoding::BINARY
+    end
+  end
+rescue
+end

data/lib/lita-hipchat.rb

@@ -0,0 +1 @@
+require "lita/adapters/hipchat"

data/lita-hipchat.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |spec|
+  spec.name          = "lita-hipchat"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Jimmy Cuadra"]
+  spec.email         = ["jimmy@jimmycuadra.com"]
+  spec.description   = %q{A HipChat adapter for Lita.}
+  spec.summary       = %q{A HipChat adapter for the Lita chat robot.}
+  spec.homepage      = "https://github.com/jimmycuadra/lita-hipchat"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "lita", "~> 1.1"
+  spec.add_runtime_dependency "xmpp4r", "~> 0.5"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 2.14.0.rc1"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+end

data/spec/lita/adapters/hipchat/callback_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe Lita::Adapters::HipChat::Callback do
+  subject { described_class.new(robot, roster) }
+
+  let(:robot) { double("Lita::Robot") }
+  let(:roster) do
+    double("Jabber::Roster::Helper", items: { "user_id" => roster_item })
+  end
+  let(:user) { double("Lita::User", id: "user_id") }
+  let(:source) { double("Lita::Source") }
+  let(:message) { double("Lita::Message") }
+  let(:roster_item) do
+    double("Jabber::Roster::RosterItem", attributes: {
+      "jid" => "user_id",
+      "name" => "Carl",
+      "mention_name" => "@Carl"
+    }, iname: "Carl")
+  end
+
+  before do
+    allow(roster).to receive(:[]).with("user_id").and_return(roster_item)
+    allow(Lita::User).to receive(:create).with(
+      "user_id",
+      name: "Carl",
+      mention_name: "@Carl"
+    ).and_return(user)
+  end
+
+  it "has a robot" do
+    expect(subject.robot).to eq(robot)
+  end
+
+  it "has a roster" do
+    expect(subject.roster).to eq(roster)
+  end
+
+  describe "#private_message" do
+    let(:client) { double("Jabber::Client") }
+    let(:jabber_message) do
+      double("Jabber::Message", type: :chat, from: "user_id", body: "foo")
+    end
+
+    before do
+      allow(client).to receive(:add_message_callback).and_yield(jabber_message)
+    end
+
+    it "sends the message to the robot with the proper source and body" do
+      allow(Lita::Source).to receive(:new).with(user).and_return(source)
+      allow(Lita::Message).to receive(:new).with(
+        robot,
+        "foo",
+        source
+      ).and_return(message)
+      expect(message).to receive(:command!)
+      expect(robot).to receive(:receive).with(message)
+      subject.private_message(client)
+    end
+
+    it "skips the message if it's an error type" do
+      allow(jabber_message).to receive(:type).and_return(:error)
+      expect(robot).not_to receive(:receive)
+      subject.private_message(client)
+    end
+
+    it "skips the message if the body is nil" do
+      allow(jabber_message).to receive(:body).and_return(nil)
+      expect(robot).not_to receive(:receive)
+      subject.private_message(client)
+    end
+  end
+
+  describe "#muc_message" do
+    let(:jid) { double("Jabber::JID", bare: "room_id") }
+    let(:muc) { double("Jabber::MUC::SimpleMUCClient", jid: jid) }
+
+    before do
+      allow(muc).to receive(:on_message).and_yield(nil, "Carl", "foo")
+    end
+
+    it "sends the message to the robot with the proper source and body" do
+      allow(Lita::Source).to receive(:new).with(
+        user,
+        "room_id"
+      ).and_return(source)
+      allow(Lita::Message).to receive(:new).with(
+        robot,
+        "foo",
+        source
+      ).and_return(message)
+      expect(robot).to receive(:receive).with(message)
+      subject.muc_message(muc)
+    end
+  end
+
+  describe "#roster_update" do
+    before do
+      allow(roster).to receive(:add_update_callback).and_yield(nil, roster_item)
+    end
+
+    it "finds/creates a user object for the roster item" do
+      expect(Lita::User).to receive(:create).with(
+        "user_id",
+        name: "Carl",
+        mention_name: "@Carl"
+      )
+      subject.roster_update
+    end
+  end
+end

data/spec/lita/adapters/hipchat/connector_spec.rb

@@ -0,0 +1,200 @@
+require "spec_helper"
+
+describe Lita::Adapters::HipChat::Connector do
+  subject { described_class.new(robot, "user", "secret") }
+
+  let(:client) { double("Jabber::Client").as_null_object }
+  let(:robot) { double("Lita::Robot", name: "Lita" ) }
+
+  before { allow(subject).to receive(:client).and_return(client) }
+
+  it "sets the JID properly when only a node is supplied" do
+    subject = described_class.new(robot, "user", "secret")
+    expect(subject.jid).to eq("user@chat.hipchat.com/bot")
+  end
+
+  it "sets the JID properly when a node and domain are supplied" do
+    subject = described_class.new(robot, "user@example.com", "secret")
+    expect(subject.jid).to eq("user@example.com/bot")
+  end
+
+  it "sets the JID properly when a resource is supplied" do
+    subject = described_class.new(robot, "user@example.com/wrong", "secret")
+    expect(subject.jid).to eq("user@example.com/bot")
+  end
+
+  it "turns on the xmpp4r logger if debug: true is supplied" do
+    expect(Jabber).to receive(:debug=).with(true)
+    subject = described_class.new(robot, "user", "secret", debug: true)
+  end
+
+  describe "#connect" do
+    let(:presence) { double("Jabber::Presence") }
+    let(:roster) { double("Jabber::Roster::Helper").as_null_object }
+    let(:callback) { double("Lita::Adapters::HipChat::Callback") }
+
+    before do
+      allow(Jabber::Presence).to receive(:new).and_return(presence)
+      allow(Jabber::Roster::Helper).to receive(:new).with(
+        client,
+        false
+      ).and_return(roster)
+      allow(Lita::Adapters::HipChat::Callback).to receive(:new).and_return(
+        callback
+      )
+      allow(callback).to receive(:private_message)
+      allow(callback).to receive(:roster_update)
+      allow(robot).to receive(:mention_name=)
+    end
+
+    it "connects to HipChat" do
+      expect(subject.client).to receive(:connect)
+      subject.connect
+    end
+
+    it "authenticates with the supplied password" do
+      expect(subject.client).to receive(:auth).with("secret")
+      subject.connect
+    end
+
+    it "sends an initial presence of :chat" do
+      expect(Jabber::Presence).to receive(:new).with(:chat).and_return(presence)
+      expect(subject.client).to receive(:send).with(presence)
+      subject.connect
+    end
+
+    it "registers a message callback" do
+      expect(Lita::Adapters::HipChat::Callback).to receive(:new).with(
+        robot,
+        roster
+      ).and_return(callback)
+      expect(callback).to receive(:private_message).with(client)
+      subject.connect
+    end
+
+    it "loads a roster" do
+      expect(roster).to receive(:wait_for_roster)
+      subject.connect
+    end
+
+    it "assigns the robot's mention_name with info from the roster" do
+      allow(roster).to receive(:[]).with(subject.jid).and_return(
+        double("Jabber::Roster::RosterItem", attributes: {
+          "mention_name" => "LitaBot"
+        })
+      )
+      expect(robot).to receive(:mention_name=).with("LitaBot")
+      subject.connect
+    end
+  end
+
+  describe "#join rooms" do
+    let(:muc_domain) { "conf.hipchat.com" }
+    let(:rooms) { ["muc_1", "muc_2"] }
+    let(:muc_1) { double("Jabber::MUC::SimpleMUCClient").as_null_object }
+    let(:muc_2) { double("Jabber::MUC::SimpleMUCClient").as_null_object }
+    let(:callback) { double("Lita::Adapters::HipChat::Callback") }
+    let(:roster) { double("Jabber::Roster::Helper") }
+
+    before do
+      allow(Jabber::MUC::SimpleMUCClient).to receive(:new).with(
+        client
+      ).and_return(muc_1, muc_2)
+      allow(Lita::Adapters::HipChat::Callback).to receive(:new).and_return(
+        callback
+      )
+      allow(callback).to receive(:muc_message)
+      allow(subject).to receive(:roster).and_return(roster)
+    end
+
+    it "creates a SimpleMUCClient for each room" do
+      subject.join_rooms(muc_domain, rooms)
+      expect(subject.mucs).to eq(
+        "muc_1@conf.hipchat.com" => muc_1,
+        "muc_2@conf.hipchat.com" => muc_2,
+      )
+    end
+
+    it "registers a message callback for each room" do
+      expect(Lita::Adapters::HipChat::Callback).to receive(:new).with(
+        robot,
+        roster
+      ).and_return(callback)
+      expect(callback).to receive(:muc_message).with(muc_1)
+      expect(callback).to receive(:muc_message).with(muc_2)
+      subject.join_rooms(muc_domain, rooms)
+    end
+
+    it "joins each room" do
+      expect(muc_1).to receive(:join)
+      expect(muc_2).to receive(:join)
+      subject.join_rooms(muc_domain, rooms)
+    end
+  end
+
+  describe "#list_rooms" do
+    let(:browser) { double("Jabber::MUC::MUCBrowser") }
+
+    before do
+      allow(Jabber::MUC::MUCBrowser).to receive(:new).with(client).and_return(
+        browser
+      )
+    end
+
+    it "returns an array of room JIDs for the MUC domain" do
+      allow(browser).to receive(:muc_rooms).with("conf.hipchat.com").and_return(
+        "123_456@conf.hipchat.com" => "Room 1",
+        "789_012@conf.hipchat.com" => "Room 2"
+      )
+      expect(subject.list_rooms("conf.hipchat.com")).to eq([
+        "123_456@conf.hipchat.com",
+        "789_012@conf.hipchat.com"
+      ])
+    end
+  end
+
+  describe "#message_jid" do
+    let(:message_1) { double("Jabber::Message") }
+    let(:message_2) { double("Jabber::Message") }
+
+    it "sends the messages to the user" do
+      allow(Jabber::Message).to receive(:new).with("jid", "foo").and_return(
+        message_1
+      )
+      allow(Jabber::Message).to receive(:new).with("jid", "bar").and_return(
+        message_2
+      )
+      expect(message_1).to receive(:type=).with(:chat)
+      expect(message_2).to receive(:type=).with(:chat)
+      expect(client).to receive(:send).with(message_1)
+      expect(client).to receive(:send).with(message_2)
+      subject.message_jid("jid", ["foo", "bar"])
+    end
+  end
+
+  describe "#message_muc" do
+    it "sends the messages to the room" do
+      muc = double("Jabber::MUC::SimpleMUCClient")
+      allow(subject).to receive(:mucs).and_return("jid" => muc)
+      expect(muc).to receive(:say).with("foo")
+      expect(muc).to receive(:say).with("bar")
+      subject.message_muc("jid", ["foo", "bar"])
+    end
+  end
+
+  describe "#set_topic" do
+    it "sets the room's topic to the supplied message" do
+      muc = double("Jabber::MUC::SimpleMUCClient")
+      allow(subject).to receive(:mucs).and_return("jid" => muc)
+      expect(muc).to receive(:subject=).with("New topic")
+      subject.set_topic("jid", "New topic")
+    end
+  end
+
+  describe "#shut_down" do
+    it "closes the client connection" do
+      expect(subject.client).to receive(:close)
+      subject.shut_down
+    end
+  end
+end

data/spec/lita/adapters/hipchat_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Lita::Adapters::HipChat do
+  before do
+    Lita.config.adapter.jid = "jid"
+    Lita.config.adapter.password = "secret"
+    Lita.config.adapter.rooms = nil
+    Lita.config.adapter.muc_domain = nil
+    allow(Lita).to receive(:logger).and_return(double("Logger").as_null_object)
+    allow(described_class::Connector).to receive(:new).and_return(connector)
+  end
+
+  subject { described_class.new(robot) }
+
+  let(:robot) { double("Lita::Robot") }
+  let(:connector) { double("Lita::Adapters::HipChat::Connector") }
+
+  it "registers with Lita" do
+    expect(Lita.adapters[:hipchat]).to eql(described_class)
+  end
+
+  it "requires config.jid and config.password" do
+    Lita.instance_variable_set(:@config, nil)
+    expect(Lita.logger).to receive(:fatal).with(/jid, password/)
+    expect { subject }.to raise_error(SystemExit)
+  end
+
+  describe "#run" do
+    before do
+      allow(subject.connector).to receive(:connect)
+      allow(subject.connector).to receive(:join_rooms)
+      allow(subject).to receive(:sleep)
+    end
+
+    it "connects to HipChat" do
+      expect(subject.connector).to receive(:connect)
+      subject.run
+    end
+
+    it "joins rooms with a custom muc_domain" do
+      Lita.config.adapter.muc_domain = "foo.bar.com"
+      expect(subject.connector).to receive(:join_rooms).with(
+        "foo.bar.com",
+        anything
+      )
+      subject.run
+    end
+
+    it "joins all rooms when config.rooms is :all" do
+      all_rooms = ["room_1_id", "room_2_id"]
+      Lita.config.adapter.rooms = :all
+      allow(subject.connector).to receive(:list_rooms).with(
+        "conf.hipchat.com"
+      ).and_return(all_rooms)
+      expect(subject.connector).to receive(:join_rooms).with(
+        "conf.hipchat.com",
+        all_rooms
+      )
+      subject.run
+    end
+
+    it "joins rooms specified by config.rooms" do
+      custom_rooms = ["my_room_1_id", "my_room_2_id"]
+      Lita.config.adapter.rooms = custom_rooms
+      expect(subject.connector).to receive(:join_rooms).with(
+        "conf.hipchat.com",
+        custom_rooms
+      )
+      subject.run
+    end
+
+    it "sleeps the main thread" do
+      expect(subject).to receive(:sleep)
+      subject.run
+    end
+
+    it "disconnects gracefully on interrupt" do
+      expect(subject).to receive(:shut_down)
+      allow(subject).to receive(:sleep).and_raise(Interrupt)
+      subject.run
+    end
+  end
+
+  describe "#send_messages" do
+    it "sends messages to rooms" do
+      source = double("Lita::Source", room: "room_id")
+      expect(subject.connector).to receive(:message_muc).with(
+        "room_id",
+        ["Hello!"]
+      )
+      subject.send_messages(source, ["Hello!"])
+    end
+
+    it "sends private messages to users" do
+      user = double("Lita::User", id: "user_id")
+      source = double("Lita::Source", room: nil, user: user)
+      expect(subject.connector).to receive(:message_jid).with(
+        "user_id",
+        ["Hello!"]
+      )
+      subject.send_messages(source, ["Hello!"])
+    end
+  end
+
+  describe "#set_topic" do
+    it "sets a new topic for a room" do
+      source = double("Lita::Source", room: "room_id")
+      expect(subject.connector).to receive(:set_topic).with("room_id", "Topic")
+      subject.set_topic(source, "Topic")
+    end
+  end
+
+  describe "#shut_down" do
+    it "shuts down the connector" do
+      expect(subject.connector).to receive(:shut_down)
+      subject.shut_down
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require "lita-hipchat"
+require "lita/rspec"
+
+RSpec.configure do |config|
+  config.include Lita::RSpec
+
+  config.before do
+    allow(Lita).to receive(:logger).and_return(double("Logger").as_null_object)
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: lita-hipchat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jimmy Cuadra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: xmpp4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.0.rc1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A HipChat adapter for Lita.
+email:
+- jimmy@jimmycuadra.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- lib/lita-hipchat.rb
+- lib/lita/adapters/hipchat.rb
+- lib/lita/adapters/hipchat/callback.rb
+- lib/lita/adapters/hipchat/connector.rb
+- lib/lita/encoding_patches.rb
+- lita-hipchat.gemspec
+- spec/lita/adapters/hipchat/callback_spec.rb
+- spec/lita/adapters/hipchat/connector_spec.rb
+- spec/lita/adapters/hipchat_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jimmycuadra/lita-hipchat
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A HipChat adapter for the Lita chat robot.
+test_files:
+- spec/lita/adapters/hipchat/callback_spec.rb
+- spec/lita/adapters/hipchat/connector_spec.rb
+- spec/lita/adapters/hipchat_spec.rb
+- spec/spec_helper.rb
+has_rdoc: