xmppify 0.0.12

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

@@ -0,0 +1,232 @@
+/*
+  Copyright 2010, François de Metz <francois@2metz.fr>
+*/
+
+/**
+ * Disco Strophe Plugin
+ * Implement http://xmpp.org/extensions/xep-0030.html
+ * TODO: manage node hierarchies, and node on info request
+ */
+Strophe.addConnectionPlugin('disco',
+{
+    _connection: null,
+    _identities : [],
+    _features : [],
+    _items : [],
+    /** Function: init
+     * Plugin init
+     *
+     * Parameters:
+     *   (Strophe.Connection) conn - Strophe connection
+     */
+    init: function(conn)
+    {
+    this._connection = conn;
+        this._identities = [];
+        this._features   = [];
+        this._items      = [];
+        // disco info
+        conn.addHandler(this._onDiscoInfo.bind(this), Strophe.NS.DISCO_INFO, 'iq', 'get', null, null);
+        // disco items
+        conn.addHandler(this._onDiscoItems.bind(this), Strophe.NS.DISCO_ITEMS, 'iq', 'get', null, null);
+    },
+    /** Function: addIdentity
+     * See http://xmpp.org/registrar/disco-categories.html
+     * Parameters:
+     *   (String) category - category of identity (like client, automation, etc ...)
+     *   (String) type - type of identity (like pc, web, bot , etc ...)
+     *   (String) name - name of identity in natural language
+     *   (String) lang - lang of name parameter
+     *
+     * Returns:
+     *   Boolean
+     */
+    addIdentity: function(category, type, name, lang)
+    {
+        for (var i=0; i<this._identities.length; i++)
+        {
+            if (this._identities[i].category == category &&
+                this._identities[i].type == type &&
+                this._identities[i].name == name &&
+                this._identities[i].lang == lang)
+            {
+                return false;
+            }
+        }
+        this._identities.push({category: category, type: type, name: name, lang: lang});
+        return true;
+    },
+    /** Function: addFeature
+     *
+     * Parameters:
+     *   (String) var_name - feature name (like jabber:iq:version)
+     *
+     * Returns:
+     *   boolean
+     */
+    addFeature: function(var_name)
+    {
+        for (var i=0; i<this._features.length; i++)
+        {
+             if (this._features[i] == var_name)
+                 return false;
+        }
+        this._features.push(var_name);
+        return true;
+    },
+    /** Function: removeFeature
+     *
+     * Parameters:
+     *   (String) var_name - feature name (like jabber:iq:version)
+     *
+     * Returns:
+     *   boolean
+     */
+    removeFeature: function(var_name)
+    {
+        for (var i=0; i<this._features.length; i++)
+        {
+             if (this._features[i] === var_name){
+                 this._features.splice(i,1)
+                 return true;
+             }
+        }
+        return false;
+    },
+    /** Function: addItem
+     *
+     * Parameters:
+     *   (String) jid
+     *   (String) name
+     *   (String) node
+     *   (Function) call_back
+     *
+     * Returns:
+     *   boolean
+     */
+    addItem: function(jid, name, node, call_back)
+    {
+        if (node && !call_back)
+            return false;
+        this._items.push({jid: jid, name: name, node: node, call_back: call_back});
+        return true;
+    },
+    /** Function: info
+     * Info query
+     *
+     * Parameters:
+     *   (Function) call_back
+     *   (String) jid
+     *   (String) node
+     */
+    info: function(jid, node, success, error, timeout)
+    {
+        var attrs = {xmlns: Strophe.NS.DISCO_INFO};
+        if (node)
+            attrs.node = node;
+
+        var info = $iq({from:this._connection.jid,
+                         to:jid, type:'get'}).c('query', attrs);
+        this._connection.sendIQ(info, success, error, timeout);
+    },
+    /** Function: items
+     * Items query
+     *
+     * Parameters:
+     *   (Function) call_back
+     *   (String) jid
+     *   (String) node
+     */
+    items: function(jid, node, success, error, timeout)
+    {
+        var attrs = {xmlns: Strophe.NS.DISCO_ITEMS};
+        if (node)
+            attrs.node = node;
+
+        var items = $iq({from:this._connection.jid,
+                         to:jid, type:'get'}).c('query', attrs);
+        this._connection.sendIQ(items, success, error, timeout);
+    },
+
+    /** PrivateFunction: _buildIQResult
+     */
+    _buildIQResult: function(stanza, query_attrs)
+    {
+        var id   =  stanza.getAttribute('id');
+        var from = stanza.getAttribute('from');
+        var iqresult = $iq({type: 'result', id: id});
+
+        if (from !== null) {
+            iqresult.attrs({to: from});
+        }
+
+        return iqresult.c('query', query_attrs);
+    },
+
+    /** PrivateFunction: _onDiscoInfo
+     * Called when receive info request
+     */
+    _onDiscoInfo: function(stanza)
+    {
+        var node = stanza.getElementsByTagName('query')[0].getAttribute('node');
+        var attrs = {xmlns: Strophe.NS.DISCO_INFO};
+        if (node)
+        {
+            attrs.node = node;
+        }
+        var iqresult = this._buildIQResult(stanza, attrs);
+        for (var i=0; i<this._identities.length; i++)
+        {
+            var attrs = {category: this._identities[i].category,
+                         type    : this._identities[i].type};
+            if (this._identities[i].name)
+                attrs.name = this._identities[i].name;
+            if (this._identities[i].lang)
+                attrs['xml:lang'] = this._identities[i].lang;
+            iqresult.c('identity', attrs).up();
+        }
+        for (var i=0; i<this._features.length; i++)
+        {
+            iqresult.c('feature', {'var':this._features[i]}).up();
+        }
+        this._connection.send(iqresult.tree());
+        return true;
+    },
+    /** PrivateFunction: _onDiscoItems
+     * Called when receive items request
+     */
+    _onDiscoItems: function(stanza)
+    {
+        var query_attrs = {xmlns: Strophe.NS.DISCO_ITEMS};
+        var node = stanza.getElementsByTagName('query')[0].getAttribute('node');
+        if (node)
+        {
+            query_attrs.node = node;
+            var items = [];
+            for (var i = 0; i < this._items.length; i++)
+            {
+                if (this._items[i].node == node)
+                {
+                    items = this._items[i].call_back(stanza);
+                    break;
+                }
+            }
+        }
+        else
+        {
+            var items = this._items;
+        }
+        var iqresult = this._buildIQResult(stanza, query_attrs);
+        for (var i = 0; i < items.length; i++)
+        {
+            var attrs = {jid:  items[i].jid};
+            if (items[i].name)
+                attrs.name = items[i].name;
+            if (items[i].node)
+                attrs.node = items[i].node;
+            iqresult.c('item', attrs).up();
+        }
+        this._connection.send(iqresult.tree());
+        return true;
+    }
+});

