resolve merge-conflict with accounting branch

www/common/encode.js

@@ -0,0 +1,19 @@
+define([], function () {
+    var exports = {};
+
+    var hexToUint8Array = exports.hexToUint8Array = function (s) {
+        // if not hex or odd number of characters
+        if (!/[a-fA-F0-9]+/.test(s) || s.length % 2) { throw new Error("string is not hex"); }
+        return s.split(/([0-9a-fA-F]{2})/)
+            .filter(function (x) { return x; })
+            .map(function (x) { return Number('0x' + x); });
+    };
+
+    var uint8ArrayToHex = exports.uint8ArrayToHex = function (a) {
+        return a.reduce(function(memo, i) {
+            return memo + ((i < 16) ? '0' : '') + i.toString(16);
+        }, '');
+    };
+
+    return exports;
+});

www/common/pinpad.js

@@ -0,0 +1,57 @@
+define([
+    '/common/cryptpad-common.js',
+    '/common/rpc.js',
+
+    '/bower_components/tweetnacl/nacl-fast.min.js'
+], function (Cryptpad, Rpc) {
+
+    var Nacl = window.nacl;
+
+    var deduplicate = function (array) {
+        var a = array.slice();
+        for(var i=0; i<a.length; i++) {
+            for(var j=i+1; j<a.length; j++) {
+                if(a[i] === a[j]) { a.splice(j--, 1); }
+            }
+        }
+        return a;
+    };
+
+    var create = function (network, ed) {
+        var exp = {};
+        var rpc = Rpc.create(network, ed);
+
+        var checkHash = exp.checkHash = function (fileList) {
+            //var fileList = fo.getFilesDataFiles();
+            var channelIdList = [];
+            fileList.forEach(function (href) {
+                var parsedHref = Cryptpad.parsePadUrl(href);
+                if (!parsedHref || !parsedHref.hash) { return; }
+                var parsedHash = Cryptpad.parseHash(parsedHref.hash);
+                if (!parsedHash || !parsedHash.channel) { return; }
+                channelIdList.push(Cryptpad.base64ToHex(parsedHash.channel));
+            });
+            var uniqueList = deduplicate(channelIdList).sort();
+
+            /*
+1. every time you want to pin or unpid a pad you send a message to the server
+2. the server sends back a hash of the sorted list of your pinned pads
+3. you hash your sorted list of pinned pads that you should have according to your drive
+4. compare them, if same
+    AWESOME
+  if they are not
+    UNPIN all, send all
+
+            */
+
+            var hash = Nacl.util.encodeBase64(Nacl.hash(Nacl.util.decodeUTF8( JSON.stringify(uniqueList) )));
+
+            console.log(hash);
+            return hash;
+        };
+
+        return exp;
+    };
+
+    return { create: create };
+});

www/common/rpc.js

@@ -0,0 +1,106 @@
+define([
+    '/common/encode.js',
+
+    '/bower_components/tweetnacl/nacl-fast.min.js',
+], function (Encode) {
+    var MAX_LAG_BEFORE_TIMEOUT = 30000;
+
+    var uid = function () {
+        return Number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER))
+            .toString(32).replace(/\./g, '');
+    };
+
+    /*
+types of messages:
+    pin -> hash
+    unpin -> hash
+    getHash -> hash
+    getTotalSize -> bytes
+    getFileSize -> bytes
+
+    */
+
+/*  RPC communicates only with the history keeper
+    messages have the format:
+        [TYPE, txid, msg]
+*/
+    var sendMsg = function (ctx, type, msg, cb) {
+        var network = ctx.network;
+        var hkn = network.historyKeeper;
+        var txid = uid();
+
+        ctx.pending[txid] = cb;
+
+        return network.sendto(hkn, JSON.stringify([txid, type, msg]));
+    };
+
+    var parse = function (msg) {
+        try {
+            return JSON.parse(msg);
+        } catch (e) {
+            return null;
+        }
+    };
+
+/*  Returning messages have the format:
+    [txid, {}]
+*/
+    var onMsg = function (ctx, msg) {
+        var parsed = parse(msg);
+
+        if (!parsed) {
+            // TODO handle error
+            console.log(msg);
+            return;
+        }
+
+        var txid = parsed[0];
+        var pending = ctx.pending[txid];
+        var response = parsed.slice(1);
+
+        if (typeof(pending) === 'function') {
+            if (response[0] === 'ERROR') {
+                return void pending(response[1]);
+            }
+            pending(void 0, response);
+        } else {
+            console.log("No callback provided");
+        }
+    };
+
+    var cookie = function (ctx, cb) {
+        // TODO txid
+    };
+
+    var signMsg = function (msg, secKey) {
+        // TODO
+    };
+
+    var create = function (network, edPrivateKey) {
+        if (!/[0-9a-f]{64}/.test(edPrivateKey)) {
+            //throw new Error("private signing key is not valid");
+        }
+        var ctx = {
+            //privateKey: Encode.hexToUint8Array(edPrivateKey),
+            seq: new Date().getTime(),
+            network: network,
+            timeouts: {}, // timeouts
+            pending: {}, // callbacks
+        };
+
+        var pin = function (channel, cb) { };
+
+        var send = function (type, msg, cb) {
+            return sendMsg(ctx, type, msg, cb);
+        };
+        network.on('message', function (msg, sender) {
+            onMsg(ctx, msg);
+        });
+        return {
+            cookie: function (cb) { cookie(ctx, cb); },
+            send: send,
+        };
+    };
+
+    return { create: create };
+});