xmppify 0.0.12

data/app/assets/javascripts/xmpp/strophejs-plugins/caps/strophe.caps.jsonly.js

@@ -0,0 +1,240 @@
+/**
+ * Entity Capabilities (XEP-0115)
+ *
+ * Depends on disco plugin.
+ *
+ * See: http://xmpp.org/extensions/xep-0115.html
+ *
+ * Authors:
+ *   - Michael Weibel <michael.weibel@gmail.com>
+ *
+ * Copyright:
+ *   - Michael Weibel <michael.weibel@gmail.com>
+ */
+
+ Strophe.addConnectionPlugin('caps', {
+	/** Constant: HASH
+	 * Hash used
+	 *
+	 * Currently only sha-1 is supported.
+	 */
+	HASH: 'sha-1',
+	/** Variable: node
+	 * Client which is being used.
+	 *
+	 * Can be overwritten as soon as Strophe has been initialized.
+	 */
+	node: 'http://strophe.im/strophejs/',
+	/** PrivateVariable: _ver
+	 * Own generated version string
+	 */
+	_ver: '',
+	/** PrivateVariable: _connection
+	 * Strophe connection
+	 */
+	_connection: null,
+	/** PrivateVariable: _knownCapabilities
+	 * A hashtable containing version-strings and their capabilities, serialized
+	 * as string.
+	 *
+	 * TODO: Maybe those caps shouldn't be serialized.
+	 */
+	_knownCapabilities: {},
+	/** PrivateVariable: _jidVerIndex
+	 * A hashtable containing jids and their versions for better lookup of capabilities.
+	 */
+	_jidVerIndex: {},
+
+	/** Function: init
+	 * Initialize plugin:
+	 *   - Add caps namespace
+	 *   - Add caps feature to disco plugin
+	 *   - Add handler for caps stanzas
+	 *
+	 * Parameters:
+	 *   (Strophe.Connection) conn - Strophe connection
+	 */
+	init: function(conn) {
+		this._connection = conn;
+
+		Strophe.addNamespace('CAPS', 'http://jabber.org/protocol/caps');
+
+		if (!this._connection.disco) {
+			throw "Caps plugin requires the disco plugin to be installed.";
+		}
+
+		this._connection.disco.addFeature(Strophe.NS.CAPS);
+		this._connection.addHandler(this._delegateCapabilities.bind(this), Strophe.NS.CAPS);
+	},
+
+	/** Function: generateCapsAttrs
+	 * Returns the attributes for generating the "c"-stanza containing the own version
+	 *
+	 * Returns:
+	 *   (Object) - attributes
+	 */
+	generateCapsAttrs: function() {
+		return {
+			'xmlns': Strophe.NS.CAPS,
+			'hash': this.HASH,
+			'node': this.node,
+			'ver': this.generateVer()
+		};
+	},
+
+	/** Function: generateVer
+	 * Returns the base64 encoded version string (encoded itself with sha1)
+	 *
+	 * Returns:
+	 *   (String) - version
+	 */
+	generateVer: function() {
+		if (this._ver !== "") {
+			return this._ver;
+		}
+
+		var ver = "",
+			identities = this._connection.disco._identities.sort(this._sortIdentities),
+			identitiesLen = identities.length,
+			features = this._connection.disco._features.sort(),
+			featuresLen = features.length;
+		for(var i = 0; i < identitiesLen; i++) {
+			var curIdent = identities[i];
+			ver += curIdent.category + "/" + curIdent.type + "/" + curIdent.lang + "/" + curIdent.name + "<";
+		}
+		for(var i = 0; i < featuresLen; i++) {
+			ver += features[i] + '<';
+		}
+
+		this._ver = b64_sha1(ver);
+		return this._ver;
+	},
+
+	/** Function: getCapabilitiesByJid
+	 * Returns serialized capabilities of a jid (if available).
+	 * Otherwise null.
+	 *
+	 * Parameters:
+	 *   (String) jid - Jabber id
+	 *
+	 * Returns:
+	 *   (String|null) - capabilities, serialized; or null when not available.
+	 */
+	getCapabilitiesByJid: function(jid) {
+		if (this._jidVerIndex[jid]) {
+			return this._knownCapabilities[this._jidVerIndex[jid]];
+		}
+		return null;
+	},
+
+	/** PrivateFunction: _delegateCapabilities
+	 * Checks if the version has already been saved.
+	 * If yes: do nothing.
+	 * If no: Request capabilities
+	 *
+	 * Parameters:
+	 *   (Strophe.Builder) stanza - Stanza
+	 *
+	 * Returns:
+	 *   (Boolean)
+	 */
+	_delegateCapabilities: function(stanza) {
+		var from = stanza.getAttribute('from'),
+			c = stanza.querySelector('c'),
+			ver = c.getAttribute('ver'),
+			node = c.getAttribute('node');
+		if (!this._knownCapabilities[ver]) {
+			return this._requestCapabilities(from, node, ver);
+		} else {
+			this._jidVerIndex[from] = ver;
+		}
+		if (!this._jidVerIndex[from] || !this._jidVerIndex[from] !== ver) {
+			this._jidVerIndex[from] = ver;
+		}
+		return true;
+	},
+
+	/** PrivateFunction: _requestCapabilities
+	 * Requests capabilities from the one which sent the caps-info stanza.
+	 * This is done using disco info.
+	 *
+	 * Additionally, it registers a handler for handling the reply.
+	 *
+	 * Parameters:
+	 *   (String) to - Destination jid
+	 *   (String) node - Node attribute of the caps-stanza
+	 *   (String) ver - Version of the caps-stanza
+	 *
+	 * Returns:
+	 *   (Boolean) - true
+	 */
+	_requestCapabilities: function(to, node, ver) {
+		if (to !== this._connection.jid) {
+			var id = this._connection.disco.info(to, node + '#' + ver);
+			this._connection.addHandler(this._handleDiscoInfoReply.bind(this), Strophe.NS.DISCO_INFO, 'iq', 'result', id, to);
+		}
+		return true;
+	},
+
+	/** PrivateFunction: _handleDiscoInfoReply
+	 * Parses the disco info reply and adds the version & it's capabilities to the _knownCapabilities variable.
+	 * Additionally, it adds the jid & the version to the _jidVerIndex variable for a better lookup.
+	 *
+	 * Parameters:
+	 *   (Strophe.Builder) stanza - Disco info stanza
+	 *
+	 * Returns:
+	 *   (Boolean) - false, to automatically remove the handler.
+	 */
+	_handleDiscoInfoReply: function(stanza) {
+		var query = stanza.querySelector('query'),
+			node = query.getAttribute('node').split('#'),
+			ver = node[1],
+			from = stanza.getAttribute('from');
+		if (!this._knownCapabilities[ver]) {
+			var childNodes = query.childNodes,
+				childNodesLen = childNodes.length;
+			this._knownCapabilities[ver] = [];
+			for(var i = 0; i < childNodesLen; i++) {
+				var node = childNodes[i];
+				this._knownCapabilities[ver].push({name: node.nodeName, attributes: node.attributes});
+			}
+			this._jidVerIndex[from] = ver;
+		} else if (!this._jidVerIndex[from] || !this._jidVerIndex[from] !== ver) {
+			this._jidVerIndex[from] = ver;
+		}
+		return false;
+	},
+
+	/** PrivateFunction: _sortIdentities
+	 * Sorts two identities according the sorting requirements in XEP-0115.
+	 *
+	 * Parameters:
+	 *   (Object) a - Identity a
+	 *   (Object) b - Identity b
+	 *
+	 * Returns:
+	 *   (Integer) - 1, 0 or -1; according to which one's greater.
+	 */
+	_sortIdentities: function(a, b) {
+		if (a.category > b.category) {
+			return 1;
+		}
+		if (a.category < b.category) {
+			return -1;
+		}
+		if (a.type > b.type) {
+			return 1;
+		}
+		if (a.type < b.type) {
+			return -1;
+		}
+		if (a.lang > b.lang) {
+			return 1;
+		}
+		if (a.lang < b.lang) {
+			return -1;
+		}
+		return 0;
+	}
+ });

