lita-hipchat 1.2.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b44d85256ad28bcd38f6251bb541befe06e46e1a
-  data.tar.gz: d4cbe864f145d04cf8e951f4e5d9926368b78601
+  metadata.gz: 4eafe0fed02771e3620e3c24e787e5ac93bd6161
+  data.tar.gz: d3ce7410e3b5ac946ca7b8647faf3fd11606f511
 SHA512:
-  metadata.gz: 28fd7d98f38987810ffce31d1425fdc443aa3173cfe638bd49f536d8df4a331e85eb1ab1d48984d3cffa2478f7a4cfac6cb7fb77f9da1ef85dd28a1d7dcf0de0
-  data.tar.gz: 17113cc66fb7da9a6724ccabc9acefdc465f9a0471129c7ee87cfe7d442493504f60ee3f241cf3277c3aba3f7c05210f17db5b1e710dca94c4cdd23ba1a2f4fa
+  metadata.gz: 766865e1b4d6179bec66e66a7c5ad22d1da935eb541e96822619ed3cd4bb1eb74fd5aaacb297beff1d448dea5d3dd491795f3ca0d0c11e8901c7f40fa228a08b
+  data.tar.gz: 0cf3c6890479743a5193272ad6070034d1b936cdabf434331f4ff98606a013eeebc1e6573451ca37ceaf7de0bf22454f58e6658c79203ac3ebf19a04812af0d0

data/lib/lita/adapters/hipchat.rb

@@ -11,20 +11,21 @@ module Lita
       def initialize(robot)
         super
 
-        set_default_config_values
-
-        @connector = Connector.new(
-          robot,
-          config.jid,
-          config.password,
-          debug: config.debug
-        )
+        @connector = Connector.new(robot, config.jid, config.password, debug: debug)
+      end
+
+      def join(room_id)
+        connector.join(muc_domain, room_id)
+      end
+
+      def part(room_id)
+        connector.part(muc_domain, room_id)
       end
 
       def run
         connector.connect
         robot.trigger(:connected)
-        connector.join_rooms(config.muc_domain, rooms)
+        connector.join_rooms(muc_domain, rooms)
         sleep
       rescue Interrupt
         shut_down
@@ -53,18 +54,21 @@ module Lita
         Lita.config.adapter
       end
 
+      def debug
+        config.debug || false
+      end
+
+      def muc_domain
+        config.muc_domain || "conf.hipchat.com"
+      end
+
       def rooms
         if config.rooms == :all
-          connector.list_rooms(config.muc_domain)
+          connector.list_rooms(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)

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

@@ -1,4 +1,3 @@
-require "lita/encoding_patches"
 require "lita/adapters/hipchat/callback"
 
 require "xmpp4r"
@@ -34,15 +33,21 @@ module Lita
           send_presence
         end
 
+        def join(muc_domain, room)
+          room_jid = normalized_jid(room, muc_domain, robot.name)
+          return if mucs[room_jid.bare.to_s]
+
+          muc = Jabber::MUC::SimpleMUCClient.new(client)
+          mucs[room_jid.bare.to_s] = muc
+
+          register_muc_message_callback(muc)
+
+          Lita.logger.info("Joining room: #{room_jid}.")
+          muc.join(room_jid)
+        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
+          rooms.each { |room| join(muc_domain, room) }
         end
 
         def list_rooms(muc_domain)
@@ -72,6 +77,12 @@ module Lita
           @mucs ||= {}
         end
 
+        def part(muc_domain, room)
+          room_jid = normalized_jid(room, muc_domain, robot.name)
+          muc = mucs[room_jid.bare.to_s]
+          muc.exit if muc
+        end
+
         def set_topic(room_jid, topic)
           muc = mucs[room_jid]
           if muc

data/lita-hipchat.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-hipchat"
-  spec.version       = "1.2.4"
+  spec.version       = "1.3.0"
   spec.authors       = ["Jimmy Cuadra"]
   spec.email         = ["jimmy@jimmycuadra.com"]
   spec.description   = %q{A HipChat adapter for Lita.}
@@ -15,11 +15,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "lita", ">= 2.5"
-  spec.add_runtime_dependency "xmpp4r", ">= 0.5"
+  spec.add_runtime_dependency "xmpp4r", ">= 0.5.6"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", ">= 2.14"
+  spec.add_development_dependency "rspec", ">= 3.0.0.beta2"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "coveralls"
 end

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

@@ -3,15 +3,15 @@ require "spec_helper"
 describe Lita::Adapters::HipChat::Callback, lita: true do
   subject { described_class.new(robot, roster) }
 
-  let(:robot) { double("Lita::Robot") }
+  let(:robot) { instance_double("Lita::Robot") }
   let(:roster) do
-    double("Jabber::Roster::Helper", items: { "user_id" => roster_item })
+    instance_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(:user) { instance_double("Lita::User", id: "user_id") }
+  let(:source) { instance_double("Lita::Source") }
+  let(:message) { instance_double("Lita::Message") }
   let(:roster_item) do