data/app/assets/javascripts/xmpp/strophejs-plugins/epic/public/javascript/jquery.epic.js

@@ -0,0 +1,61 @@
+(function($) {
+
+	function log(msg) {
+		if (window.console) {
+			console.log('epic.' + msg);
+		}
+	}
+
+	var templates = {
+		roster: '<ul class="epic-roster"></ul>',
+		roster_item: '<li data-jid="${jid}" class="epic-roster-item">${jid}</li>',
+		cmds: '<ul class="epic-cmds"></ul>',
+		cmds_item: '<li class="epic-cmd-item" data-jid="${jid}" data-node="${node}">${name}</li>'
+	};
+
+	var epic = {
+		_create: function() {
+			log('create');
+			this.element.append(templates.roster);
+			this.element.append(templates.cmds);
+			this._conn = this.options.conn;
+			this._conn.roster.onPresenceChanged = $.proxy(this.updateRoster, this);
+			this.element.delegate('.epic-roster', 'click', $.proxy(this.getCmdList,this));
+			this.element.delegate('.epic-cmds', 'click', $.proxy(this.executeCmd,this));
+		},
+		updateRoster: function(jid, status) {
+			log('updateRoster');
+			var roster = this.element.find('.epic-roster');
+			$(".epic-roster-item[data-jid='" + jid + "']", roster).remove();
+			if (status !== 'unavailable') {
+				$.tmpl(templates.roster_item, {jid: jid}).appendTo(roster);
+			}
+		},
+		getCmdList: function(e) {
+			var node = $(e.target).text();
+			log('getCmdList for ' + node);
+			this._conn.disco.items(node, Strophe.NS.CMDS, $.proxy(this.updateCmdList, this));
+		},
+		updateCmdList: function(iq) {
+			var cmds = this.element.find('.epic-cmds');
+			$("item",iq).each(function(i,item) {
+				item = $(item);
+				var data = {
+					node: item.attr('node'),
+					name: item.attr('name'),
+					jid: item.attr('jid')
+				};
+				$.tmpl(templates.cmds_item, data).appendTo(cmds);
+			});
+		},
+		executeCmd: function(e) {
+			var target = $(e.target);
+			var node = target.attr('data-node');
+			var jid = target.attr('data-jid');
+			log('executeCmd for ' + node + ' on ' + jid);
+			this._conn.cmds.execute(jid, node);
+		}
+	};
+
+	$.widget('nmk.epic', epic);
+})(jQuery);

