Add RGA#destroy() method and use it to fix a bug where a server res…

…tart would cause multiple RGAs to be tied to a single editor, within a single browser window, leading to a kaleidoscope of possible bugs.

lib/rga.js

@@ -18,6 +18,7 @@ function RGA(id, history, queue) {
   this._nextTimestamp = id;
   this._subscribers = [];
   this._queue = queue || RGA._browserQueue;
+  this._onDestroy = [];
 
   var self = this;
   this.downstream = function (sender, op) {
@@ -143,6 +144,19 @@ RGA.prototype = {
     return s;
   },
 
+  // Disconnect this RGA from anything it was connected to.
+  destroy: function () {
+    this._subscribers = undefined;
+    for (var i = 0; i < this._onDestroy.length; i++)
+      this._onDestroy[i]();
+    this._onDestroy = undefined;
+  },
+
+  // Returns true if this.destroy() has been called.
+  wasDestroyed: function () {
+    return this._subscribers === undefined;
+  },
+
   // Add an event listener. An RGA only emits one kind of event: "op".
   on: function (type, callback) {
     if (type === "op")
@@ -174,24 +188,52 @@ RGA.tie = function tie(a, b) {
 
   a.on("op", b.downstream);
   b.on("op", a.downstream);
+
+  // If either RGA is destroyed, untie it from the other.
+  function untie() {
+    if (a !== undefined) {
+      a.off("op", b.downstream);
+      b.off("op", a.downstream);
+      a = b = undefined;
+    }
+  }
+  b._onDestroy.push(untie);
+  a._onDestroy.push(untie);
 };
 
 // Cause an RGA object to communicate via socket.io to update an RGA object
 // tied to the other end of the socket. The two RGA objects must initially
 // contain the same history.
 RGA.tieToSocket = function tieToSocket(a, s) {
   var a_s = function (sender, op) {
-    s.emit("downstream", op);
+    if (s !== undefined) {
+      //a._log("forwarding from RGA " + a.id + " to socket: ", op);
+      s.emit("downstream", op);
+    }
   };
   a.on("op", a_s);
-  s.on("downstream", function (op) {
-    a.downstream(a_s, op);
-  });
 
-  // Cleanup.
-  s.on("disconnect", function () {
-    a.off("op", a_s);
-  });
+  var s_a = function (op) {
+    if (a !== undefined) {
+      //a._log("forwarding from socket to RGA " + a.id + ": ", op);
+      a.downstream(a_s, op);
+    }
+  };
+  s.on("downstream", s_a);
+
+  // If the RGA is destroyed or the socket gets disconnected, untie them from
+  // one another.  Amazingly, socket.io offers no way to unsubscribe callbacks.
+  // To ensure no further events are delievered and no unused GC-edges remain,
+  // we null out the variables, and the callbacks above check for this state.
+  function untie() {
+    if (a !== undefined) {
+      //a._log("untying RGA " + a.id + " from socket");
+      a.off("op", a_s);
+      a = s = a_s = s_a = untie = undefined;
+    }
+  }
+  a._onDestroy.push(untie);
+  s.on("disconnect", untie);
 };
 
 // Return a delta to turn the string s0 into s1.
@@ -302,6 +344,9 @@ RGA.AceEditorRGA = function AceEditorRGA(id, editor, history, queue) {
   var self = this;
   this._changeCallback = function () { self._takeUserEdits() };
   editor.getSession().on("change", this._changeCallback);
+  this._onDestroy.push(function () {
+    self.editor.getSession().off("change", self._changeCallback);
+  });
 
   // Now for the other direction. Replace the callback that receives changes
   // from other RGAs with a new one that also updates the editor.
@@ -517,6 +562,14 @@ Object.assign(RGA.AceEditorRGA.prototype, {
 RGA.AceEditorRGA.setup = function (editor, socket) {
   var local = undefined;
   socket.on("welcome", function (event) {
+    if (local !== undefined) {
+      // If the server is restarted, we'll receive a second welcome event.
+      // Don't try to keep the old RGA in sync with the new server instance,
+      // and *definitely* don't try to tie two RGAs to the same editor!
+      local.destroy();
+      local = undefined;
+    }
+
     local = new RGA.AceEditorRGA(event.id, editor, event.history);
     RGA.tieToSocket(local, socket);
     editor.focus();