data/app/assets/javascripts/xmpp/strophejs-plugins/chatstates/strophe.chatstates.js

@@ -0,0 +1,80 @@
+/**
+ * Chat state notifications (XEP 0085) plugin
+ * @see http://xmpp.org/extensions/xep-0085.html
+ */
+Strophe.addConnectionPlugin('chatstates',
+{
+	init: function (connection)
+	{
+		this._connection = connection;
+
+		Strophe.addNamespace('CHATSTATES', 'http://jabber.org/protocol/chatstates');
+	},
+
+	statusChanged: function (status)
+	{
+		if (status === Strophe.Status.CONNECTED
+			|| status === Strophe.Status.ATTACHED)
+		{
+			this._connection.addHandler(this._notificationReceived.bind(this),
+				Strophe.NS.CHATSTATES, "message");
+		}
+	},
+
+	addActive: function(message)
+	{
+		return message.c('active', {xmlns: Strophe.NS.CHATSTATES}).up();
+	},
+
+	_notificationReceived: function(message)
+	{
+		var composing = $(message).find('composing'),
+		paused = $(message).find('paused'),
+		active = $(message).find('active'),
+		jid = $(message).attr('from');
+
+		if (composing.length > 0)
+		{
+			$(document).trigger('composing.chatstates', jid);
+		}
+
+		if (paused.length > 0)
+		{
+			$(document).trigger('paused.chatstates', jid);
+		}
+
+		if (active.length > 0)
+		{
+			$(document).trigger('active.chatstates', jid);
+		}
+
+		return true;
+	},
+
+	sendActive: function(jid, type)
+	{
+		this._sendNotification(jid, type, 'active');
+	},
+
+	sendComposing: function(jid, type)
+	{
+		this._sendNotification(jid, type, 'composing');
+	},
+
+	sendPaused: function(jid, type)
+	{
+		this._sendNotification(jid, type, 'paused');
+	},
+
+	_sendNotification: function(jid, type, notification)
+	{
+		if (!type) type = 'chat';
+
+		this._connection.send($msg(
+		{
+			to: jid,
+			type: type
+		})
+		.c(notification, {xmlns: Strophe.NS.CHATSTATES}));
+	}
+});