data/app/assets/javascripts/xmpp/strophejs-plugins/epic/spec/SpecHelper.js

@@ -0,0 +1,9 @@
+beforeEach(function() {
+  this.addMatchers({
+    toBePlaying: function(expectedSong) {
+      var player = this.actual;
+      return player.currentlyPlayingSong === expectedSong
+          && player.isPlaying;
+    }
+  })
+});

data/app/assets/javascripts/xmpp/strophejs-plugins/epic/spec/jquery.epic.js

@@ -0,0 +1,39 @@
+describe("plugin", function() {
+	var conn, epic;
+	beforeEach(function() {
+		conn = new Strophe.Connection();
+		conn.authenticated = true;
+		conn._changeConnectStatus(Strophe.Status.CONNECTED);
+		epic = $("<div/>").epic({conn: conn});
+	});
+
+	it("shows item in roster", function() {
+		var pres = $pres({from: 'n@d/r'});
+		conn._dataRecv(createRequest(pres));
+		expect(conn.roster.contacts).toEqual({'n@d/r': 'available'});
+		expect(epic.find('.epic-roster-item').text()).toEqual('n@d/r');
+	});
+
+	it("gets commands and displays them", function() {
+		var x = '<ul class="epic-roster"><li class="epic-roster-item">n@d/r</li></ul>';
+		epic.append(x);
+		spyOn(conn,'send').andCallFake(function(iq) {
+			var res = $iq({type: 'result', id: $(iq).attr('id')});
+			res.c('query', {xmlns: Strophe.NS.DISCO_ITEMS, node: Strophe.NS.CMDS});
+			res.c('item', {name: 'aName', node: 'aNode', jid: $(iq).attr('from')});
+			conn._dataRecv(createRequest(res));
+			expect(epic.find('.epic-cmd-item').text()).toEqual('aName');
+
+		});
+		epic.find('.epic-roster-item').click();
+	});
+
+	it("executes command", function() {
+		var x = '<ul class="epic-cmds"><li data-node="aNode" data-jid="n@d/r" class="epic-cmd-item">cmd</li></ul>';
+		epic.append(x);
+		spyOn(conn,'send');
+		epic.find('.epic-cmd-item').click();
+		expect(conn.send).toHaveBeenCalled();
+	});
+
+});

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

@@ -0,0 +1,22 @@
+{
+ "src_dir"  : "/public/javascript/",
+ "spec_dir" : "/spec/",
+
+ "server":{
+   "port":8124
+ },
+ "externals":[
+  "https://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js",
+  "http://localhost/jquery.ui.widget.js",
+  "http://localhost/strophe.js",
+  "http://localhost/strophe.roster.js",
+  "http://localhost/strophe.disco.js",
+  "http://localhost/strophe.cmds.js",
+  "http://localhost/Stanzas.js",
+  "http://ajax.microsoft.com/ajax/jquery.templates/beta1/jquery.tmpl.js"
+ ],
+	
+ "_other external files you can add above":[
+  "https://github.com/pivotal/jasmine-ajax/raw/master/lib/mock-ajax.js" 
+ ]
+}

data/app/assets/javascripts/xmpp/strophejs-plugins/iexdomain/iexdomain.js

@@ -0,0 +1,36 @@
+Strophe.addConnectionPlugin('iexdomain', {
+    init: function(conn) {
+        // replace Strophe.Request._newXHR with new IE CrossDomain version
+        if (window.XDomainRequest) {
+            Strophe.Request.prototype._newXHR = function() {
+                var xhr = new XDomainRequest();
+                xhr.readyState = 0;
+
+                xhr.onreadystatechange = this.func.prependArg(this);
+                xhr.onerror = function() {
+                    xhr.readyState = 4;
+                    xhr.status = 500;
+                    xhr.onreadystatechange(xhr.responseText);
+                };
+                xhr.ontimeout = function() {
+                    xhr.readyState = 4;
+                    xhr.status = 0;
+                    xhr.onreadystatechange(xhr.responseText);
+                };
+                xhr.onload = function() {
+                    xhr.readyState = 4;
+                    xhr.status = 200;
+                    var _response = xhr.responseText;
+                    var _xml = new ActiveXObject('Microsoft.XMLDOM');
+                    _xml.async = 'false';
+                    _xml.loadXML(_response);
+                    xhr.responseXML = _xml;
+                    xhr.onreadystatechange(_response);
+                };
+                return xhr;
+            };
+        } else {
+            console.info("Browser doesnt support XDomainRequest." + "  Falling back to native XHR implementation.");
+        }
+    }
+});

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

