Deploy 11.2.0

Deploy 11.1.0
Deploy 11.0.4
2016-05-10 18:12:57 +02:00 · 2016-05-07 13:20:37 +01:00 · 2016-05-02 10:59:58 +02:00 · 2016-04-30 23:00:23 +01:00 · 2016-04-27 12:04:30 +01:00 · 2016-04-26 21:28:18 +02:00
8 changed files with 328 additions and 79 deletions
--- a/Examples/Drawing/index.html
+++ b/Examples/Drawing/index.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<body>
+  <style>
+    path {
+      fill: none;
+      stroke: blue;
+      stroke-width: 1px;
+      stroke-linejoin: round;
+      stroke-linecap: round;
+    }
+  </style>
+  <button type="button" id="clearDrawingCanvas">Clear Drawing</button>
+  <svg id="drawingCanvas" viewbox="0 0 100 100" width="100%"></svg>
+  <script src="../bower_components/yjs/y.js"></script>
+  <script src="../bower_components/d3/d3.js"></script>
+  <script src="./index.js"></script>
+</body>
+</html>
--- a/Examples/Drawing/index.js
+++ b/Examples/Drawing/index.js
@@ -0,0 +1,88 @@
+/* globals Y, d3 */
+'strict mode'
+
+Y({
+  db: {
+    name: 'memory'
+  },
+  connector: {
+    name: 'websockets-client',
+    room: 'drawing-example'
+    // url: 'localhost:1234'
+  },
+  sourceDir: '/bower_components',
+  share: {
+    drawing: 'Array'
+  }
+}).then(function (y) {
+  window.yDrawing = y
+  var drawing = y.share.drawing
+  var renderPath = d3.svg.line()
+    .x(function (d) { return d[0] })
+    .y(function (d) { return d[1] })
+    .interpolate('basis')
+
+  var svg = d3.select('#drawingCanvas')
+    .call(d3.behavior.drag()
+      .on('dragstart', dragstart)
+      .on('drag', drag)
+      .on('dragend', dragend))
+
+  // create line from a shared array object and update the line when the array changes
+  function drawLine (yarray) {
+    var line = svg.append('path').datum(yarray.toArray())
+    line.attr('d', renderPath)
+    yarray.observe(function (event) {
+      // we only implement insert events that are appended to the end of the array
+      event.values.forEach(function (value) {
+        line.datum().push(value)
+      })
+      line.attr('d', renderPath)
+    })
+  }
+  // call drawLine every time an array is appended
+  y.share.drawing.observe(function (event) {
+    if (event.type === 'insert') {
+      event.values().then(function (values) {
+        values.forEach(drawLine)
+      })
+    } else {
+      // just remove all elements (thats what we do anyway)
+      svg.selectAll('path').remove()
+    }
+  })
+  // draw all existing content
+  for (var i = 0; i < drawing.length; i++) {
+    drawing.get(i).then(drawLine)
+  }
+
+  // clear canvas on request
+  document.querySelector('#clearDrawingCanvas').onclick = function () {
+    drawing.delete(0, drawing.length)
+  }
+
+  var sharedLine = null
+  function dragstart () {
+    drawing.insert(drawing.length, [Y.Array])
+    drawing.get(drawing.length - 1).then(function (array) {
+      sharedLine = array
+    })
+  }
+
+  // After one dragged event is recognized, we ignore them for 33ms.
+  var ignoreDrag = null
+  function drag () {
+    if (sharedLine != null && ignoreDrag == null) {
+      ignoreDrag = window.setTimeout(function () {
+        ignoreDrag = null
+      }, 33)
+      sharedLine.push([d3.mouse(this)])
+    }
+  }
+
+  function dragend () {
+    sharedLine = null
+    window.clearTimeout(ignoreDrag)
+    ignoreDrag = null
+  }
+})
--- a/Examples/bower.json
+++ b/Examples/bower.json
@@ -18,10 +18,11 @@
    "y-websockets-client": "latest",
    "y-text": "latest",
    "y-indexeddb": "latest",
-    "y-xml": "latest", 
+    "y-xml": "latest",
    "quill": "~0.20.1",
    "ace": "~1.2.3",
    "ace-builds": "~1.2.3",
-    "jquery": "~2.2.2"
+    "jquery": "~2.2.2",
+    "d3": "^3.5.16"
  }
 }
--- a/bower.json
+++ b/bower.json
@@ -1,6 +1,6 @@
 {
  "name": "yjs",
-  "version": "11.0.1",
+  "version": "11.2.0",
  "homepage": "y-js.org",
  "authors": [
    "Kevin Jahns <kevin.jahns@rwth-aachen.de>"
--- a/y.es6
+++ b/y.es6
@@ -498,7 +498,7 @@ module.exports = function (Y) {
              } else {
                resolve()
              }
-            }, 10)
+            }, 0)
          }
        }
        globalRoom.whenTransactionsFinished().then(nextFlush)
