RubyGems - jabber4r-revive - Versions diffs - 0.9.0 - Mend

jabber4r-revive 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

data/.gitignore +4 -0
data/.rspec +3 -0
data/.travis.yml +8 -0
data/CHANGELOG +45 -0
data/Gemfile +3 -0
data/Gemfile.lock +45 -0
data/LICENSE +12 -0
data/README.md +29 -0
data/Rakefile +71 -0
data/jabber4r-revive.gemspec +25 -0
data/lib/jabber4r/bosh_session.rb +224 -0
data/lib/jabber4r/connection.rb +258 -0
data/lib/jabber4r/debugger.rb +61 -0
data/lib/jabber4r/jid.rb +125 -0
data/lib/jabber4r/protocol/iq.rb +260 -0
data/lib/jabber4r/protocol/message.rb +246 -0
data/lib/jabber4r/protocol/parsed_xml_element.rb +208 -0
data/lib/jabber4r/protocol/presence.rb +160 -0
data/lib/jabber4r/protocol/xml_element.rb +144 -0
data/lib/jabber4r/protocol.rb +257 -0
data/lib/jabber4r/rexml_1.8_patch.rb +16 -0
data/lib/jabber4r/roster.rb +322 -0
data/lib/jabber4r/session.rb +615 -0
data/lib/jabber4r/vcard.rb +42 -0
data/lib/jabber4r/version.rb +3 -0
data/lib/jabber4r.rb +33 -0
data/spec/lib/jabber4r/bosh_session_spec.rb +150 -0
data/spec/lib/jabber4r/connection_spec.rb +174 -0
data/spec/lib/jabber4r/debugger_spec.rb +36 -0
data/spec/lib/jabber4r/jid_spec.rb +198 -0
data/spec/spec_helper.rb +11 -0
data/spec/support/mocks/tcp_socket_mock.rb +8 -0
metadata +151 -0

data/lib/jabber4r/vcard.rb ADDED Viewed

@@ -0,0 +1,42 @@
+# License: see LICENSE.txt
+#  Jabber4R - Jabber Instant Messaging Library for Ruby
+#  Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+#
+module Jabber
+  ##
+  # The VCard class holds the parsed VCard data from the Jabber service.
+  #
+  class VCard
+    attr_accessor :given, :family, :middle, :nickname, :email
+    ##
+    # Factory to create the VCard from the ParsedXMLElement
+    #
+    # je:: [ParsedXMLElement] The VCard as an xml element.
+    # return:: [Jabber::VCard] The newly created VCard.
+    #
+    def VCard.from_element(je)
+      card = VCard.new
+      return card unless je
+      card.given = je.N.GIVEN.element_data
+      card.family = je.N.FAMILY.element_data
+      card.middle = je.N.MIDDLE.element_data
+      card.email = je.EMAIL.element_data
+      card.nickname = je.NICKNAME.element_data
+      return card
+    end
+    ##
+    # Dumps the attributes of the VCard
+    #
+    # return:: [String] The VCard as a string.
    #
+    def to_s
+      "VCARD: [first=#{@given} last=#{@family} nick=#{@nickname} email=#{@email}]"
+    end
+  end
+end

data/lib/jabber4r/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Jabber
+  VERSION = "0.9.0"
+end

data/lib/jabber4r.rb ADDED Viewed

@@ -0,0 +1,33 @@
+# License: see LICENSE.txt
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# The Jabber module is the main namespace for all Jabber modules
+# and classes.
+module Jabber
+  DEBUG = false
+  # Public: Should raise if connection was force closed
+  class ConnectionForceCloseError < StandardError; end
+  # Public: Should raise if received XML data is malformed
+  class XMLMalformedError < StandardError; end
+  # Public: Should raise if authentication failed
+  class AuthenticationError < StandardError; end
+end
+require "jabber4r/debugger"
+require "jabber4r/session"
+require "jabber4r/bosh_session"
+require "jabber4r/protocol"
+require "jabber4r/connection"
+require "jabber4r/protocol/iq"
+require "jabber4r/protocol/presence"
+require "jabber4r/protocol/message"
+require "jabber4r/protocol/xml_element"
+require "jabber4r/protocol/parsed_xml_element"
+require "jabber4r/roster"
+require "jabber4r/jid"
+require "jabber4r/vcard"

data/spec/lib/jabber4r/bosh_session_spec.rb ADDED Viewed