@@ -0,0 +1,117 @@
+# Jabber Object Access Protocol
+
+A strophe plugin for the Jabber Object Access Protocol
+([XEP-0075](http://xmpp.org/extensions/xep-0075.html)).
+
+## Usage
+
+Link the `rpc`, `jid` and the `joap` plugin below the strophe library in your
+HTML head section:
+
+``` html
+<head>
+<!-- ... -->
+<script type="text/javascript" src="strophe.min.js"></script>
+<script type="text/javascript" src="jid.js"></script>
+<script type="text/javascript" src="strophe.disco.js"></script>
+<script type="text/javascript" src="strophe.rpc.js"></script>
+<script type="text/javascript" src="strophe.joap.js"></script>
+<!-- ... -->
+</head>
+```
+
+After your client is sucessfully connected you can create, read, update and
+delete objects.
+
+### Server
+
+``` coffeescript
+objectServer = new connection.joap.JOAPServer "component.example.org"
+
+# requesting the server description
+objectServer.describe (iq, err, parsedDescription) ->
+
+# requesting a class description
+objectServer.describe "User", (iq, err, parsedDescription) ->
+
+# creating a new instance
+objectServer.add "User", { name:"My Name", age: 99 }, (iq, err, instanceAddress) ->
+
+# reading an instance
+objectServer.read "User", "instanceId", (iq, err, parsedResult) ->
+
+# reading only a few properties of an instance
+objectServer.read "User", "instanceId", ["email", "age"], (iq, err, parsedResult) ->
+
+# modifying properties of an instance
+objectServer.edit "User", "instanceId", { age: 27 }, (iq, err) ->
+
+# deleting an instance
+objectServer.delete "User", "instanceId", (iq, err) ->
+
+# searching for instances
+objectServer.search "User", {age: 60} , (iq, err, arrayOfInstanceIDs) ->
+
+# searching and reading in one step
+objectServer.searchAndRead "User", {type: "admin"}, ["email"], (iq, err, arrayOfInstancObjects) ->
+
+# performing a method call
+objectServer.methodCall "myMethod", "User", ["param1","param2"], (iq, err, result) ->
+```
+
+### Class
+
+``` coffeescript
+aClass = new connection.joap.JOAPClass "myClass@component.example.org"
+
+# requesting a class description
+aClass.describe (iq, err, parsedDescription) ->
+
+# searching for class instances
+aClass.search (iq, err, arrayOfInstanceIDs) ->
+
+# searching and reading
+aClass.searchAndRead filter, limits, (iq, err, arrayOfInstances) ->
+
+# creating a new instance
+aClass.add { aProperty:"aValue" }, (iq, err, instanceAddress) ->
+```
+
+### Object
+
+``` coffeescript
+obj = new connection.joap.JOAPObject "myClass@component.example.org/instanceId"
+
+# modifying properties
+obj.edit { key: 'value' }, (iq, err) ->
+```
+
+## Dependencies
+
+- jid.js
+- [rpc](https://github.com/metajack/strophejs-plugins/tree/master/rpc)
+- [punycode](https://github.com/bestiejs/punycode.js/) (optional)
+- [service discovery](https://github.com/metajack/strophejs-plugins/tree/master/disco) (optional)
+
+## Available JOAP server implementations
+
+- [node-xmpp-joap](https://github.com/flosse/node-xmpp-joap)
+
+## Tests & specs
+
+[buster.js](https://github.com/busterjs/) and
+[buster-coffee](https://github.com/jodal/buster-coffee) and
+are required (`npm install -g buster buster-coffee`) for running the tests.
+
+First start a test server
+
+```bash
+buster server
+```
+
+Then navigate with one or more browsers to `localhost:1111` and capture them.
+Afterwards you can run the specs:
+
+```bash
+cake test
+```

data/app/assets/javascripts/xmpp/strophejs-plugins/joap/buster.js

@@ -0,0 +1,23 @@
+var config = module.exports;
+
+config["joap"] = {
+  environment: "browser",
+  specs: ["spec/strophe.joap.spec.coffee"],
+  specHelpers: ["spec/browserSetup.coffee"],
+  sources: ["strophe.joap.js"],
+  libs: [
+    "lib/punycode.js",
+    "jid.js",
+    "lib/jquery.js",
+    "lib/strophe.js",
+    "lib/strophe.rpc.js" ],
+  extensions: [require("buster-coffee")],
+};
+
+config["jid"] = {
+  environment: "browser",
+  specs: ["spec/jid.spec.coffee"],
+  sources: ["jid.js"],
+  libs: ["lib/punycode.js"],
+  extensions: [require("buster-coffee")],
+};

data/app/assets/javascripts/xmpp/strophejs-plugins/joap/jid.coffee

@@ -0,0 +1,64 @@
+###
+This program is distributed under the terms of the MIT license.
+Copyright 2012 (c) Markus Kohlhase <mail@markus-kohlhase.de>
+###
+
+###
+This is coffee-script fork of
+https://github.com/astro/node-xmpp/blob/master/lib/xmpp/jid.js
+###
+
+toUnicode  = punycode?.toUnicode or (a) -> a
+
+class JID
+
+  constructor: (a, b, c) ->
+
+    if a and not b? and not c?
+      @parseJID a
+    else if b?
+      @setUser a
+      @setDomain b
+      @resource = c
+    else
+      throw new Error 'Argument error'
+
+  user     : null
+  resource : null
+  domain   : null
+
+  parseJID: (s) ->
+    if  s.indexOf('@') >= 0
+        @setUser(s.substr(0, s.indexOf('@')))
+        s = s.substr(s.indexOf('@') + 1)
+    if (s.indexOf('/') >= 0)
+        @resource = s.substr(s.indexOf('/') + 1)
+        s = s.substr(0, s.indexOf('/'))
+    @setDomain s
+
+  toString: ->
+    s = @domain
+    s = @user + '@' + s if @user
+    s += '/' + @resource if @resource
+    s
+
+  # Convenience method to distinguish users
+  bare : ->
+    if @resource then new JID @user, @domain, null
+    else @
+
+  # Comparison function
+  equals: (other) ->
+    @user     is other.user    and
+    @domain   is other.domain  and
+    @resource is other.resource
+
+  # Setters that do stringprep normalization.
+  setUser: (user) -> @user = user and user.toLowerCase()
+
+  # http://xmpp.org/rfcs/rfc6122.html#addressing-domain
+  setDomain: (domain) ->
+    @domain = domain and
+        (domain.split(".").map(toUnicode).join(".")).toLowerCase()
+
+window.JID = JID

data/app/assets/javascripts/xmpp/strophejs-plugins/joap/jid.js

@@ -0,0 +1,92 @@
+// Generated by CoffeeScript 1.3.3
+
+/*
+This program is distributed under the terms of the MIT license.
+Copyright 2012 (c) Markus Kohlhase <mail@markus-kohlhase.de>
+*/
+
+
+/*
+This is coffee-script fork of
+https://github.com/astro/node-xmpp/blob/master/lib/xmpp/jid.js
+*/
+
+
+(function() {
+  var JID, toUnicode;
+
+  toUnicode = (typeof punycode !== "undefined" && punycode !== null ? punycode.toUnicode : void 0) || function(a) {
+    return a;
+  };
+
+  JID = (function() {
+
+    function JID(a, b, c) {
+      if (a && !(b != null) && !(c != null)) {
+        this.parseJID(a);
+      } else if (b != null) {
+        this.setUser(a);
+        this.setDomain(b);
+        this.resource = c;
+      } else {
+        throw new Error('Argument error');
+      }
+    }
+
+    JID.prototype.user = null;
+
+    JID.prototype.resource = null;
+
+    JID.prototype.domain = null;
+
+    JID.prototype.parseJID = function(s) {
+      if (s.indexOf('@') >= 0) {
+        this.setUser(s.substr(0, s.indexOf('@')));
+        s = s.substr(s.indexOf('@') + 1);
+      }
+      if (s.indexOf('/') >= 0) {
+        this.resource = s.substr(s.indexOf('/') + 1);
+        s = s.substr(0, s.indexOf('/'));
+      }
+      return this.setDomain(s);
+    };
+
+    JID.prototype.toString = function() {
+      var s;
+      s = this.domain;
+      if (this.user) {
+        s = this.user + '@' + s;
+      }
+      if (this.resource) {
+        s += '/' + this.resource;
+      }
+      return s;
+    };
+
+    JID.prototype.bare = function() {
+      if (this.resource) {
+        return new JID(this.user, this.domain, null);
+      } else {
+        return this;
+      }
+    };
+
+    JID.prototype.equals = function(other) {
+      return this.user === other.user && this.domain === other.domain && this.resource === other.resource;
+    };
+
+    JID.prototype.setUser = function(user) {
+      return this.user = user && user.toLowerCase();
+    };
+
+    JID.prototype.setDomain = function(domain) {
+      return this.domain = domain && (domain.split(".").map(toUnicode).join(".")).toLowerCase();
+    };
+
+    return JID;
+
+  })();
+
+  window.JID = JID;
+
+}).call(this);