data/app/assets/javascripts/xmpp/strophejs-plugins/cmds/README.markdown

@@ -0,0 +1,47 @@
+# strophe.cmds.js
+
+strophe.cmds.js is a plugin to provide Ad-Hoc Commands
+( [XEP-0050](http://xmpp.org/extensions/xep-0050.html) ).
+
+## Usage
+
+### Client side
+
+    cmd = new Strophe.Commands.RemoteCommand(conn, jid, node);
+
+    cmd.execute({
+
+      success: function(res, cmd){
+
+        proccessFields( cmd.form.fields );
+        doSomething();
+        resp = new Strophe.x.Form();
+        cmd.complete({ responseForm: resp });
+
+      error: myErrorFunction
+
+    }});
+
+You can also use the interactive GUI mode
+
+    cmd.execute({gui:true});
+
+### Server side
+
+## Dependencies
+
+- strophe.disco.js
+- strophe.x.js
+- jQuery
+- jQueryUI (for GUI mode)
+
+## ToDo
+
+- Write specs for UI commands
+- Write better documentation
+
+## Authors
+
+- [amaierhofer](https://github.com/amaierhofer)
+- [tjahma](https://github.com/tjahma)
+- [flosse](https://github.com/flosse)

data/app/assets/javascripts/xmpp/strophejs-plugins/cmds/spec/GetUrlComamndSpec.js

@@ -0,0 +1,66 @@
+describe("GetUrlCommand", function() {
+	var mockGetUrl = function(onSuccess, onError) {
+		var mockData = ['http://www.google.com', 'chrome://newtab'];
+		onSuccess.call(this,mockData);
+	}, c;
+
+	beforeEach(function() {
+		c = mockConnection();
+		iq = { type: 'set', to: 'n@d/r2', from: 'n@d/r1', id: 'ab6fa'};
+		success = jasmine.createSpy('success');
+	});
+
+	it("called with no urls", function() {
+		c.cmds.add(Strophe.Commands.create('getUrls', mockGetUrl));
+		spyon(c,'send',function(res) { expect(res.find('url').length).toEqual(0); });
+		c.cmds.exec('n@d/r', 'getUrls');
+	});
+
+	it("called with no urls also calls callback", function() {
+		c.cmds.add(Strophe.Commands.create('getUrls', mockGetUrl));
+		spyon(c,'send',function(req) {
+			var res = $iq({type: 'result', id: req.attr('id')});
+			c._dataRecv(createRequest(res));
+		});
+		c.cmds.execute('n@d/r', 'getUrls', { success: success});
+		expect(success).toHaveBeenCalled();
+	});
+	it("#GetUrls calls callback and sends urls in response", function() {
+		var req = $iq(iq).c('command', { xmlns: Strophe.NS.COMMANDS, node: 'getUrls' });
+		c.cmds.add(Strophe.Commands.create('getUrls', mockGetUrl));
+		spyon(c,'send',function(res) {
+			expect(res.find('url').length).toEqual(2);
+		});
+		receive(c,req);
+	});
+
+	it("#SetUrls calls callback with urls received in request", function() {
+		var req = $iq(iq).c('command', { xmlns: Strophe.NS.COMMANDS, node: 'setUrls' });
+		req.c('url').t('http://www.google.com').up();
+		req.c('url').t('chrome://newtab');
+
+		var callback = jasmine.createSpy('callback').andCallFake(function(onSuccess,onError) {
+			expect($(this.req).find('url').length).toEqual(2);
+			onSuccess.call(this,{});
+		});
+		var cmd = Strophe.Commands.create('setUrls', callback);
+		c.cmds.add(cmd);
+		spyon(c,'send',function(res) {
+			expect(res.find('command').attr('status')).toEqual('completed');
+		});
+		receive(c,req);
+		expect(cmd.callback).toHaveBeenCalled();
+	});
+
+	it("populates request for known command", function() {
+		var cmd = Strophe.Commands.create('setUrls', function() {});
+		var urls = ['http://www.google.com', 'chrome://newtab'];
+		c.cmds.add(cmd);
+		spyon(c,'send',function(res) {
+			expect(res.find('url').length).toEqual(2);
+			expect(res.find('url:eq(0)').text()).toEqual('http://www.google.com');
+		});
+		c.cmds.execute('n@d/r', 'setUrls', {data:urls});
+	});
+
+});

data/app/assets/javascripts/xmpp/strophejs-plugins/cmds/spec/strophe.cmds.spec.coffee

@@ -0,0 +1,145 @@
+describe "Commands", ->
+
+  beforeEach ->
+    @c = mockConnection()
+    @iq =
+      to: "n@d/r2"
+      from: "n@d/r1"
+      type: "get"
+      id: "abc"
+
+  it "disco#info includes command feature", ->
+    req = $iq(@iq).c("query", xmlns: Strophe.NS.DISCO_INFO)
+    spyon @c, "send", (res) ->
+      feat = ( ($ f).attr("var") for f in res.find "feature" )
+      (expect Strophe.NS.COMMANDS in feat).toBeTruthy()
+    receive @c, req
+
+  it "disco#items includes added commands", ->
+    @c.cmds.add { node: "a" }
+    req = $iq(@iq).c "query",
+      xmlns: Strophe.NS.DISCO_ITEMS
+      node: Strophe.NS.COMMANDS
+
+    spyon @c, "send", (res) ->
+      items = $(res[0]).find "item[node='a']"
+      expect(items.first().attr("node")).toEqual "a"
+      expect(items.first().attr("jid")).toEqual "n@d/r2"
+
+    receive @c, req
+
+  it "responds to command execution", ->
+    @c.cmds.add
+      node: "a"
+      name: "aName"
+
+    iq = $iq(type: "set").c("command",{
+      action: "execute"
+      node: "a"
+      xmlns: Strophe.NS.COMMANDS })
+
+    spyon @c, "send", (res) ->
+      expect(res.find("command").attr("status")).toEqual "completed"
+    receive @c, iq
+
+  it "responds with notFound for unknown command", ->
+    iq = $iq(type: "set").c "command",
+      action: "execute"
+      node: "a"
+      xmlns: Strophe.NS.COMMANDS
+
+    spyon @c, "send", (res) -> expect(res.find("item-not-found").length).toEqual 1
+    receive @c, iq
+
+  it "can execute command", ->
+    console.warn "exec"
+    spyon @c, "send", (req) ->
+      expect(req.find("command").attr("node")).toEqual "aCmd"
+      expect(req.find("command").attr("action")).toEqual "execute"
+
+    @c.cmds.execute "n@d/r", "aCmd"
+    expect(@c.send).toHaveBeenCalled()
+
+  it "can execute command with data", ->
+    @c.cmds.add
+      name: "foo"
+      node: "foo"
+      item: "foo"
+
+    spyon @c, "send", (req) ->
+      expect(req.find("command").attr("node")).toEqual "foo"
+      expect(req.find("command").attr("action")).toEqual "execute"
+      expect(req.find("foo").size()).toEqual 2
+      expect(req.find("command foo").size()).toEqual 0
+
+    @c.cmds.execute "n@d/r", "foo", { data: [ "foo", "bar" ] }
+    expect(@c.send).toHaveBeenCalled()
+
+    describe "Command", ->
+
+      beforeEach ->
+        @c = mockConnection()
+        @c.cmds.add name: "foo", node: "foo"
+        @cmd = new Strophe.Commands.RemoteCommand @c, "n@d/r", "foo"
+
+      it "has the correct properties", ->
+        (expect @cmd.jid).toEqual "n@d/r"
+        (expect @cmd.node).toEqual "foo"
+
+      it "can be converted to an iq object", ->
+
+        iq = $iq(to: "n@d/r", type: "set").c "command",
+          xmlns: Strophe.NS.COMMANDS
+          node: "foo"
+          action: "execute"
+
+        (expect @cmd.toIQ().toString()).toEqual iq.toString()
+
+      it "can be executed", ->
+        spyon @c, "send", (req) ->
+          expect(req.find("command").attr("node")).toEqual "foo"
+          expect(req.find("command").attr("action")).toEqual "execute"
+
+        @cmd.execute()
+        expect(@c.send).toHaveBeenCalled()
+
+      it "can be canceled", ->
+        @cmd.execute()
+        spyon @c, "send", (req) ->
+          expect(req.find("command").attr("action")).toEqual "cancel"
+
+        @cmd.cancel()
+        expect(@c.send).toHaveBeenCalled()
+
+      it "can exectute the 'next' action", ->
+        @cmd.execute()
+        spyon @c, "send", (req) ->
+          expect(req.find("command").attr("action")).toEqual "next"
+
+        @cmd.next()
+        expect(@c.send).toHaveBeenCalled()
+
+      it "can exectute the 'prev' action", ->
+        @cmd.execute()
+        spyon @c, "send", (req) ->
+          expect(req.find("command").attr("action")).toEqual "prev"
+
+        @cmd.prev()
+        expect(@c.send).toHaveBeenCalled()
+
+      it "can exectute the 'complete' action", ->
+        @cmd.execute()
+        spyon @c, "send", (req) ->
+          expect(req.find("command").attr("action")).toEqual "complete"
+
+        @cmd.complete()
+        expect(@c.send).toHaveBeenCalled()
+
+      it "holds all allowed actions based on the current stage", ->
+
+        spyon @c, "send", (res) ->
+          console.log res
+          expect(res.find("command").attr("status")).toEqual "completed"
+        receive @c, @cmd.toIQ()
+
+        (expect @cmd.actions).toEqual []

data/app/assets/javascripts/xmpp/strophejs-plugins/cmds/spec/support/jasmine.json

@@ -0,0 +1,16 @@
+{
+ "src_dir"  : "/public/javascript/",
+ "spec_dir" : "/spec/",
+
+ "server":{
+   "port":8124
+ },
+ "externals":[
+  "http://localhost/jslibs/jquery.js",
+  "http://localhost/jslibs/underscore.js",
+  "http://localhost/jslibs/strophe.js",
+  "http://localhost/jslibs/strophe.roster.js",
+  "http://localhost/jslibs/strophe.disco.js",
+  "http://localhost/jslibs/SpecHelper.js"
+ ]
+}