xmppify 0.0.12

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

@@ -0,0 +1,265 @@
+CMD = "http://jabber.org/protocol/commands"
+
+create = (node, callback=Strophe.Disco.noop) ->
+  switch node
+    when "getUrls" then new CommandNode item: "url", node: "getUrls", name: "Retrieve Urls", callback: callback
+    when "setUrls" then new CommandNode item: "url", node: "setUrls", name: "Sets Urls", callback: callback
+    else throw "Strophe.Commands has no implementation for: #{node}"
+
+createExecIQ = (opt) ->
+
+  iq = $iq { to: opt.jid, type: "set" }
+
+  cfg =
+    xmlns: CMD,
+    node: opt.node,
+
+  cfg.action = opt.action or "execute"
+  cfg.sessionid = opt.sid if opt.sid
+
+  iq.c "command", cfg
+
+  if $.isArray opt.data
+    iq.c(opt.item[0].item).t(item).up() for i,item of opt.data
+
+  else if opt.form
+    iq.cnode opt.form.toXML()
+  iq
+
+# we have to overrite reply, because we pass in the callback fn form
+# node requests handler, we can only send a response
+# once our cmd callback has returned
+Strophe.Disco.DiscoNode::reply = (iq, fn) ->
+  req = @parseRequest(iq)
+  res = @fromTo(req)
+  @fn = fn
+  @addFirstChild req, res
+  @addContent req, res
+  res
+
+class RemoteCommand
+
+  constructor: (@conn, @jid, @node) ->
+    @executeAction = "execute"
+    @actions = []
+    @sessionid = null
+    @data = null
+    @form = null
+    @resonseForm = null
+    @status = null
+    @error = null
+
+  _parseResult: (res) ->
+    cmd = ($ res).find "command"
+    @sessionid = cmd.attr "sessionid"
+    @status = cmd.attr "status"
+    @_parseActions cmd
+    @_parseResultForm cmd
+    @_parseError res
+
+  _parseActions: (cmd) ->
+    actions = cmd.find "actions"
+    if actions.length > 0
+      @executeAction = actions.attr "execute"
+      @actions = (a.nodeName for a in actions.children())
+
+  _parseResultForm:(cmd) ->
+    x = cmd.find "x"
+    if x.length > 0
+      @form = Strophe.x.Form.fromXML x
+    else
+      @form = null
+
+  _parseError: (res) ->
+    res = $ res
+    err = res.find "error"
+    if err.length > 0
+      @error =
+        code: err.attr "code"
+        type: err.attr "type"
+        conditions: ( e.nodeName for e in err.children())
+    else
+      @error = null
+
+  _parseSubmitFormFromHTML: (html) ->
+    form = Strophe.x.Form.fromHTML html
+    form.type = "submit"
+    for f in form.fields
+      f.options = []
+      f.required = false
+    form
+
+  _createFn: (action, div, opt) ->
+
+    close = -> div.dialog "close"
+    switch action.toLowerCase()
+
+      when "next" then =>
+        close()
+        opt.responseForm = @_parseSubmitFormFromHTML div
+        @next opt
+
+      when "prev" then =>
+        close()
+        @prev opt
+
+      when "complete" then =>
+        close()
+        opt.responseForm = @_parseSubmitFormFromHTML div
+        @complete opt
+
+      when "cancel" then =>
+        close()
+        @cancel opt
+
+      else =>
+
+  openDialog: (opt) =>
+
+    throw new Error "jQuery dialog is not available" unless $.fn.dialog
+
+    if @form
+      actions = {}
+      div = $ @form.toHTML()
+      actions[a] = @_createFn a, div, opt for a in @actions
+
+      div.find("h1").remove()
+      div.dialog
+        autoOpen: true
+        modal: true
+        title: @form.title
+        buttons: actions
+
+  onSuccess: (res, cmd) ->
+
+  onError: (res, cmd) ->
+    if console and cmd.error
+      console.error """could not exectute command.
+        Error:
+          Type: #{ cmd.error.type },
+          Code: #{ cmd.error.code },"
+          Conditions: #{ cmd.error.conditions.join ',' }"""
+
+  _exec: (opt) ->
+    if opt.gui is true
+      opt.success = (res, cmd) ->
+        cmd.openDialog opt
+
+    @conn.cmds.execute @jid, @node,
+      success: (res) =>
+        @_parseResult res
+        if opt.success
+          opt.success res, @
+        else
+          @onSuccess res, @
+      error: (res) =>
+        @_parseResult res
+        if opt.error
+          opt.error res, @
+        else
+          @onError res, @
+      sid: @sessionid
+      action: @executeAction
+      form: @responseForm
+
+  execute: (opt) -> @_exec opt
+
+  next: (opt) ->
+    @responseForm = opt.responseForm if opt.responseForm
+    @executeAction = "next"
+    @_exec opt
+
+  prev: (opt)->
+    @executeAction = "prev"
+    @_exec opt
+
+  complete: (opt) ->
+    @responseForm = opt.responseForm if opt.responseForm
+    @executeAction = "complete"
+    @_exec opt
+
+  cancel: (opt)->
+    @executeAction = "cancel"
+    @_exec opt
+
+  isValidAction: (action) -> (action in @actions)
+
+  toIQ: -> createExecIQ { @jid, @node, @action, @sessionid, @data }
+
+class CommandNode extends Strophe.Disco.DiscoNode
+
+  constructor: (cfg) -> @[k] = v for k,v of cfg
+
+  send: -> $iq {}
+
+  callback: (onSucces, onError) -> @onSuccess {}
+
+  addContent: (req, res) ->
+    @req = req
+    @res = res
+    @callback.call @, @onSuccess.bind(@), @onError.bind(@)
+
+  onError: ->
+    res.attrs status: "error"
+    @fn.call @, res
+
+  onSuccess: (obj) ->
+    res = @res
+    item = @item
+    res.attrs status: "completed"
+    res.c(item).t(entry).up() for i, entry of obj if $.isArray(obj)
+    @fn.call @, res
+
+Strophe.Commands =
+  CommandNode: CommandNode
+  RemoteCommand: RemoteCommand
+  create: create
+
+Strophe.addConnectionPlugin "cmds", do ->
+
+  conn = cmds = null
+
+  init = (c) ->
+    conn = c
+    Strophe.addNamespace "COMMANDS", CMD
+    cmds = conn.disco.features[CMD] = { items: [] }
+
+  add = (item) ->
+    throw "command needs a node" unless item.node
+    item.jid = conn.jid unless item.jid
+    cmds.items.push new CommandNode item
+
+  reply = (iq) ->
+    node = ($ "command", iq).attr("node")
+    n = $.grep(cmds.items, (n) -> n.node is node)
+    if n.length is 0
+      nodeImpl = new DiscoNodeNotFound
+      conn.send nodeImpl.reply iq
+    else
+      nodeImpl = n[0]
+      nodeImpl.reply(iq, (res) => conn.send res)
+    true
+
+  statusChanged = (status, condition) ->
+    conn.addHandler reply.bind(@), CMD, "iq", "set"  if status is Strophe.Status.CONNECTED
+
+  execute = (jid, node, opt={}) ->
+
+    iq = createExecIQ
+      jid: jid
+      node: node
+      action: opt.action
+      sid: opt.sid
+      data: opt.data
+      form: opt.form
+      item: $.grep(cmds.items, (n) -> n.node is node)
+
+    noop = Strophe.Disco.noop
+    conn.sendIQ iq, opt.success or noop, opt.error or noop
+
+  # public API
+  init: init
+  statusChanged: statusChanged
+  add: add
+  execute:execute
+  exec:execute

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

