sammcj-lita-xmpp 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7dddd7dffe3f344d9176d78190eaf974645a927
+  data.tar.gz: 0bf9e9af2a0e2d47cadb91747869831779137b63
+SHA512:
+  metadata.gz: 63f0dac7ce26f2b4ca8b27fc938d46cb17ec550badec2c00d0e68562e77691f175b8464943e2798b3a0994658fa2cd5ac3a383459669489e9dfc7293707f1bdd
+  data.tar.gz: 2bb048652ac839261dc4fdabe3ffaa2ae37d4f33353f743872b5af79ddb81f2678fb097106f2d68a16f5b24a408ec5dc95b525bb067179e402abe236b7dd9c2b

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,10 @@
+language: ruby
+rvm:
+  - 2.0.0
+script: bundle exec rspec
+before_install:
+  - gem update --system
+notifications:
+  webhooks:
+    urls:
+      - https://lita-freenode.herokuapp.com/travis

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Jimmy Cuadra
+
+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,48 @@
+# lita-xmpp
+
+WIP, probably has some bugs.
+
+**lita-xmpp** 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-xmpp to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-xmpp"
+```
+
+## Configuration
+
+
+### Required attributes
+
+* `jid` (String) - The JID of your robot's account. Default: `nil`.
+* `password` (String) - The password for your robot's 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. 
+
+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 = :xmpp
+  config.adapter.jid = "12345_123456@myserver.com"
+  config.adapter.password = "secret"
+  config.adapter.debug = false
+  config.adapter.rooms = :all
+  config.adapter.muc_domain = "conf.myserver.com"
+  config.mention_name = "bot"
+end
+```
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

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

data/lib/lita-xmpp.rb

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

data/lib/lita/adapters/xmpp.rb

@@ -0,0 +1,78 @@
+require "lita"
+require "lita/adapters/xmpp/connector"
+
+module Lita
+  module Adapters
+    class Xmpp < 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,
+          connect_domain: config.connect_domain
+        )
+      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 send_raw_messages(target, strings)
+        if target.room
+          connector.message_muc(target.room, strings, true)
+        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?
+      end
+    end
+
+    Lita.register_adapter(:xmpp, Xmpp)
+  end
+end

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

@@ -0,0 +1,85 @@
+module Lita
+  module Adapters
+    class Xmpp < Adapter
+      class Callback
+        attr_reader :robot, :roster
+
+        def initialize(robot, roster)
+          @robot = robot
+          @roster = roster
+          @start_time = Time.now.utc
+        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|
+            if time.is_a?(Time) && time < @start_time
+              Lita.logger.debug "#{time} < #{@start_time} Skipping #{nick}: #{text}"
+              next
+            else
+              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
+        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 jid_without_domain(jid)
+          jid.to_s.sub(/@.*/, '')
+        end
+
+        def create_user(user_data)
+          name = user_data['name'].downcase.gsub(/\s+/, '.')
+          User.create(
+            user_data["jid"],
+            name: name,
+            mention_name: jid_without_domain(user_data['jid'])
+          )
+        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.info("Looking up user with name: #{name}.")
+          items = roster.items.detect { |jid, item| jid_without_domain(jid) == name }
+
+          if items
+            Lita.logger.info("Looking up user by jid: #{items.first}.")
+            user_by_jid(items.first)
+          else
+            Lita.logger.warn "No user with the name #{name.inspect} was found in the roster"
+            User.new(nil, name: name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+require "lita/encoding_patches"
+require "lita/adapters/xmpp/callback"
+
+require "xmpp4r"
+require "xmpp4r/roster/helper/roster"
+require "xmpp4r/muc/helper/simplemucclient"
+require "xmpp4r/muc/helper/mucbrowser"
+
+module Lita
+  module Adapters
+    class Xmpp < Adapter
+      class Connector
+        attr_reader :robot, :client, :roster
+
+        def initialize(robot, jid, password, debug: false, connect_domain: nil)
+          @robot          = robot
+          @jid            = jid
+          @password       = password
+          @client         = Jabber::Client.new(@jid)
+          @connect_domain = connect_domain
+
+          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, raw = false)
+          if muc = mucs[room_jid]
+            if raw
+              Lita.logger.debug("Sending raw message to MUC #{room_jid}: #{strings}")
+              muc.send(strings)
+            else
+              strings.each do |s|
+                Lita.logger.debug("Sending message to MUC #{room_jid}: #{s}")
+                muc.say(s)
+              end
+            end
+          end
+        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 XMPP.")
+          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 XMPP. #{@connect_domain}")
+          client.connect(@connect_domain)
+          Lita.logger.debug("Authenticating with XMPP.")
+          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
+        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/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/lita-xmpp.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |spec|
+  spec.name          = "sammcj-lita-xmpp"
+  spec.version       = "1.0.3"
+  spec.authors       = ["Justin Mazzi"]
+  spec.email         = ["jmazzi@gmail.com"]
+  spec.description   = %q{A XMPP adapter for Lita.}
+  spec.summary       = %q{A XMPP adapter for the Lita chat robot.}
+  spec.homepage      = "https://github.com/jmazzi/lita-xmpp"
+  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", ">= 2.0"
+  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"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+end

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

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+describe Lita::Adapters::HipChat::Callback, lita: true 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
+
+    it "creates a temporary source user if the JID isn't in the roster" do
+      roster = double("Jabber::Roster::Helper", items: {})
+      allow(muc).to receive(:on_message).and_yield(nil, "Unknown", "foo")
+      allow(Lita::Source).to receive(:new).with(
+        an_instance_of(Lita::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, lita: true 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,121 @@
+require "spec_helper"
+
+describe Lita::Adapters::HipChat do
+  before do
+    Lita.configure do |config|
+      config.adapter.jid = "jid"
+      config.adapter.password = "secret"
+      config.adapter.rooms = nil
+      config.adapter.muc_domain = nil
+    end
+
+    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.clear_config
+    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,10 @@
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start { add_filter "/spec/" }
+
+require "lita-hipchat"
+require "lita/rspec"

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: sammcj-lita-xmpp
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+platform: ruby
+authors:
+- Justin Mazzi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !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 XMPP adapter for Lita.
+email:
+- jmazzi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/lita-xmpp.rb
+- lib/lita/adapters/xmpp.rb
+- lib/lita/adapters/xmpp/callback.rb
+- lib/lita/adapters/xmpp/connector.rb
+- lib/lita/encoding_patches.rb
+- lita-xmpp.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/jmazzi/lita-xmpp
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A XMPP 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