xmppify 0.0.12

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

@@ -0,0 +1,464 @@
+/**
+ * This program is distributed under the terms of the MIT license.
+ * 
+ * Copyright 2011 (c) Pierre Guilleminot <pierre.guilleminot@gmail.com>
+ */
+
+/**
+ * Jabber-RPC plugin (XEP-0009)
+ * Allow the management of RPC
+ */
+Strophe.addConnectionPlugin("rpc", {
+
+  _connection : undefined,
+
+  _whitelistEnabled : false,
+
+  jidWhiteList : [],
+  nodeWhiteList : [],
+  domainWhiteList : [],
+
+  /**
+   * Plugin init
+   * 
+   * @param  {Strophe.Connection} connection Strophe connection
+   */
+  init: function(connection) {
+
+    this._connection = connection;
+
+    this._whitelistEnabled = false;
+
+    this.jidWhiteList    = [];
+    this.nodeWhiteList   = [];
+    this.domainWhiteList = [];
+
+    Strophe.addNamespace("RPC", "jabber:iq:rpc");
+
+    if (!connection.hasOwnProperty("disco")) {
+      Strophe.warn("You need the discovery plugin " +
+                   "to have Jabber-RPC fully implemented.");
+    }
+    else {
+      this._connection.disco.addIdentity("automation", "rpc");
+      this._connection.disco.addFeature(Strophe.NS.RPC);
+    }
+  },
+
+  /**
+   * Add a jid or an array of jids to
+   * the whitelist.
+   * It's possible to use wildecards for the domain
+   * or the node. ie:
+   *   *@*
+   *   myname@*
+   *   *@jabber.org
+   * 
+   * @param {String|Array} jid
+   */
+  addJidToWhiteList: function(jids) {
+    if (typeof(jids.sort) !== "function") {
+      jids = [jids];
+    }
+
+    for (var i = 0; i < jids.length; i++) {
+      var jid = jids[i];
+
+      if (jid === "*@*") {
+        this._whitelistEnabled = false;
+        return;
+      }
+
+      var node   = Strophe.getNodeFromJid(jid);
+      var domain = Strophe.getDomainFromJid(jid);
+      if (jid) {
+        if (node === "*") {
+          this.domainWhiteList.push(domain);
+        } else if (domain === "*") {
+          this.nodeWhiteList.push(node);
+        } else {
+          this.jidWhiteList.push(jid);
+        }
+        this._whitelistEnabled = true;
+      }
+    }
+  },
+
+  /**
+   * Helper to filter out Jid outside of the whitelists
+   * 
+   * @param  {String} jid Jid to test 
+   * @return {Boolean}
+   */
+  _jidInWhitelist: function(jid) {
+    if (!this._whitelistEnabled)
+      return true;
+
+    if (jid === this._connection.jid)
+      return true;
+    
+    return (
+      this.domainWhiteList.indexOf(Strophe.getDomainFromJid(jid)) !== -1  ||
+      this.nodeWhiteList.indexOf(Strophe.getNodeFromJid(jid))     !== -1  ||
+      this.jidWhiteList.indexOf(jid) !== -1
+    );
+  },
+
+  /**
+   * Send a request message
+   * 
+   * @param  {Object} id     ID of the request
+   * @param  {String} to     JID of the recipient
+   * @param  {String} method name of the method
+   * @param  {Array}  params Array of parameters
+   */
+  sendRequest: function(id, to, method, params) {
+    params = (typeof(params.sort) === "function") ? params : [params];
+
+    var element = new Strophe.Builder("methodCall")
+      .c("methodName").t(method)
+      .up()
+      .c("params");
+    
+    for (var i = 0; i < params.length; i++) {
+      element.c("param")
+        .cnode(this._convertToXML(params[i]))
+        .up().up();
+    }
+
+    this.sendXMLElement(id, to, "set", element.tree());
+  },
+
+  /**
+   * Send a response message
+   * 
+   * @param  {String} id     ID of the request
+   * @param  {String} to     JID of the recipient
+   * @param  {Object} result Result of the function call
+   */
+  sendResponse: function(id, to, result) {
+    var element = new Strophe.Builder("methodResponse")
+      .c("params")
+      .c("param")
+      .cnode(this._convertToXML(result));
+    
+    this.sendXMLElement(id, to, "result", element.tree());
+  },
+
+  /**
+   * Send an error response (or fault)
+   * 
+   * @param  {String} id      ID of the faulted request
+   * @param  {String} to      JID of the recipient
+   * @param  {Number} code    Code of the error
+   * @param  {String} message Error message
+   */
+  sendError: function(id, to, code, message) {
+    if (isNaN(code)) {
+      Strophe.error(code + " is not a number");
+      return;
+    }
+
+    var element = new Strophe.Builder("methodResponse")
+      .c("fault")
+      .cnode(this._convertToXML({
+        faultCode: code,
+        faultString: String(message)
+      }));
+
+    this.sendXMLElement(id, to, "result", element.tree());
+  },
+
+  /**
+   * Send a XMLElement as the request
+   * Does not check whether it is properly formed or not
+   * 
+   * @param  {String}  id      ID of the request or response 
+   * @param  {String}  to      JID of the recipient
+   * @param  {String}  type    Type of the request ('set' for a request and 'result' for a response)
+   * @param  {Element} element The XMLElement to send
+   */
+  sendXMLElement: function(id, to, type, element) {
+    if (typeof element.tree === 'function') {
+      element = element.tree();
+    }
+
+    var iq = $iq({type: type, id: id, from: this._connection.jid, to: to})
+      .c("query", {xmlns: Strophe.NS.RPC})
+      .cnode(element);
+    
+    this._connection.send(iq.tree());
+  },
+
+  _sendForbiddenAccess: function(id, to) {
+    var iq = $iq({type: "error", id: id, from: this._connection.jid, to: to})
+      .c("error", {code: 403, type: "auth"})
+      .c("forbidden", {xmlns: Strophe.NS.STANZAS});
+    
+    this._connection.send(iq.tree());
+  },
+
+  /**
+   * Add a request and response handlers
+   * 
+   * @param {Function} request_h  Request handler
+   * @param {Function} response_h Response handler
+   * @param {Object} context Context of the handlers
+   */
+  addHandlers: function(request_h, response_h, context) {
+    this.addRequestHandler(request_h, context);
+    this.addResponseHandler(response_h, context);
+  },
+
+  /**
+   * Add a request handler
+   * called every time a request is received
+   * 
+   * @param {Function} handler The handler function
+   * @param {Object} context Context of the handler
+   */
+  addRequestHandler: function(handler, context) {
+    this._connection.addHandler(this._filteredRequestHandler(handler, context), Strophe.NS.RPC, "iq", "set");
+  },
+
+  /**
+   * Add a response handler
+   * called every time a response is received
+   * 
+   * @param {Function} handler The handler function called every time a response is received
+   * @param {Object} context Context of the handler
+   */
+  addResponseHandler: function(handler, context) {
+    this._connection.addHandler(this._filteredResponseHandler(handler, context), Strophe.NS.RPC, "iq", "result");
+  },
+
+  /**
+   * Add a raw XML handler for every RPC message incoming
+   * @param {Function} handler The handler function called every time a rpc is received
+   * @param {Object} context Context of the handler
+   */
+  addXMLHandler: function(handler, context) {
+    this._connection.addHandler(this._filteredHandler(handler, context), Strophe.NS.RPC, "iq");
+  },
+
+  _filter: function(xml) {
+    var from = xml.getAttribute("from");
+    if (!this._jidInWhitelist(from)) {
+      this._sendForbiddenAccess(xml.getAttribute("id"), from);
+      return false;
+    }
+    return true;
+  },
+
+  _filteredHandler: function(handler, context) {
+    context = context || this;
+    var self = this;
+    return function(xml) {
+      if (self._filter(xml)) {
+        return handler.apply(context, arguments);
+      }
+      return true;
+    };
+  },
+
+  _filteredResponseHandler: function(handler, context) {
+    context = context || this;
+    var self = this;
+    return function(xml) {
+      if (self._filter(xml)) {
+        var rpc = self._parseResponseMessage(xml);
+        if (rpc.result || rpc.result === null)
+          return handler.call(context, rpc.id, rpc.from, rpc.result, false);
+        else if (rpc.fault || rpc.fault === null)
+          return handler.call(context, rpc.id, rpc.from, rpc.fault, true);
+      }
+      return true;
+    };
+  },
+
+  _filteredRequestHandler: function(handler, context) {
+    context = context || this;
+    var self = this;
+    return function(xml) {
+      if (self._filter(xml)) {
+        var rpc = self._parseRequestMessage(xml);
+        return handler.call(context, rpc.id, rpc.from, rpc.method, rpc.params);
+      }
+      return true;
+    };
+  },
+
+  /**
+   * Helper to transform a Javascript object
+   * into its XML representation as described in
+   * the XML-RPC spec
+   * 
+   * @param  {Object} obj The object to convert
+   * @return {Element} A <value> element
+   */
+  _convertToXML: function(obj) {
+    var key;
+
+    var xml  = new Strophe.Builder("value");
+    var type = new RegExp("function (.*?)\\(\\) \\{.*").exec(obj.constructor.toString())[1];
+
+    switch (type) {
+      case "Number":
+        // Numbers can only be sent as integers or doubles.
+        var number = (Math.floor(obj) !== obj) ? "double" : "i4";
+        xml.c(number).t(obj.toString());
+        break;
+      case "String":
+        xml.c("string").t(obj);
+        break;
+      case "Boolean":
+        xml.c("boolean").t((obj*1).toString());
+        break;
+      case "Object":
+        xml.c("struct");
+        for (key in obj) {
+          if (obj.hasOwnProperty(key) && typeof(obj[key]) !== "function") {
+            xml.c("member").c("name").t(key);
+            xml.up().cnode(this._convertToXML(obj[key]));
+            xml.up().up();
+          }
+        }
+        break;
+      case "Date":
+        var datetext = obj.getFullYear() +
+                       this._padNumber(obj.getMonth()+1) +
+                       this._padNumber(obj.getDate())    + "T" +
+                       this._padNumber(obj.getHours())   + ":" +
+                       this._padNumber(obj.getMinutes()) + ":" +
+                       this._padNumber(obj.getSeconds());
+        xml.c("dateTime.iso8601").t(datetext);
+        break;
+      case "Array":
+        xml.c("array").c("data");
+        for (key in obj) {
+          if (obj.hasOwnProperty(key) && typeof(obj[key]) !== "function") {
+            xml.cnode(this._convertToXML(obj[key]));
+            xml.up();
+          }
+        }
+        break;
+      default:
+        break;
+    }
+
+    return xml.tree();
+  },
+
+  _padNumber: function(num) {
+    if (num < 10) {
+      num = "0" + num;
+    }
+    return num;
+  },
+
+  _parseRequestMessage: function(iq) {
+    var rpc  = {};
+    rpc.from = iq.getAttribute("from");
+    rpc.id   = iq.getAttribute("id") || null;
+
+    // Method name
+    var method = iq.getElementsByTagName("methodName")[0];
+    rpc.method = method ? method.textContent : null;
+
+    // Parameters
+    rpc.params = null;
+    try {
+      var params = iq.getElementsByTagName("params")[0]
+                     .childNodes;
+      if (params && params.length > 0) {
+        rpc.params = [];
+        for (var i = 0; i < params.length; i++) {
+          rpc.params.push(this._convertFromXML(params[i].firstChild));
+        }
+      }
+    } catch(e) {
+      rpc.params = null;
+    }
+    return rpc;
+  },
+
+  _parseResponseMessage: function(iq) {
+    var rpc  = {};
+    rpc.from = iq.getAttribute("from");
+    rpc.id   = iq.getAttribute("id") || null;
+
+    try {
+      var result = iq.getElementsByTagName("methodResponse")[0].firstChild;
+
+      // Response
+      var tag = result.tagName;
+      if (tag === "params") {
+        rpc.result = this._convertFromXML(result.firstChild.firstChild);
+      }
+      // Error
+      else if (tag === "fault") {
+        rpc.fault  = this._convertFromXML(result.firstChild);
+      }
+    } catch(e) {
+      rpc.result = null;
+    }
+    return rpc;
+  },
+
+  _convertFromXML: function(obj) {
+    if (!obj)
+      return null;
+
+    var data;
+    var tag = obj.tagName.toLowerCase();
+
+    try {
+      switch (tag) {
+        case "value":
+          return this._convertFromXML(obj.firstChild);
+        case "double":
+        case "i4":
+        case "int":
+          var number = obj.textContent;
+          data = number * 1;
+          break;
+        case "boolean":
+          var bool = obj.textContent;
+          data = (bool === "1" || bool === "true") ? true : false;
+          break;
+        case "datetime.iso8601":
+          var date = obj.textContent;
+          data = new Date();
+          data.setFullYear(date.substring(0,4), date.substring(4,6) - 1, date.substring(6,8));
+          data.setHours(date.substring(9,11), date.substring(12,14), date.substring(15,17));
+          break;
+        case "array":
+          data = [];
+          var datatag = obj.firstChild;
+          for (var k = 0; k < datatag.childNodes.length; k++) {
+            var value = datatag.childNodes[k];
+            data.push(this._convertFromXML(value.firstChild));
+          }
+          break;
+        case "struct":
+          data = {};
+          for (var j = 0; j < obj.childNodes.length; j++) {
+            var membername  = obj.childNodes[j].getElementsByTagName("name")[0].textContent;
+            var membervalue = obj.childNodes[j].getElementsByTagName("value")[0].firstChild;
+            data[membername] = membervalue ? this._convertFromXML(membervalue) : null;
+          }
+          break;
+        case "string":
+          data = obj.textContent;
+          break;
+        default:
+          data = null;
+          break;
+      }
+    } catch(e) {
+      data = null;
+    }
+    return data;
+  }
+
+});

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