@@ -0,0 +1,403 @@
+(function() {
+  var CMD, CommandNode, RemoteCommand, create, createExecIQ;
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, __indexOf = Array.prototype.indexOf || function(item) {
+    for (var i = 0, l = this.length; i < l; i++) {
+      if (this[i] === item) return i;
+    }
+    return -1;
+  }, __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
+    for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
+    function ctor() { this.constructor = child; }
+    ctor.prototype = parent.prototype;
+    child.prototype = new ctor;
+    child.__super__ = parent.prototype;
+    return child;
+  };
+  CMD = "http://jabber.org/protocol/commands";
+  create = function(node, callback) {
+    if (callback == null) {
+      callback = Strophe.Disco.noop;
+    }
+    switch (node) {
+      case "getUrls":
+        return new CommandNode({
+          item: "url",
+          node: "getUrls",
+          name: "Retrieve Urls",
+          callback: callback
+        });
+      case "setUrls":
+        return new CommandNode({
+          item: "url",
+          node: "setUrls",
+          name: "Sets Urls",
+          callback: callback
+        });
+      default:
+        throw "Strophe.Commands has no implementation for: " + node;
+    }
+  };
+  createExecIQ = function(opt) {
+    var cfg, i, iq, item, _ref;
+    iq = $iq({
+      to: opt.jid,
+      type: "set"
+    });
+    cfg = {
+      xmlns: CMD,
+      node: opt.node
+    };
+    cfg.action = opt.action || "execute";
+    if (opt.sid) {
+      cfg.sessionid = opt.sid;
+    }
+    iq.c("command", cfg);
+    if ($.isArray(opt.data)) {
+      _ref = opt.data;
+      for (i in _ref) {
+        item = _ref[i];
+        iq.c(opt.item[0].item).t(item).up();
+      }
+    } else if (opt.form) {
+      iq.cnode(opt.form.toXML());
+    }
+    return iq;
+  };
+  Strophe.Disco.DiscoNode.prototype.reply = function(iq, fn) {
+    var req, res;
+    req = this.parseRequest(iq);
+    res = this.fromTo(req);
+    this.fn = fn;
+    this.addFirstChild(req, res);
+    this.addContent(req, res);
+    return res;
+  };
+  RemoteCommand = (function() {
+    function RemoteCommand(conn, jid, node) {
+      this.conn = conn;
+      this.jid = jid;
+      this.node = node;
+      this.openDialog = __bind(this.openDialog, this);
+      this.executeAction = "execute";
+      this.actions = [];
+      this.sessionid = null;
+      this.data = null;
+      this.form = null;
+      this.resonseForm = null;
+      this.status = null;
+      this.error = null;
+    }
+    RemoteCommand.prototype._parseResult = function(res) {
+      var cmd;
+      cmd = ($(res)).find("command");
+      this.sessionid = cmd.attr("sessionid");
+      this.status = cmd.attr("status");
+      this._parseActions(cmd);
+      this._parseResultForm(cmd);
+      return this._parseError(res);
+    };
+    RemoteCommand.prototype._parseActions = function(cmd) {
+      var a, actions;
+      actions = cmd.find("actions");
+      if (actions.length > 0) {
+        this.executeAction = actions.attr("execute");
+        return this.actions = (function() {
+          var _i, _len, _ref, _results;
+          _ref = actions.children();
+          _results = [];
+          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+            a = _ref[_i];
+            _results.push(a.nodeName);
+          }
+          return _results;
+        })();
+      }
+    };
+    RemoteCommand.prototype._parseResultForm = function(cmd) {
+      var x;
+      x = cmd.find("x");
+      if (x.length > 0) {
+        return this.form = Strophe.x.Form.fromXML(x);
+      } else {
+        return this.form = null;
+      }
+    };
+    RemoteCommand.prototype._parseError = function(res) {
+      var e, err;
+      res = $(res);
+      err = res.find("error");
+      if (err.length > 0) {
+        return this.error = {
+          code: err.attr("code"),
+          type: err.attr("type"),
+          conditions: (function() {
+            var _i, _len, _ref, _results;
+            _ref = err.children();
+            _results = [];
+            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+              e = _ref[_i];
+              _results.push(e.nodeName);
+            }
+            return _results;
+          })()
+        };
+      } else {
+        return this.error = null;
+      }
+    };
+    RemoteCommand.prototype._parseSubmitFormFromHTML = function(html) {
+      var f, form, _i, _len, _ref;
+      form = Strophe.x.Form.fromHTML(html);
+      form.type = "submit";
+      _ref = form.fields;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        f = _ref[_i];
+        f.options = [];
+        f.required = false;
+      }
+      return form;
+    };
+    RemoteCommand.prototype._createFn = function(action, div, opt) {
+      var close;
+      close = function() {
+        return div.dialog("close");
+      };
+      switch (action.toLowerCase()) {
+        case "next":
+          return __bind(function() {
+            close();
+            opt.responseForm = this._parseSubmitFormFromHTML(div);
+            return this.next(opt);
+          }, this);
+        case "prev":
+          return __bind(function() {
+            close();
+            return this.prev(opt);
+          }, this);
+        case "complete":
+          return __bind(function() {
+            close();
+            opt.responseForm = this._parseSubmitFormFromHTML(div);
+            return this.complete(opt);
+          }, this);
+        case "cancel":
+          return __bind(function() {
+            close();
+            return this.cancel(opt);
+          }, this);
+        default:
+          return __bind(function() {}, this);
+      }
+    };
+    RemoteCommand.prototype.openDialog = function(opt) {
+      var a, actions, div, _i, _len, _ref;
+      if (!$.fn.dialog) {
+        throw new Error("jQuery dialog is not available");
+      }
+      if (this.form) {
+        actions = {};
+        div = $(this.form.toHTML());
+        _ref = this.actions;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          a = _ref[_i];
+          actions[a] = this._createFn(a, div, opt);
+        }
+        div.find("h1").remove();
+        return div.dialog({
+          autoOpen: true,
+          modal: true,
+          title: this.form.title,
+          buttons: actions
+        });
+      }
+    };
+    RemoteCommand.prototype.onSuccess = function(res, cmd) {};
+    RemoteCommand.prototype.onError = function(res, cmd) {
+      if (console && cmd.error) {
+        return console.error("could not exectute command.\nError:\n  Type: " + cmd.error.type + ",\n  Code: " + cmd.error.code + ",\"\n  Conditions: " + (cmd.error.conditions.join(',')));
+      }
+    };
+    RemoteCommand.prototype._exec = function(opt) {
+      if (opt.gui === true) {
+        opt.success = function(res, cmd) {
+          return cmd.openDialog(opt);
+        };
+      }
+      return this.conn.cmds.execute(this.jid, this.node, {
+        success: __bind(function(res) {
+          this._parseResult(res);
+          if (opt.success) {
+            return opt.success(res, this);
+          } else {
+            return this.onSuccess(res, this);
+          }
+        }, this),
+        error: __bind(function(res) {
+          this._parseResult(res);
+          if (opt.error) {
+            return opt.error(res, this);
+          } else {
+            return this.onError(res, this);
+          }
+        }, this),
+        sid: this.sessionid,
+        action: this.executeAction,
+        form: this.responseForm
+      });
+    };
+    RemoteCommand.prototype.execute = function(opt) {
+      return this._exec(opt);
+    };
+    RemoteCommand.prototype.next = function(opt) {
+      if (opt.responseForm) {
+        this.responseForm = opt.responseForm;
+      }
+      this.executeAction = "next";
+      return this._exec(opt);
+    };
+    RemoteCommand.prototype.prev = function(opt) {
+      this.executeAction = "prev";
+      return this._exec(opt);
+    };
+    RemoteCommand.prototype.complete = function(opt) {
+      if (opt.responseForm) {
+        this.responseForm = opt.responseForm;
+      }
+      this.executeAction = "complete";
+      return this._exec(opt);
+    };
+    RemoteCommand.prototype.cancel = function(opt) {
+      this.executeAction = "cancel";
+      return this._exec(opt);
+    };
+    RemoteCommand.prototype.isValidAction = function(action) {
+      return __indexOf.call(this.actions, action) >= 0;
+    };
+    RemoteCommand.prototype.toIQ = function() {
+      return createExecIQ({
+        jid: this.jid,
+        node: this.node,
+        action: this.action,
+        sessionid: this.sessionid,
+        data: this.data
+      });
+    };
+    return RemoteCommand;
+  })();
+  CommandNode = (function() {
+    __extends(CommandNode, Strophe.Disco.DiscoNode);
+    function CommandNode(cfg) {
+      var k, v;
+      for (k in cfg) {
+        v = cfg[k];
+        this[k] = v;
+      }
+    }
+    CommandNode.prototype.send = function() {
+      return $iq({});
+    };
+    CommandNode.prototype.callback = function(onSucces, onError) {
+      return this.onSuccess({});
+    };
+    CommandNode.prototype.addContent = function(req, res) {
+      this.req = req;
+      this.res = res;
+      return this.callback.call(this, this.onSuccess.bind(this), this.onError.bind(this));
+    };
+    CommandNode.prototype.onError = function() {
+      res.attrs({
+        status: "error"
+      });
+      return this.fn.call(this, res);
+    };
+    CommandNode.prototype.onSuccess = function(obj) {
+      var entry, i, item, res;
+      res = this.res;
+      item = this.item;
+      res.attrs({
+        status: "completed"
+      });
+      if ($.isArray(obj)) {
+        for (i in obj) {
+          entry = obj[i];
+          res.c(item).t(entry).up();
+        }
+      }
+      return this.fn.call(this, res);
+    };
+    return CommandNode;
+  })();
+  Strophe.Commands = {
+    CommandNode: CommandNode,
+    RemoteCommand: RemoteCommand,
+    create: create
+  };
+  Strophe.addConnectionPlugin("cmds", (function() {
+    var add, cmds, conn, execute, init, reply, statusChanged;
+    conn = cmds = null;
+    init = function(c) {
+      conn = c;
+      Strophe.addNamespace("COMMANDS", CMD);
+      return cmds = conn.disco.features[CMD] = {
+        items: []
+      };
+    };
+    add = function(item) {
+      if (!item.node) {
+        throw "command needs a node";
+      }
+      if (!item.jid) {
+        item.jid = conn.jid;
+      }
+      return cmds.items.push(new CommandNode(item));
+    };
+    reply = function(iq) {
+      var n, node, nodeImpl;
+      node = ($("command", iq)).attr("node");
+      n = $.grep(cmds.items, function(n) {
+        return n.node === node;
+      });
+      if (n.length === 0) {
+        nodeImpl = new DiscoNodeNotFound;
+        conn.send(nodeImpl.reply(iq));
+      } else {
+        nodeImpl = n[0];
+        nodeImpl.reply(iq, __bind(function(res) {
+          return conn.send(res);
+        }, this));
+      }
+      return true;
+    };
+    statusChanged = function(status, condition) {
+      if (status === Strophe.Status.CONNECTED) {
+        return conn.addHandler(reply.bind(this), CMD, "iq", "set");
+      }
+    };
+    execute = function(jid, node, opt) {
+      var iq, noop;
+      if (opt == null) {
+        opt = {};
+      }
+      iq = createExecIQ({
+        jid: jid,
+        node: node,
+        action: opt.action,
+        sid: opt.sid,
+        data: opt.data,
+        form: opt.form,
+        item: $.grep(cmds.items, function(n) {
+          return n.node === node;
+        })
+      });
+      noop = Strophe.Disco.noop;
+      return conn.sendIQ(iq, opt.success || noop, opt.error || noop);
+    };
+    return {
+      init: init,
+      statusChanged: statusChanged,
+      add: add,
+      execute: execute,
+      exec: execute
+    };
+  })());
+}).call(this);