-    double("Jabber::Roster::RosterItem", attributes: {
+    instance_double("Jabber::Roster::RosterItem", attributes: {
       "jid" => "user_id",
       "name" => "Carl",
       "mention_name" => "@Carl"
@@ -36,9 +36,9 @@ describe Lita::Adapters::HipChat::Callback, lita: true do
   end
 
   describe "#private_message" do
-    let(:client) { double("Jabber::Client") }
+    let(:client) { instance_double("Jabber::Client") }
     let(:jabber_message) do
-      double("Jabber::Message", type: :chat, from: "user_id", body: "foo")
+      instance_double("Jabber::Message", type: :chat, from: "user_id", body: "foo")
     end
 
     before do
@@ -47,11 +47,7 @@ describe Lita::Adapters::HipChat::Callback, lita: true do
 
     it "sends the message to the robot with the proper source and body" do
       allow(Lita::Source).to receive(:new).with(user: user).and_return(source)
-      allow(Lita::Message).to receive(:new).with(
-        robot,
-        "foo",
-        source
-      ).and_return(message)
+      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)
@@ -71,39 +67,28 @@ describe Lita::Adapters::HipChat::Callback, lita: true do
   end
 
   describe "#muc_message" do
-    let(:jid) { double("Jabber::JID", bare: "room_id") }
-    let(:muc) { double("Jabber::MUC::SimpleMUCClient", jid: jid) }
+    let(:jid) { instance_double("Jabber::JID", bare: "room_id") }
+    let(:muc) { instance_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: user,
-        room: "room_id"
-      ).and_return(source)
-      allow(Lita::Message).to receive(:new).with(
-        robot,
-        "foo",
-        source
-      ).and_return(message)
+      allow(Lita::Source).to receive(:new).with(user: user, room: "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: {})
+      roster = instance_double("Jabber::Roster::Helper", items: {})
       allow(muc).to receive(:on_message).and_yield(nil, "Unknown", "foo")
       allow(Lita::Source).to receive(:new).with(
         user: an_instance_of(Lita::User),
         room: "room_id"
       ).and_return(source)
-      allow(Lita::Message).to receive(:new).with(
-        robot,
-        "foo",
-        source
-      ).and_return(message)
+      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
@@ -112,11 +97,7 @@ describe Lita::Adapters::HipChat::Callback, lita: true do
   describe "#roster_update" do
     it "finds/creates a user object for the roster item" do
       allow(roster).to receive(:add_update_callback).and_yield(nil, roster_item)
-      expect(Lita::User).to receive(:create).with(
-        "user_id",
-        name: "Carl",
-        mention_name: "@Carl"
-      )
+      expect(Lita::User).to receive(:create).with("user_id", name: "Carl", mention_name: "@Carl")
       subject.roster_update
     end
 

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

@@ -3,8 +3,15 @@ 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" ) }
+  let(:client) do
+    client = instance_double("Jabber::Client")
+    allow(client).to receive(:auth)
+    allow(client).to receive(:connect)
+    allow(client).to receive(:send)
+    client
+  end
+
+  let(:robot) { instance_double("Lita::Robot", name: "Lita" ) }
 
   before { allow(subject).to receive(:client).and_return(client) }
 
@@ -29,22 +36,23 @@ describe Lita::Adapters::HipChat::Connector, lita: true do
   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") }
+    let(:presence) { instance_double("Jabber::Presence") }
+    let(:callback) { instance_double("Lita::Adapters::HipChat::Callback") }
+    let(:roster) { instance_double("Jabber::Roster::Helper") }
+    let(:roster_item) do
+      instance_double("Jabber::Roster::RosterItem", attributes: { "mention_name" => "LitaBot"})
+    end
 
     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(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=)
+      allow(roster).to receive(:get_roster)
+      allow(roster).to receive(:wait_for_roster)
+      allow(roster).to receive(:[]).with(subject.jid).and_return(roster_item)
     end
 
     it "connects to HipChat" do
@@ -78,67 +86,58 @@ describe Lita::Adapters::HipChat::Connector, lita: true do
     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") }
+  describe "#join" do
+    let(:muc) { instance_double("Jabber::MUC::SimpleMUCClient") }
+    let(:callback) { instance_double("Lita::Adapters::HipChat::Callback") }
 
     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(Jabber::MUC::SimpleMUCClient).to receive(:new).with(client).and_return(muc)
+      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)
+      allow(muc).to receive(:join)
     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,
-      )
+    it "stores a SimpleMUCClient for the room" do
+      subject.join("conf.hipchat.com", "foo")
+      expect(subject.mucs["foo@conf.hipchat.com"]).to eq(muc)
     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)
+    it "registers a message callback" do
+      expect(callback).to receive(:muc_message).with(muc)
+      subject.join("conf.hipchat.com", "foo")
+    end
+
+    it "joins the room" do
+      expect(muc).to receive(:join)
+      subject.join("conf.hipchat.com", "foo")
     end
 
+    it "doesn't attempt to join a room it's already in" do
+      expect(callback).to receive(:muc_message).with(muc).once
+      expect(muc).to receive(:join).once
+      2.times { subject.join("conf.hipchat.com", "foo") }
+    end
+  end
+
+  describe "#join rooms" do
+    let(:rooms) { %w(foo bar) }
+
     it "joins each room" do
-      expect(muc_1).to receive(:join)
-      expect(muc_2).to receive(:join)
-      subject.join_rooms(muc_domain, rooms)
+      rooms.each { |room| expect(subject).to receive(:join).with("conf.hipchat.com", room) }
+      subject.join_rooms("conf.hipchat.com", rooms)
     end
   end
 
   describe "#list_rooms" do
-    let(:browser) { double("Jabber::MUC::MUCBrowser") }
+    let(:browser) { instance_double("Jabber::MUC::MUCBrowser") }
 
     before do
-      allow(Jabber::MUC::MUCBrowser).to receive(:new).with(client).and_return(
-        browser
-      )
+      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
@@ -154,16 +153,12 @@ describe Lita::Adapters::HipChat::Connector, lita: true do
   end
 
   describe "#message_jid" do
-    let(:message_1) { double("Jabber::Message") }
-    let(:message_2) { double("Jabber::Message") }
+    let(:message_1) { instance_double("Jabber::Message") }
+    let(:message_2) { instance_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
-      )
+      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)
@@ -174,7 +169,7 @@ describe Lita::Adapters::HipChat::Connector, lita: true do
 
   describe "#message_muc" do
     it "sends the messages to the room" do