@@ -0,0 +1,52 @@
+// http://xmpp.org/extensions/xep-0059.html
+
+Strophe.addNamespace('RSM', 'http://jabber.org/protocol/rsm');
+   
+Strophe.RSM = function(options) {
+  this.attribs = ['max', 'first', 'last', 'after', 'before', 'index', 'count'];
+
+  if (typeof options.xml != 'undefined') {
+    this.fromXMLElement(options.xml);
+  } else {
+    for (var ii = 0; ii < this.attribs.length; ii++) {
+      var attrib = this.attribs[ii];
+      this[attrib] = options[attrib];
+    }
+  }
+};
+
+Strophe.RSM.prototype = {
+  toXML: function() {
+    var xml = $build('set', {xmlns: Strophe.NS.RSM});
+    for (var ii = 0; ii < this.attribs.length; ii++) {
+      var attrib = this.attribs[ii];
+      if (typeof this[attrib] != 'undefined') {
+        xml = xml.c(attrib).t(this[attrib].toString()).up();
+      }
+    }
+    return xml.tree();
+  },
+
+  next: function(max) {
+    var newSet = new Strophe.RSM({max: max, after: this.last});
+    return newSet;
+  },
+
+  previous: function(max) {
+    var newSet = new Strophe.RSM({max: max, before: this.first});
+    return newSet;
+  },
+
+  fromXMLElement: function(xmlElement) {
+    for (var ii = 0; ii < this.attribs.length; ii++) {
+      var attrib = this.attribs[ii];
+      var elem = xmlElement.getElementsByTagName(attrib)[0];
+      if (typeof elem != 'undefined' && elem !== null) {
+        this[attrib] = Strophe.getText(elem);
+        if (attrib == 'first') {
+          this.index = elem.getAttribute('index');
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,58 @@
+
+
+/* serverdate plugin
+**
+** This plugin syncs a local clock to the servers using the response header
+** on the BOSH connection
+**
+*/
+
+var ServerDate = function(){
+  if( arguments.length === 0 ){
+    return new Date( new Date().valueOf() + ServerDate.skew );
+  }
+  else if ( arguments.length === 1 ){
+    // Covers case where a string is passed in
+    return new Date( arguments[0] );
+  }
+  else {
+    return new Date( Date.UTC.apply( null, arguments ) + ((new Date()).getTimezoneOffset() * 60000) );    
+  }
+};
+ServerDate.parse = Date.parse;
+ServerDate.UTC   = Date.UTC;
+ServerDate.now   = function(){ return (new ServerDate()).valueOf(); };
+ServerDate.skew  = 0;
+
+Strophe.addConnectionPlugin('serverdate', {
+  init: function(connection){    
+    Strophe.Request.prototype._newXHR = function () {
+      var xhr = null;
+      if (window.XMLHttpRequest) {
+        xhr = new XMLHttpRequest();
+        if (xhr.overrideMimeType) {
+          xhr.overrideMimeType("text/xml");
+        }
+      } else if (window.ActiveXObject) {
+        xhr = new ActiveXObject("Microsoft.XMLHTTP");
+      }
+    
+      var handler = this.func.prependArg(this);
+    
+      xhr.onreadystatechange = function(){
+        if(this.readyState == 2){
+          var header = this.getResponseHeader('Date');
+          var server_date = new Date(header);
+          if ( header && server_date != 'Invalid Date' ){
+            system_date = new Date();
+            skew_ms = server_date - system_date;
+            ServerDate.skew = skew_ms;
+          }
+        }
+        handler();
+      };
+    
+      return xhr;
+    };
+  }
+});

data/app/assets/javascripts/xmpp/strophejs-plugins/vcard/examples/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+
+    <title>Strophe Vcard Example</title>
+    <!-- Load jQuery -->
+    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.js"></script>
+
+    <script src="../../strophe.min.js"></script>
+    <script src="../strophe.vcard.js"></script>
+    <script src="strophevcard.js"></script>
+  </head>
+  <body class='avatar'>
+    <canvas id='example' width='100' height='100'></canvas>
+  </body>
+</html>

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

@@ -0,0 +1,44 @@
+###
+Plugin to implement the vCard extension.
+http://xmpp.org/extensions/xep-0054.html
+
+Author: Nathan Zorn (nathan.zorn@gmail.com)
+CoffeeScript port: Andreas Guth (guth@dbis.rwth-aachen.de)
+
+###
+### jslint configuration: ###
+### global document, window, setTimeout, clearTimeout, console,
+    XMLHttpRequest, ActiveXObject,
+    Base64, MD5,
+    Strophe, $build, $msg, $iq, $pres
+###
+buildIq = (type, jid, vCardEl) ->
+    iq = $iq if jid then type:type, to:jid else type:type
+    iq.c "vCard", xmlns:Strophe.NS.VCARD
+    iq.cnode vCardEl if vCardEl
+    iq
+
+Strophe.addConnectionPlugin 'vcard',
+    _connection: null
+    # Called by Strophe.Connection constructor
+    init: (conn) ->
+        this._connection = conn
+        Strophe.addNamespace 'VCARD', 'vcard-temp'
+
+    ###Function
+      Retrieve a vCard for a JID/Entity
+      Parameters:
+      (Function) handler_cb - The callback function used to handle the request.
+      (String) jid - optional - The name of the entity to request the vCard
+         If no jid is given, this function retrieves the current user's vcard.
+    ###
+    get: (handler_cb, jid, error_cb) ->
+        iq = buildIq "get", jid
+        this._connection.sendIQ iq, handler_cb, error_cb
+
+    ### Function
+        Set an entity's vCard.
+    ###
+    set: (handler_cb, vCardEl, jid, error_cb) ->
+        iq = buildIq "set", jid, vCardEl
+        this._connection.sendIQ iq, handler_cb, error_cb

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

@@ -0,0 +1,66 @@
+// Generated by CoffeeScript 1.3.3
+/*
+Plugin to implement the vCard extension.
+http://xmpp.org/extensions/xep-0054.html
+
+Author: Nathan Zorn (nathan.zorn@gmail.com)
+CoffeeScript port: Andreas Guth (guth@dbis.rwth-aachen.de)
+*/
+
+/* jslint configuration:
+*/
+
+/* global document, window, setTimeout, clearTimeout, console,
+    XMLHttpRequest, ActiveXObject,
+    Base64, MD5,
+    Strophe, $build, $msg, $iq, $pres
+*/
+
+var buildIq;
+
+buildIq = function(type, jid, vCardEl) {
+  var iq;
+  iq = $iq(jid ? {
+    type: type,
+    to: jid
+  } : {
+    type: type
+  });
+  iq.c("vCard", {
+    xmlns: Strophe.NS.VCARD
+  });
+  if (vCardEl) {
+    iq.cnode(vCardEl);
+  }
+  return iq;
+};
+
+Strophe.addConnectionPlugin('vcard', {
+  _connection: null,
+  init: function(conn) {
+    this._connection = conn;
+    return Strophe.addNamespace('VCARD', 'vcard-temp');
+  },
+  /*Function
+    Retrieve a vCard for a JID/Entity
+    Parameters:
+    (Function) handler_cb - The callback function used to handle the request.
+    (String) jid - optional - The name of the entity to request the vCard
+       If no jid is given, this function retrieves the current user's vcard.
+  */
+
+  get: function(handler_cb, jid, error_cb) {
+    var iq;
+    iq = buildIq("get", jid);
+    return this._connection.sendIQ(iq, handler_cb, error_cb);
+  },
+  /* Function
+      Set an entity's vCard.
+  */
+
+  set: function(handler_cb, vCardEl, jid, error_cb) {
+    var iq;
+    iq = buildIq("set", jid, vCardEl);
+    return this._connection.sendIQ(iq, handler_cb, error_rb);
+  }
+});