@@ -0,0 +1,150 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::BoshSession do
+  let(:successful_login) { '<body xmlns="http://jabber.org/protocol/httpbind"><iq type="result" xmlns="jabber:client" id="2034"/></body>' }
+  let(:successful_open_stream) do
+    [
+      '<body xmlns="http://jabber.org/protocol/httpbind" xmlns:xmpp="urn:xmpp:xbosh" xmlns:stream="http://etherx.jabber.org/streams"',
+      'authid="3780309894" sid="ce21410" from="localhost"',
+      'wait="60" requests="2" inactivity="30" maxpause="120" polling="2" ver="1.8" secure="true" />'
+    ].join " "
+  end
+  let(:is_open_stream?) { ->(data) { x = Ox.parse(data); ["1", "localhost"] == [x[:rid], x[:to]] } }
+  let(:is_login?) { ->(data) { x = Ox.parse(data); ["1", "ce21410"] == [x[:rid], x[:sid]] } }
+  let(:bosh_session) { described_class.bind("strech@localhost/resource", "password") }
+  before { Jabber::BoshSession.any_instance.stub(:generate_next_rid).and_return "1" }
+  describe "#bind" do
+    context "when session successfuly binded" do
+      before do
+        stub_request(:post, "http://localhost:5280/http-bind")
+          .with(body: is_open_stream?)
+          .to_return(body: successful_open_stream)
+        stub_request(:post, "http://localhost:5280/http-bind")
+          .with(body: is_login?)
+          .to_return(body: successful_login)
+      end
+      it { expect(bosh_session).to be_alive }
+    end
+    context "when couldn't open stream" do
+      context "when response body missed authid attribute" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind" sid="ce21410" />' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: malformed_body)
+          WebMock.should_not have_requested(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::XMLMalformedError, "Couldn't find <body /> attribute [authid]" }
+      end
+      context "when response body missed sid attribute" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind" authid="3780309894" />' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: malformed_body)
+          WebMock.should_not have_requested(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::XMLMalformedError, "Couldn't find <body /> attribute [sid]" }
+      end
+      context "when response was not 200 OK" do
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: "Foo", status: 401)
+          WebMock.should_not have_requested(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+        end
+        it { expect { bosh_session }.to raise_error Net::HTTPBadResponse }
+      end
+    end
+    context "when couldn't login in opened stream" do
+      context "when response is a malformed xml without IQ tag" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind"></body>' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: successful_open_stream)
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+            .to_return(body: malformed_body)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::XMLMalformedError, "Couldn't find xml tag <iq/>" }
+      end
+      context "when response has type not equal 'result'" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind"><iq type="error" xmlns="jabber:client" id="2034"/></body>' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: successful_open_stream)
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+            .to_return(body: malformed_body)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::AuthenticationError, "Failed to login" }
+      end
+      context "when response was not 200 OK" do
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: successful_open_stream)
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+            .to_return(body: "Foo", status: 401)
+        end
+        it { expect { bosh_session }.to raise_error Net::HTTPBadResponse }
+      end
+    end
+  end
+  describe "#to_json" do
+    let(:json) { JSON.parse(bosh_session.to_json) }
+    before do
+      stub_request(:post, "http://localhost:5280/http-bind")
+        .with(body: is_open_stream?)
+        .to_return(body: successful_open_stream)
+      stub_request(:post, "http://localhost:5280/http-bind")
+        .with(body: is_login?)
+        .to_return(body: successful_login)
+    end
+    it { expect(json).to have_key "jid" }
+    it { expect(json).to have_key "rid" }
+    it { expect(json).to have_key "sid" }
+    it { expect(json["jid"]).to eq "strech@localhost/resource"}
+    it { expect(json["rid"]).to eq "1"}
+    it { expect(json["sid"]).to eq "ce21410"}
+  end
+end

data/spec/lib/jabber4r/connection_spec.rb ADDED Viewed

