added lots of magic

build/node/ConnectorClass.js

@@ -137,13 +137,13 @@ module.exports = {
   /*
    * Broadcast a message to all connected peers.
    * @param message {Object} The message to broadcast.
-  #
+   *
   broadcast: (message)->
     throw new Error "You must implement broadcast!"
   
-  #
+   *
    * Send a message to a peer, or set of peers
-  #
+   *
   send: (peer_s, message)->
     throw new Error "You must implement send!"
    */

examples/indexedDB/index.coffee

@@ -1,48 +1,172 @@
 
-class Buffer
-  constructor: (@buffer)->
-  set: (op)->
+class DBTransaction
+  constructor: (@t)->
+
+  setOperation: (op)->
     that = this
-    new Promise (resolve, reject)=>
-      request = that.buffer.put op
-      request.onsuccess = (event)->
+    new Promise (resolve, reject)->
+      req = that.t.objectStore("HistoryBuffer").put op
+      req.onsuccess = (event)->
         resolve op
-      request.onerror = (event)->
-        reject "Could not set value!"
+      req.onerror = (event)->
+        reject "Could not set Operation!"
 
-  get: (uid)->
+  getOperation: (uid)->
     that = this
-    new Promise (resolve, reject)=>
-      request = that.buffer.get uid
-      request.onsuccess = (event)->
-        resolve request.result
-      request.onerror = (event)->
-        reject "Could not set value!"
+    new Promise (resolve, reject)->
+      req = that.t.objectStore("HistoryBuffer").get uid
+      req.onsuccess = (event)->
+        resolve req.result
+      req.onerror = (event)->
+        reject "Could not get Operation!"
 
-class window.HB
+  getOperations: (state_map)->
+    flow = Promise.resolve()
+    ops = []
+    that = this
+    hb = that.t.objectStore("HistoryBuffer")
+
+    that.getStateVector().then (end_state_vector)->
+      for end_state of end_state_vector
+        # convert to the db-structure
+        do (end_state = end_state)->
+          start_state =
+            user: end_state.name
+            state: state_map[end_state] ? 0
+
+          flow = flow.then ()->
+            from = [start_state.user, start_state.number]
+            to = [end_state.user, end_state.number]
+            range = IDBKeyRange.bound from, to
+            defer = Promise.defer()
+
+            hb.openCursor(range).onsuccess = ()->
+              cursor = event.target.result
+              if cursor?
+                ops.push cursor.value # add Operation
+                cursor.continue()
+              else
+                # got all ops from this user
+                defer.resolve ops
+            defer.promise
+
+  setState: (state)->
+    that = this
+    new Promise (resolve, reject)->
+      req = that.t.objectStore("StateVector").put state
+      req.onsuccess = (event)->
+        resolve state
+      req.onerror = (event)->
+        reject "Could not set state vector!"
+
+  getState: (user)->
+    defer = Promise.defer()
+    req = @t.objectStore("StateVector").get user
+    req.onsuccess = (event)->
+      defer.resolve req.result
+    req.onerror = (event)->
+      defer.reject "Could not get state vector!"
+    defer.promise
+
+  getStateVector: ()->
+    defer = Promise.defer()
+    state_vector = []
+    @t.objectStore("StateVector").openCursor().onsuccess = ()->
+      cursor = event.target.result
+      if cursor?
+        state = cursor.value
+        state_vector.push state
+        cursor.continue()
+      else
+        # got all ops from this user
+        defer.resolve state_vector
+    defer.promise
+
+
+
+class Transaction
+  constructor: (@t)->
+
+  updateOperation: (op)->
+    @t.setOperation op
+
+  addOperation: (op)->
+    that = this
+    @t.getState op.uid[0]
+      .then (state)->
+        # only add operation if this is an expected operation
+        if not state?
+          state =
+            user: op.uid[0]
+            number: 0
+        if op.uid[1] is state.number
+          state.number++
+          that.t.setState state
+        else
+          return Promise.reject("Unexpected Operation")
+      .then that.t.setOperation op
+
+  getOperation: (uid)->
+    @t.getOperation uid
+
+  getState: (user)->
+    @t.getState user
+
+  getOperations: (state_vector)->
+    @t.getOperations state_vector
+
+
+class window.DB
   constructor: ()->
     @ready = (new Promise (resolve, reject)->
-      request = indexedDB.open "Testy", 7
-      request.onerror = ()->
+      req = indexedDB.open "Testy", 7
+      req.onerror = ()->
         reject "Couldn't open the IndexedDB database!"
-      request.onsuccess = (event)->
+      req.onsuccess = (event)->
         resolve event.target.result
-      request.onupgradeneeded = (event)->
+      req.onupgradeneeded = (event)->
         db = event.target.result
         objectStore = db.createObjectStore "HistoryBuffer", {keyPath: "uid"}
+        objectStore = db.createObjectStore "StateVector", {keyPath: "user"}
+
     ).catch (message)->
       throw new Error message
 
-  requestBuffer: ()->
+  requestTransaction: ()->
     @ready.then (db)->
       new Promise (resolve, reject)->
-        resolve new Buffer(db.transaction(["HistoryBuffer"], "readwrite").objectStore("HistoryBuffer"))
+        resolve new Transaction( new DBTransaction(db.transaction(["HistoryBuffer", "StateVector"], "readwrite")) )
 
   removeDatabase: ()->
     req = indexedDB.deleteDatabase "Testy"
     req.onsuccess = ()->
       console.log("Deleted database successfully");
+    req.onblocked = ()->
+      console.log("Database is currently being blocked")
+      console.dir arguments
     req.onerror = ()->
       console.log("Couldn't delete database")
+      console.dir arguments
+    null
 
-window.hb = new HB()
+window.db = new DB()
+
+window.addDummyDataSet = ()->
+  db.requestTransaction().then (t)->
+    t.getState("dmonad").then (state)->
+      state ?= {number: 0}
+      t.addOperation({uid: ["dmonad", state.number]})
+
+window.getOp = (num = 3)->
+  db.requestTransaction().then (t)->
+    t.getOperation(["dmonad", num])
+      .then (op)->
+        console.log("yay:")
+        console.log(op)
+
+window.getOps = (state_map = {dmonad: 5})->
+  db.requestTransaction().then (t)->
+    t.getOperations(state_map)
+      .then (op)->
+        console.log("yay:")
+        console.log(op)

examples/indexedDB/index.js

@@ -1,96 +1,272 @@
 // Generated by CoffeeScript 1.9.2
 (function() {
-  var Buffer;
+  var DBTransaction, Transaction;
 
-  Buffer = (function() {
-    function Buffer(buffer) {
-      this.buffer = buffer;
+  DBTransaction = (function() {
+    function DBTransaction(t1) {
+      this.t = t1;
     }
 
-    Buffer.prototype.set = function(op) {
+    DBTransaction.prototype.setOperation = function(op) {
       var that;
       that = this;
-      return new Promise((function(_this) {
-        return function(resolve, reject) {
-          var request;
-          request = that.buffer.put(op);
-          request.onsuccess = function(event) {
-            return resolve(op);
-          };
-          return request.onerror = function(event) {
-            return reject("Could not set value!");
-          };
+      return new Promise(function(resolve, reject) {
+        var req;
+        req = that.t.objectStore("HistoryBuffer").put(op);
+        req.onsuccess = function(event) {
+          return resolve(op);
         };
-      })(this));
+        return req.onerror = function(event) {
+          return reject("Could not set Operation!");
+        };
+      });
     };
 
-    Buffer.prototype.get = function(uid) {
+    DBTransaction.prototype.getOperation = function(uid) {
       var that;
       that = this;
-      return new Promise((function(_this) {
-        return function(resolve, reject) {
-          var request;
-          request = that.buffer.get(uid);
-          request.onsuccess = function(event) {
-            return resolve(request.result);
-          };
-          return request.onerror = function(event) {
-            return reject("Could not set value!");
-          };
+      return new Promise(function(resolve, reject) {
+        var req;
+        req = that.t.objectStore("HistoryBuffer").get(uid);
+        req.onsuccess = function(event) {
+          return resolve(req.result);
         };
-      })(this));
+        return req.onerror = function(event) {
+          return reject("Could not get Operation!");
+        };
+      });
     };
 
-    return Buffer;
+    DBTransaction.prototype.getOperations = function(state_map) {
+      var flow, hb, ops, that;
+      flow = Promise.resolve();
+      ops = [];
+      that = this;
+      hb = that.t.objectStore("HistoryBuffer");
+      return that.getStateVector().then(function(end_state_vector) {
+        var end_state, results;
+        results = [];
+        for (end_state in end_state_vector) {
+          results.push((function(end_state) {
+            var ref, start_state;
+            start_state = {
+              user: end_state.name,
+              state: (ref = state_map[end_state]) != null ? ref : 0
+            };
+            return flow = flow.then(function() {
+              var defer, from, range, to;
+              from = [start_state.user, start_state.number];
+              to = [end_state.user, end_state.number];
+              range = IDBKeyRange.bound(from, to);
+              defer = Promise.defer();
+              hb.openCursor(range).onsuccess = function() {
+                var cursor;
+                cursor = event.target.result;
+                if (cursor != null) {
+                  ops.push(cursor.value);
+                  return cursor["continue"]();
+                } else {
+                  return defer.resolve(ops);
+                }
+              };
+              return defer.promise;
+            });
+          })(end_state));
+        }
+        return results;
+      });
+    };
+
+    DBTransaction.prototype.setState = function(state) {
+      var that;
+      that = this;
+      return new Promise(function(resolve, reject) {
+        var req;
+        req = that.t.objectStore("StateVector").put(state);
+        req.onsuccess = function(event) {
+          return resolve(state);
+        };
+        return req.onerror = function(event) {
+          return reject("Could not set state vector!");
+        };
+      });
+    };
+
+    DBTransaction.prototype.getState = function(user) {
+      var defer, req;
+      defer = Promise.defer();
+      req = this.t.objectStore("StateVector").get(user);
+      req.onsuccess = function(event) {
+        return defer.resolve(req.result);
+      };
+      req.onerror = function(event) {
+        return defer.reject("Could not get state vector!");
+      };
+      return defer.promise;
+    };
+
+    DBTransaction.prototype.getStateVector = function() {
+      var defer, state_vector;
+      defer = Promise.defer();
+      state_vector = [];
+      this.t.objectStore("StateVector").openCursor().onsuccess = function() {
+        var cursor, state;
+        cursor = event.target.result;
+        if (cursor != null) {
+          state = cursor.value;
+          state_vector.push(state);
+          return cursor["continue"]();
+        } else {
+          return defer.resolve(state_vector);
+        }
+      };
+      return defer.promise;
+    };
+
+    return DBTransaction;
 
   })();
 
-  window.HB = (function() {
-    function HB() {
+  Transaction = (function() {
+    function Transaction(t1) {
+      this.t = t1;
+    }
+
+    Transaction.prototype.updateOperation = function(op) {
+      return this.t.setOperation(op);
+    };
+
+    Transaction.prototype.addOperation = function(op) {
+      var that;
+      that = this;
+      return this.t.getState(op.uid[0]).then(function(state) {
+        if (state == null) {
+          state = {
+            user: op.uid[0],
+            number: 0
+          };
+        }
+        if (op.uid[1] === state.number) {
+          state.number++;
+          return that.t.setState(state);
+        } else {
+          return Promise.reject("Unexpected Operation");
+        }
+      }).then(that.t.setOperation(op));
+    };
+
+    Transaction.prototype.getOperation = function(uid) {
+      return this.t.getOperation(uid);
+    };
+
+    Transaction.prototype.getState = function(user) {
+      return this.t.getState(user);
+    };
+
+    Transaction.prototype.getOperations = function(state_vector) {
+      return this.t.getOperations(state_vector);
+    };
+
+    return Transaction;
+
+  })();
+
+  window.DB = (function() {
+    function DB() {
       this.ready = (new Promise(function(resolve, reject) {
-        var request;
-        request = indexedDB.open("Testy", 7);
-        request.onerror = function() {
+        var req;
+        req = indexedDB.open("Testy", 7);
+        req.onerror = function() {
           return reject("Couldn't open the IndexedDB database!");
         };
-        request.onsuccess = function(event) {
+        req.onsuccess = function(event) {
           return resolve(event.target.result);
         };
-        return request.onupgradeneeded = function(event) {
+        return req.onupgradeneeded = function(event) {
           var db, objectStore;
           db = event.target.result;
-          return objectStore = db.createObjectStore("HistoryBuffer", {
+          objectStore = db.createObjectStore("HistoryBuffer", {
             keyPath: "uid"
           });
+          return objectStore = db.createObjectStore("StateVector", {
+            keyPath: "user"
+          });
         };
       }))["catch"](function(message) {
         throw new Error(message);
       });
     }
 
-    HB.prototype.requestBuffer = function() {
+    DB.prototype.requestTransaction = function() {
       return this.ready.then(function(db) {
         return new Promise(function(resolve, reject) {
-          return resolve(new Buffer(db.transaction(["HistoryBuffer"], "readwrite").objectStore("HistoryBuffer")));
+          return resolve(new Transaction(new DBTransaction(db.transaction(["HistoryBuffer", "StateVector"], "readwrite"))));
         });
       });
     };
 
-    HB.prototype.removeDatabase = function() {
+    DB.prototype.removeDatabase = function() {
       var req;
       req = indexedDB.deleteDatabase("Testy");
       req.onsuccess = function() {
         return console.log("Deleted database successfully");
       };
-      return req.onerror = function() {
-        return console.log("Couldn't delete database");
+      req.onblocked = function() {
+        console.log("Database is currently being blocked");
+        return console.dir(arguments);
       };
+      req.onerror = function() {
+        console.log("Couldn't delete database");
+        return console.dir(arguments);
+      };
+      return null;
     };
 
-    return HB;
+    return DB;
 
   })();
 
-  window.hb = new HB();
+  window.db = new DB();
+
+  window.addDummyDataSet = function() {
+    return db.requestTransaction().then(function(t) {
+      return t.getState("dmonad").then(function(state) {
+        if (state == null) {
+          state = {
+            number: 0
+          };
+        }
+        return t.addOperation({
+          uid: ["dmonad", state.number]
+        });
+      });
+    });
+  };
+
+  window.getOp = function(num) {
+    if (num == null) {
+      num = 3;
+    }
+    return db.requestTransaction().then(function(t) {
+      return t.getOperation(["dmonad", num]).then(function(op) {
+        console.log("yay:");
+        return console.log(op);
+      });
+    });
+  };
+
+  window.getOps = function(state_map) {
+    if (state_map == null) {
+      state_map = {
+        dmonad: 5
+      };
+    }
+    return db.requestTransaction().then(function(t) {
+      return t.getOperations(state_map).then(function(op) {
+        console.log("yay:");
+        return console.log(op);
+      });
+    });
+  };
 
 }).call(this);