@@ -659,7 +659,7 @@ module.exports = function (Y /* :any */) {
      }
      this.gc1 = [] // first stage
      this.gc2 = [] // second stage -> after that, remove the op
-      this.gcTimeout = !opts.gcTimeout ? 50000 : opts.gcTimeoutś
+      this.gcTimeout = !opts.gcTimeout ? 50000 : opts.gcTimeouts
      function garbageCollect () {
        return os.whenTransactionsFinished().then(function () {
          if (os.gc1.length > 0 || os.gc2.length > 0) {
@@ -963,56 +963,73 @@ module.exports = function (Y /* :any */) {
        }
      }
    }
-    // called by a transaction when an operation is added
+    /*
+     * Called by a transaction when an operation is added.
+     * This function is especially important for y-indexeddb, where several instances may share a single database.
+     * Every time an operation is created by one instance, it is send to all other instances and operationAdded is called
+     *
+     * If it's not a Delete operation:
+     *   * Checks if another operation is executable (listenersById)
+     *   * Update state, if possible
+     *
+     * Always:
+     *   * Call type
+     */
    * operationAdded (transaction, op) {
-      // increase SS
-      yield* transaction.updateState(op.id[0])
-
-      var opLen = op.content != null ? op.content.length : 1
-      for (let i = 0; i < opLen; i++) {
-        // notify whenOperation listeners (by id)
-        var sid = JSON.stringify([op.id[0], op.id[1] + i])
-        var l = this.listenersById[sid]
-        delete this.listenersById[sid]
-
-        if (l != null) {
-          for (var key in l) {
-            var listener = l[key]
-            if (--listener.missing === 0) {
-              this.whenOperationsExist([], listener.op)
+      if (op.struct === 'Delete') {
+        var target = yield* transaction.getInsertion(op.target)
+        var type = this.initializedTypes[JSON.stringify(target.parent)]
+        if (type != null) {
+          yield* type._changed(transaction, op)
+        }
+      } else {
+        // increase SS
+        yield* transaction.updateState(op.id[0])
+        var opLen = op.content != null ? op.content.length : 1
+        for (let i = 0; i < opLen; i++) {
+          // notify whenOperation listeners (by id)
+          var sid = JSON.stringify([op.id[0], op.id[1] + i])
+          var l = this.listenersById[sid]
+          delete this.listenersById[sid]
+          if (l != null) {
+            for (var key in l) {
+              var listener = l[key]
+              if (--listener.missing === 0) {
+                this.whenOperationsExist([], listener.op)
+              }
            }
          }
        }
-      }
-      var t = this.initializedTypes[JSON.stringify(op.parent)]
+        var t = this.initializedTypes[JSON.stringify(op.parent)]

-      // if parent is deleted, mark as gc'd and return
-      if (op.parent != null) {
-        var parentIsDeleted = yield* transaction.isDeleted(op.parent)
-        if (parentIsDeleted) {
-          yield* transaction.deleteList(op.id)
-          return
+        // if parent is deleted, mark as gc'd and return
+        if (op.parent != null) {
+          var parentIsDeleted = yield* transaction.isDeleted(op.parent)
+          if (parentIsDeleted) {
+            yield* transaction.deleteList(op.id)
+            return
+          }
        }
-      }

-      // notify parent, if it was instanciated as a custom type
-      if (t != null) {
-        let o = Y.utils.copyObject(op)
-        yield* t._changed(transaction, o)
-      }
-      if (!op.deleted) {
-        // Delete if DS says this is actually deleted
-        var len = op.content != null ? op.content.length : 1
-        var startId = op.id // You must not use op.id in the following loop, because op will change when deleted
-        for (let i = 0; i < len; i++) {
-          var id = [startId[0], startId[1] + i]
-          var opIsDeleted = yield* transaction.isDeleted(id)
-          if (opIsDeleted) {
-            var delop = {
-              struct: 'Delete',
-              target: id
+        // notify parent, if it was instanciated as a custom type
+        if (t != null) {
+          let o = Y.utils.copyOperation(op)
+          yield* t._changed(transaction, o)
+        }
+        if (!op.deleted) {
+          // Delete if DS says this is actually deleted
+          var len = op.content != null ? op.content.length : 1
+          var startId = op.id // You must not use op.id in the following loop, because op will change when deleted
+          for (let i = 0; i < len; i++) {
+            var id = [startId[0], startId[1] + i]
+            var opIsDeleted = yield* transaction.isDeleted(id)
+            if (opIsDeleted) {
+              var delop = {
+                struct: 'Delete',
+                target: id
+              }
+              yield* this.tryExecute.call(transaction, delop)
            }
-            yield* this.tryExecute.call(transaction, delop)
          }
        }
      }
@@ -1063,14 +1080,9 @@ module.exports = function (Y /* :any */) {
      this.waitingTransactions.push(makeGen)
      if (!this.transactionInProgress) {
        this.transactionInProgress = true
-        if (false || callImmediately) { // TODO: decide whether this is ok or not..
+        setTimeout(() => {
          this.transact(this.getNextRequest())
-        } else {
-          var self = this
-          setTimeout(function () {
-            self.transact(self.getNextRequest())
-          }, 0)
-        }
+        }, 0)
      }
    }
  }
@@ -1746,14 +1758,11 @@ module.exports = function (Y/* :any */) {
            right = null
          }
          if (callType && !preventCallType) {
-            var type = this.store.initializedTypes[JSON.stringify(target.parent)]
-            if (type != null) {
-              yield* type._changed(this, {
-                struct: 'Delete',
-                target: target.id,
-                length: targetLength
-              })
-            }
+            yield* this.store.operationAdded(this, {
+              struct: 'Delete',
+              target: target.id,
+              length: targetLength
+            })
          }
          // need to gc in the end!
          yield* this.store.addToGarbageCollector.call(this, target, left)
@@ -2560,7 +2569,7 @@ module.exports = function (Y/* :any */) {
    /* this is what we used before.. use this as a reference..
    * makeOperationReady (startSS, op) {
      op = Y.Struct[op.struct].encode(op)
-      op = Y.utils.copyObject(op)
+      op = Y.utils.copyObject(op) -- use copyoperation instead now!
      var o = op
      var ids = [op.id]
      // search for the new op.right
@@ -2696,9 +2705,90 @@ module.exports = function (Y /* : any*/) {
      prematurely called operations are executed
    */
    awaitAndPrematurelyCall (ops) {
-      this.awaiting += ops.length
-      ops.forEach(this.onevent)
+      this.awaiting++
+      ops.map(Y.utils.copyOperation).forEach(this.onevent)
    }
+    * awaitOps (transaction, f, args) {
+      function notSoSmartSort (array) {
+        // this function sorts insertions in a executable order
+        var result = []
+        while (array.length > 0) {
+          for (var i = 0; i < array.length; i++) {
+            var independent = true
+            for (var j = 0; j < array.length; j++) {
+              if (Y.utils.matchesId(array[j], array[i].left)) {
+                // array[i] depends on array[j]
+                independent = false
+                break
+              }
+            }
+            if (independent) {
+              result.push(array.splice(i, 1)[0])
+              i--
+            }
+          }
+        }
+        return result
+      }
+      var before = this.waiting.length
+      // somehow create new operations
+      yield* f.apply(transaction, args)
+      // remove all appended ops / awaited ops
+      this.waiting.splice(before)
+      if (this.awaiting > 0) this.awaiting--
+      // if there are no awaited ops anymore, we can update all waiting ops, and send execute them (if there are still no awaited ops)
+      if (this.awaiting === 0 && this.waiting.length > 0) {
+        // update all waiting ops
+        for (let i = 0; i < this.waiting.length; i++) {
+          var o = this.waiting[i]
+          if (o.struct === 'Insert') {
+            var _o = yield* transaction.getInsertion(o.id)
+            if (!Y.utils.compareIds(_o.id, o.id)) {
+              // o got extended
+              o.left = [o.id[0], o.id[1] - 1]
+            } else if (_o.left == null) {
+              o.left = null
+            } else {
+              // find next undeleted op
+              var left = yield* transaction.getInsertion(_o.left)
+              while (left.deleted != null) {
+                if (left.left != null) {
+                  left = yield* transaction.getInsertion(left.left)
+                } else {
+                  left = null
+                  break
+                }
+              }
+              o.left = left != null ? Y.utils.getLastId(left) : null
+            }
+          }
+        }
+        // the previous stuff was async, so we have to check again!
+        // We also pull changes from the bindings, if there exists such a method, this could increase awaiting too
+        if (this._pullChanges != null) {
+          this._pullChanges()
+        }
+        if (this.awaiting === 0) {
+          // sort by type, execute inserts first
+          var ins = []
+          var dels = []
+          this.waiting.forEach(function (o) {
+            if (o.struct === 'Delete') {
+              dels.push(o)
+            } else {
+              ins.push(o)
+            }
+          })
+          // put in executable order
+          ins = notSoSmartSort(ins)
+          ins.forEach(this.onevent)
+          dels.forEach(this.onevent)
+          this.waiting = []
+        }
+      }
+    }
+    // TODO: Remove awaitedInserts and awaitedDeletes in favor of awaitedOps, as they are deprecated and do not always work
+    // Do this in one of the coming releases that are breaking anyway
    /*
      Call this when you successfully awaited the execution of n Insert operations
    */
@@ -2709,15 +2799,17 @@ module.exports = function (Y /* : any*/) {
        if (op.struct === 'Insert') {
          for (var i = this.waiting.length - 1; i >= 0; i--) {
            let w = this.waiting[i]
+            // TODO: do I handle split operations correctly here? Super unlikely, but yeah..
+            // Also: can this case happen? Can op be inserted in the middle of a larger op that is in $waiting?
            if (w.struct === 'Insert') {
-              if (Y.utils.compareIds(op.left, w.id)) {
+              if (Y.utils.matchesId(w, op.left)) {
                // include the effect of op in w
                w.right = op.id
                // exclude the effect of w in op
                op.left = w.left
-              } else if (Y.utils.compareIds(op.right, w.id)) {
+              } else if (Y.utils.compareIds(w.id, op.right)) {
                // similar..
-                w.left = op.id
+                w.left = Y.utils.getLastId(op)
                op.right = w.right
              }
            }
@@ -2754,12 +2846,42 @@ module.exports = function (Y /* : any*/) {
    /* (private)
      Try to execute the events for the waiting operations
    */
-    _tryCallEvents (n) {
-      this.awaiting -= n
+    _tryCallEvents () {
+      function notSoSmartSort (array) {
+        var result = []
+        while (array.length > 0) {
+          for (var i = 0; i < array.length; i++) {
+            var independent = true
+            for (var j = 0; j < array.length; j++) {
+              if (Y.utils.matchesId(array[j], array[i].left)) {
+                // array[i] depends on array[j]
+                independent = false
+                break
+              }
+            }
+            if (independent) {
+              result.push(array.splice(i, 1)[0])
+              i--
+            }
+          }
+        }
+        return result
+      }
+      if (this.awaiting > 0) this.awaiting--
      if (this.awaiting === 0 && this.waiting.length > 0) {
-        var ops = this.waiting
+        var ins = []
+        var dels = []
+        this.waiting.forEach(function (o) {
+          if (o.struct === 'Delete') {
+            dels.push(o)
+          } else {
+            ins.push(o)
+          }
+        })
+        ins = notSoSmartSort(ins)
+        ins.forEach(this.onevent)
+        dels.forEach(this.onevent)
        this.waiting = []
-        ops.forEach(this.onevent)
      }
    }
  }
@@ -2828,6 +2950,20 @@ module.exports = function (Y /* : any*/) {
  }
  Y.utils.copyObject = copyObject

+  /*
+    Copy an operation, so that it can be manipulated.
+    Note: You must not change subproperties (except o.content)!
+  */
+  function copyOperation (o) {
+    o = copyObject(o)
+    if (o.content != null) {
+      o.content = o.content.map(function (c) { return c })
+    }
+    return o
+  }
+
+  Y.utils.copyOperation = copyOperation
+
  /*
    Defines a smaller relation on Id's
  */
@@ -2836,6 +2972,11 @@ module.exports = function (Y /* : any*/) {
  }
  Y.utils.smaller = smaller

+  function inDeletionRange (del, ins) {
+    return del.target[0] === ins[0] && del.target[1] <= ins[1] && ins[1] < del.target[1] + (del.length || 1)
+  }
+  Y.utils.inDeletionRange = inDeletionRange
+
  function compareIds (id1, id2) {
    if (id1 == null || id2 == null) {
      return id1 === id2
@@ -2892,9 +3033,9 @@ module.exports = function (Y /* : any*/) {
      I tried to optimize this for performance, therefore no highlevel operations.
    */
    class SmallLookupBuffer extends Store {
-      constructor (arg) {
+      constructor (arg1, arg2) {
        // super(...arguments) -- do this when this is supported by stable nodejs
-        super(arg)
+        super(arg1, arg2)
        this.writeBuffer = createEmptyOpsArray(5)
        this.readBuffer = createEmptyOpsArray(10)
      }
--- a/y.es6.map
+++ b/y.es6.map
--- a/y.js
+++ b/y.js
--- a/y.js.map
+++ b/y.js.map
Author	SHA1	Message	Date
Kevin Jahns	b9f9c762eb	Deploy 11.2.0	2016-05-10 18:12:57 +02:00
Kevin Jahns	80ab682b0a	Deploy 11.1.0	2016-05-07 13:20:37 +01:00
Kevin Jahns	3f60690880	Deploy 11.0.4	2016-05-02 10:59:58 +02:00
Kevin Jahns	e2f93af86e	added drawing example	2016-04-30 23:00:23 +01:00
Kevin Jahns	76ebd3043d	Deploy 11.0.3	2016-04-27 12:04:30 +01:00
Kevin Jahns	b958b72f1d	Deploy 11.0.2	2016-04-26 21:28:18 +02:00