@@ -0,0 +1,174 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::Connection do
+  let(:socket) { TCPSocketMock.new }
+  let(:connection) { described_class.new "localhost" }
+  before { TCPSocket.stub(:new).and_return socket }
+  describe "#connect" do
+    before { connection.connect }
+    it { expect(connection).to be_connected }
+    it { expect(connection.poll_thread).to be_alive }
+    it { expect(connection.parser_thread).to be_alive }
+    it { expect(connection.socket).not_to be_closed }
+  end
+  describe "#close" do
+    before { connection.connect }
+    before { connection.close; sleep 0.01 }
+    it { expect(connection).to be_disconnected }
+    it { expect(connection.poll_thread).not_to be_alive }
+    it { expect(connection.parser_thread).not_to be_alive }
+    it { expect(connection.socket).to be_closed }
+  end
+  describe "#add_filter" do
+    context "when filter name and block is given" do
+      before { connection.add_filter("hello") { 1 } }
+      it { expect(connection.filters).to have_key "hello" }
+    end
+    context "when only filter name give" do
+      it { expect { connection.add_filter("hello") }.to raise_error ArgumentError }
+    end
+  end
+  describe "#remove_filter" do
+    before { connection.add_filter("hello") { 1 } }
+    it { expect(connection.filters).to have_key "hello" }
+    it "should remove filter" do
+      connection.remove_filter("hello")
+      expect(connection.filters).not_to have_key "hello"
+    end
+  end
+  describe "#send" do
+    let(:handler) { proc { 1 } }
+    before { connection.connect }
+    before { Thread.stub(:current).and_return "current" }
+    context "when own handler is given" do
+      before { connection.send("hello", handler) }
+      it { expect(connection.handlers).to have_key "current" }
+      it { expect(connection.handlers["current"]).to eq handler }
+      describe "socket" do
+        it { expect(socket.to_s).to eq "hello" }
+      end
+    end
+    context "when only block is given" do
+      before { connection.send("hello") { 1 } }
+      it { expect(connection.handlers).to have_key "current" }
+    end
+    context "when handler and block are given" do
+      before { connection.send("hello", handler) { 1 } }
+      it { expect(connection.handlers).to have_key "current" }
+      it { expect(connection.handlers["current"]).to eq handler }
+    end
+    context "when no handlers and block are given" do
+      before { connection.send("hello") }
+      it { expect(connection.handlers).to be_empty }
+    end
+  end
+  describe "#receive" do
+    let(:thread) { double("Pseudo thread", alive?: true) }
+    let(:element) { double("XML Element", element_consumed?: false) }
+    let(:consume) { ->(element) { element.stub(:element_consumed?).and_return true } }
+    let(:skip) { ->(element) { element.stub(:element_consumed?).and_return false } }
+    before { connection.stub :register_parsing_thread }
+    before { connection.stub :register_polling_thread }
+    context "when handlers are not empty" do
+      context "when filters are empty" do
+        before do
+          thread.should_receive(:wakeup)
+          connection.stub(:handlers).and_return({thread => consume})
+          connection.receive(element)
+        end
+        it { expect(connection.handlers).to be_empty }
+        it { expect(connection.filters).to be_empty }
+      end
+      context "when filters are not empty" do
+        context "when handler consume element" do
+          before do
+            thread.should_receive(:wakeup)
+            skip.should_not_receive(:call)
+            connection.stub(:handlers).and_return({thread => consume})
+            connection.stub(:filters).and_return({f1: skip})
+            connection.receive(element)
+          end
+          it { expect(connection.handlers).to be_empty }
+          it { expect(connection.filters).not_to be_empty }
+        end
+        context "when handler doesn't consume element" do
+          before do
+            thread.should_not_receive(:wakeup)
+            consume.should_receive(:call).and_call_original
+            connection.stub(:handlers).and_return({thread => skip})
+            connection.stub(:filters).and_return({f1: consume})
+            connection.receive(element)
+          end
+          it { expect(connection.handlers).not_to be_empty }
+          it { expect(connection.filters).not_to be_empty }
+        end
+      end
+    end
+    context "when handlers are empty" do
+      context "when filters are empty" do
+        before do
+          thread.should_not_receive(:wakeup)
+          connection.should_receive(:wait_for_consume?).and_return false
+          connection.receive(element)
+        end
+        it { expect(connection.handlers).to be_empty }
+        it { expect(connection.filters).to be_empty }
+      end
+      context "when filters are not empty" do
+        before do
+          thread.should_not_receive(:wakeup)
+          consume.should_receive(:call).and_call_original
+          connection.stub(:filters).and_return({f1: consume})
+          connection.receive(element)
+        end
+        it { expect(connection.handlers).to be_empty }
+        it { expect(connection.filters).not_to be_empty }
+      end
+    end
+    # TODO : When socket is empty?
+  end
+end

data/spec/lib/jabber4r/debugger_spec.rb ADDED Viewed

@@ -0,0 +1,36 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::Debugger do
+  let(:debugger) { described_class.clone.instance }
+  before { described_class.stub(:instance).and_return debugger }
+  describe "#initialize" do
+    it { expect(described_class).not_to be_enabled }
+  end
+  describe "#enable" do
+    before { described_class.enable! }
+    it { expect(described_class).to be_enabled }
+  end
+  describe "#disable" do
+    before { described_class.disable! }
+    it { expect(described_class).not_to be_enabled }
+  end
+  describe "#logger=" do
+    let(:logger) { double("Logger") }
+    before { described_class.logger = logger }
+    it { expect(debugger.logger).to eq logger }
+  end
+  describe "generated methods" do
+    it { expect(described_class).to respond_to :warn }
+    it { expect(described_class).to respond_to :info }
+    it { expect(described_class).to respond_to :debug }
+  end
+end