-      muc = double("Jabber::MUC::SimpleMUCClient")
+      muc = instance_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")
@@ -182,9 +177,24 @@ describe Lita::Adapters::HipChat::Connector, lita: true do
     end
   end
 
+  describe "#part" do
+    let(:muc) { instance_double("Jabber::MUC::SimpleMUCClient") }
+
+    it "parts from a room" do
+      subject.mucs["#foo@conf.hipchat.com"] = muc
+      expect(muc).to receive(:exit)
+      subject.part("conf.hipchat.com", "#foo")
+    end
+
+    it "doesn't attempt to part from a room it's not in" do
+      expect(muc).not_to receive(:exit)
+      subject.part("conf.hipchat.com", "#foo")
+    end
+  end
+
   describe "#set_topic" do
     it "sets the room's topic to the supplied message" do
-      muc = double("Jabber::MUC::SimpleMUCClient")
+      muc = instance_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")

data/spec/lita/adapters/hipchat_spec.rb

@@ -14,19 +14,33 @@ describe Lita::Adapters::HipChat do
 
   subject { described_class.new(robot) }
 
-  let(:robot) { double("Lita::Robot") }
-  let(:connector) { double("Lita::Adapters::HipChat::Connector") }
+  let(:robot) { instance_double("Lita::Robot") }
+  let(:connector) { instance_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
+    Lita.config.adapter.jid = Lita.config.adapter.password = nil
     expect(Lita.logger).to receive(:fatal).with(/jid, password/)
     expect { subject }.to raise_error(SystemExit)
   end
 
+  describe "#join" do
+    it "joins a room" do
+      expect(subject.connector).to receive(:join).with("conf.hipchat.com", "#foo")
+      subject.join("#foo")
+    end
+  end
+
+  describe "#part" do
+    it "parts from a room" do
+      expect(subject.connector).to receive(:part).with("conf.hipchat.com", "#foo")
+      subject.part("#foo")
+    end
+  end
+
   describe "#run" do
     before do
       allow(subject.connector).to receive(:connect)
@@ -43,33 +57,22 @@ describe Lita::Adapters::HipChat do
 
     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
-      )
+      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"]
+      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
-      )
+      allow(subject.connector).to receive(:list_rooms).with("conf.hipchat.com").and_return(rooms)
+      expect(subject.connector).to receive(:join_rooms).with("conf.hipchat.com", 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
-      )
+      expect(subject.connector).to receive(:join_rooms).with("conf.hipchat.com",custom_rooms)
       subject.run
     end
 
@@ -87,28 +90,22 @@ describe Lita::Adapters::HipChat do
 
   describe "#send_messages" do
     it "sends messages to rooms" do
-      source = double("Lita::Source", room: "room_id", private_message?: false)
-      expect(subject.connector).to receive(:message_muc).with(
-        "room_id",
-        ["Hello!"]
-      )
+      source = instance_double("Lita::Source", room: "room_id", private_message?: false)
+      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", user: user, private_message?: true)
-      expect(subject.connector).to receive(:message_jid).with(
-        "user_id",
-        ["Hello!"]
-      )
+      user = instance_double("Lita::User", id: "user_id")
+      source = instance_double("Lita::Source", user: user, private_message?: true)
+      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")
+      source = instance_double("Lita::Source", room: "room_id")
       expect(subject.connector).to receive(:set_topic).with("room_id", "Topic")
       subject.set_topic(source, "Topic")
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-hipchat
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.3.0
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-17 00:00:00.000000000 Z
+date: 2014-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.5.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.5.6
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: 3.0.0.beta2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: 3.0.0.beta2
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -125,7 +125,6 @@ files:
 - 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

data/lib/lita/encoding_patches.rb

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