data/spec/lib/jabber4r/jid_spec.rb ADDED Viewed

@@ -0,0 +1,198 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::JID do
+  describe "#initialize" do
+    context "when need parse jid from string" do
+      context "when only node given" do
+        it { expect { described_class.new "user" }.to raise_error ArgumentError }
+      end
+      context "when node and host given" do
+        subject { described_class.new "user@localhost" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should be_nil }
+      end
+      context "when node, host and resource given" do
+        subject { described_class.new "user@localhost/attach" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should eq "attach" }
+      end
+      context "when empty string given" do
+        it { expect { described_class.new "" }.to raise_error ArgumentError }
+      end
+    end
+    context "when extra arguments given" do
+      context "when only host given" do
+        subject { described_class.new "user", "localhost" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+      end
+      context "when host and resource given" do
+        subject { described_class.new "user", "localhost", "attach" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should eq "attach" }
+      end
+      context "when node is fully loaded and host, resource given" do
+        subject { described_class.new "user@example.com/bind", "localhost", "attach" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should eq "attach" }
+      end
+    end
+  end
+  describe "#strip" do
+    subject { described_class.new(args).strip }
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost" }
+      its(:to_s) { should eq "strech@localhost" }
+    end
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost/pewpew" }
+      its(:to_s) { should eq "strech@localhost" }
+    end
+  end
+  describe "#strip!" do
+    subject { described_class.new(args).strip! }
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost" }
+      its(:to_s) { should eq "strech@localhost" }
+      its(:resource) { should be_nil }
+    end
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost/pewpew" }
+      its(:to_s) { should eq "strech@localhost" }
+      its(:resource) { should be_nil }
+    end
+  end
+  describe "#hash" do
+    let(:hash) { "strech@pewpew/one".hash }
+    subject { described_class.new "strech@pewpew/one" }
+    its(:hash) { should eq hash }
+  end
+  describe "#to_s" do
+    context "when only host and domain exists" do
+      subject { described_class.new("strech", "localhost").to_s }
+      it { should eq "strech@localhost" }
+    end
+    context "when only host and domain exists" do
+      subject { described_class.new("strech", "localhost", "attach-resource").to_s }
+      it { should eq "strech@localhost/attach-resource" }
+    end
+  end
+  describe "#==" do
+    subject { jid1 == jid2 }
+    context "when jids are equal" do
+      let(:jid1) { described_class.new "strech@localhost" }
+      let(:jid2) { described_class.new "strech@localhost" }
+      it { should be_true }
+    end
+    context "when jids are not equal" do
+      let(:jid1) { described_class.new "strech@localhost" }
+      let(:jid2) { described_class.new "strech@localhost/resource1" }
+      it { should be_false }
+    end
+  end
+  describe "#same?" do
+    subject { jid1.same? jid2 }
+    context "when jids are equal" do
+      context "when jid1 and jid2 has no resource" do
+        let(:jid1) { described_class.new "strech@localhost" }
+        let(:jid2) { described_class.new "strech@localhost" }
+        it { should be_true }
+      end
+      context "when jid1 has resource, but jid2 not" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@localhost" }
+        it { should be_true }
+      end
+      context "when jid1 and jid2 has resources" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@localhost/hola" }
+        it { should be_true }
+      end
+    end
+    context "when jids are not equal" do
+      context "when jid1 and jid2 has no resource" do
+        let(:jid1) { described_class.new "strech@localhost" }
+        let(:jid2) { described_class.new "strech@gmail.com" }
+        it { should be_false }
+      end
+      context "when jid1 has resource, but jid2 not" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@gmail.com" }
+        it { should be_false }
+      end
+      context "when jid1 and jid2 has resources" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@gmail.com/hola" }
+        it { should be_false }
+      end
+    end
+  end
+  describe "::to_jid" do
+    subject { Jabber::JID.to_jid jid }
+    context "when jid is a Jabber::JID" do
+      let(:jid) { described_class.new "strech@localhost" }
+      its(:object_id) { should eq jid.object_id }
+      its(:to_s) { should eq "strech@localhost" }
+    end
+    context "when jid is a String" do
+      let(:jid) { "strech@localhost/resource" }
+      its(:object_id) { should_not eq jid.object_id }
+      its(:to_s) { should eq "strech@localhost/resource" }
+    end
+  end
+end