action_cable_notifications 0.1.14 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f1c452c20e07a93aa050d60b61d6a5c2fdba4a1
-  data.tar.gz: da28fc564086ef82612b56f209bd365df1d80127
+  metadata.gz: 3d3881c154e82ff694803dae629b00ef8110d979
+  data.tar.gz: be3fcb83d77cc590afbbc82982ef4eed706b304e
 SHA512:
-  metadata.gz: a769b28967a738637247207f4113cbebe510a2526a44099daed32be698e2207ce93b7b566b46f9344dab5092a62207bbb4f17f54246b9dc7e01b416388489cff
-  data.tar.gz: 50f9b8030b96f4aeaf82a7a5f8b030c627c577525128e9b8e6697425b883adab7585591c3879cce64a5498a2d99bbf1c14483f6254274a69fa604159922be118
+  metadata.gz: 3f7ce84fcef2aea235649357959f5ffaeae93af487922a2e06fadf371419e996a454b3c4f7929f3f53e298ab2ef289828c5a0e3921bfd600a10b4101e0b2e63f
+  data.tar.gz: db6d782b49af060688c3bb53a8702ec421c6393f7ce50319da561405d5cb41ceeae6e67e2ae8615d3230db63d3b059c6a14f2e0501cd1114860ab81f6d9cf6ec

data/app/assets/javascripts/action_cable_notifications/application.js

@@ -11,4 +11,5 @@
 // about supported directives.
 //
 //= require lodash
+//= require ./tracker
 //= require ./cable_notifications

data/app/assets/javascripts/action_cable_notifications/cable_notifications.coffee

@@ -7,7 +7,7 @@
   stores: []
 
   # Register a new store
-  registerStore: (store, callbacks) ->
-    new_store = new CableNotifications.Store(store, callbacks)
+  registerStore: (store, options, callbacks) ->
+    new_store = new CableNotifications.Store(store, options, callbacks)
     @stores.push new_store
     new_store

data/app/assets/javascripts/action_cable_notifications/collection.coffee

@@ -1,40 +1,109 @@
 class CableNotifications.Collection
-  constructor: (@store, @name) ->
-    @data = []
-    @channelInfo = null
-
   # Private methods
   #######################################
+  upstream = (command, params={}) ->
+    if @sync
+      cmd =
+        collection: @tableName
+        command: command
+        params: params
+
+      # If channel is connected, send command to the server
+      if @channel.isConnected()
+        @channel?.perform?('action', cmd)
+      # Otherwise, enqueue commands to send when connection resumes
+      else
+        @commandsCache.push {command: command, params: params, performed: false}
+        false
+    else
+      false
+
+  connectionChanged = () ->
+    if @channel.isConnected()
+      _.each(@commandsCache, (cmd) ->
+        if upstream(cmd.command, cmd.params)
+          cmd.performed = true
+      )
+
+      # Cleanup performed commands
+      _.remove(@commandsCache, {performed: true})
+
+  # Public methods
+  #######################################
+
+  constructor: (@store, @name, @tableName) ->
+    # Data storage array
+    @data = []
+    # Channel used to sync with upstream collection
+    @channel = null
+    # Tells changes should be synced with upstream collection
+    @sync = false
+    # Stores upstream commands when there is no connection to the server
+    @commandsCache = []
 
+    # Bind private methods to class instance
+    ########################################################
+    upstream = upstream.bind(this)
+    connectionChanged = connectionChanged.bind(this)
+
+  # Sync collection to ActionCable Channel
+  syncToChannel: (@channel) ->
+    @sync = true
+
+    Tracker.autorun () =>
+      @channel.isConnected()
+      connectionChanged()
+
+  # Fetch records from upstream
+  fetch: (params) ->
+    upstream("fetch", params)
+
+  # Filter records from the current collection
+  where: (selector={}) ->
+    _.filter(@data, selector)
+
+  # Find a record
   find: (selector={}) ->
     _.find(@data, selector)
 
-  findIndex: (selector={}) ->
-    _.findIndex(@data, selector)
+  # Creates a new record
+  create: (fields={}) ->
+    record = _.find(@data, {id: fields.id})
+    if( record )
+      console.warn("[create] Not expected to find an existing record with id #{fields.id}")
+      return
 
-  insert: (record) ->
-    @data.push (record)
+    @data.push (fields) unless @sync
 
-  remove: (selector={}) ->
-    index = @findIndex(selector)
-    if index < 0
-      console.warn("Couldn't find a matching record: #{selector}")
-    else
-      record = @data.splice(index, 1)
+    upstream("create",
+      fields: fields
+    )
+    fields
 
-  update: (selector={}, fields, options) ->
-    record = @find(selector)
+  # Update an existing record
+  update: (selector={}, fields={}, options={}) ->
+    record = _.find(@data, selector)
     if !record
       if options.upsert
-        @insert(fields)
+        @create(fields)
       else
-        console.warn("Couldn't find a matching record: #{selector}")
+        console.warn("[update] Couldn't find a matching record:", selector)
     else
       _.extend(record, fields)
+      upstream("update", {id: record.id, fields: fields})
+      record
 
-  # http://docs.meteor.com/#/full/upsert
+  # Update an existing record or inserts a new one if there is no match
   upsert: (selector={}, fields) ->
     @update(selector, fields, {upsert: true})
 
-  filter: (selector={}) ->
-    _.filter(@data, selector)
+  # Destroy an existing record
+  destroy: (selector={}) ->
+    index = _.findIndex(@data, selector)
+    if index < 0
+      console.warn("[destroy] Couldn't find a matching record:", selector)
+    else
+      record = @data[index]
+      @data.splice(index, 1) unless @sync
+      upstream("destroy", {id: record.id})
+      record

data/app/assets/javascripts/action_cable_notifications/default_callbacks.coffee

@@ -2,25 +2,6 @@
 class CableNotifications.Store.DefaultCallbacks
   constructor: (@collections) ->
 
-  # Helper function
-  processPacketHelper = (packet, collection) ->
-    index = -1
-    record = null
-
-    local_collection = @collections[collection || packet.collection].data
-    if !local_collection
-      console.warn("[update_many]: Collection #{collection_name} doesn't exist")
-    else
-      index = _.find(local_collection, (record) -> record.id == packet.id)
-      if (index >= 0)
-        record = local_collection[index]
-
-    return {
-      collection: local_collection
-      index: index
-      record: record
-    }
-
   # Callbacks
   ##################################################
 
@@ -28,35 +9,21 @@ class CableNotifications.Store.DefaultCallbacks
     console.warn 'Method not implemented: collection_remove '
 
   create: (packet, collection) ->
-    data = processPacketHelper(packet, collection)
-    if data.record
-      console.warn 'Expected not to find a document already present for an add: ' + data.record
-    else
-      data.collection.push(packet.data)
+    collection.create(packet.data)
 
   update: (packet, collection) ->
-    data = processPacketHelper(packet, collection)
-    if !data.record
-      console.warn 'Expected to find a document to change'
-    else if !_.isEmpty(packet.data)
-      _.extend(data.record, packet.data)
+    collection.update({id: packet.id}, packet.data)
 
   update_many: (packet, collection) ->
-    collection_name = collection || packet.collection
-    local_collection = @collections[collection_name].data
-    if !local_collection
-      console.warn("[update_many]: Collection #{collection_name} doesn't exist")
-    else
-      _.each packet.data, (fields) ->
-        record = _.findIndex(local_collection, (r) -> r.id == fields.id)
-        if record>=0
-          _.extend(local_collection[record], fields)
-        else
-          local_collection.push(fields)
+    _.each packet.data, (fields) ->
+      collection.update({id: fields.id}, fields)
+
+  upsert_many: (packet, collection) ->
+    _.each packet.data, (fields) ->
+      collection.upsert({id: fields.id}, fields)
 
   destroy: (packet, collection) ->
-    data = processPacketHelper(packet, collection)
-    if !data.record
-      console.warn 'Expected to find a document to remove'
-    else
-      data.collection.splice(data.index, 1)
+    collection.destroy({id: packet.id})
+
+  error: (packet, collection) ->
+    console.error "[#{packet.cmd}]: #{packet.error}"

data/app/assets/javascripts/action_cable_notifications/store.coffee

@@ -2,53 +2,125 @@
 #= require './default_callbacks'
 
 class CableNotifications.Store
-  constructor: (@name, @callbacks) ->
+  constructor: (@name, @options={}, @callbacks) ->
     @collections = {}
     @channels = {}
 
     if !@callbacks
       @callbacks = new CableNotifications.Store.DefaultCallbacks(@collections)
 
-    this
-
   # Private methods
   #######################################
 
-  packetReceived = (channelInfo, collection) ->
+  # Check received packet and dispatch to the apropriate callback.
+  # Then call original callback
+  packetReceived = (channelInfo) ->
     (packet) ->
-      @storePacket(packet, collection)
-      channelInfo.callbacks.received?.apply channelInfo.channel, arguments
+      if packet?.collection
+        # Search if there is a collection in this Store that receives packets from the server
+        collection = _.find(channelInfo.collections,
+          {tableName: packet.collection})
+        if collection
+          dispatchPacket.call(this, packet, collection)
+      channelInfo.callbacks.received?.apply(channelInfo.channel, arguments)
+
+  # Dispatch received packet to registered stores
+  # collection overrides the collection name specified in the incoming packet
+  dispatchPacket = (packet, collection) ->
+    if packet && packet.msg
+      # Disables sync with upstream to prevent infinite message loop
+      sync = collection.sync
+      collection.sync = false
+      @callbacks[packet.msg]?(packet, collection)
+      collection.sync = sync
+
+  # Called when connected to a channel
+  channelConnected = (channelInfo) ->
+    () ->
+      channelInfo.connectedDep.changed()
+      channelInfo.callbacks.connected?.apply(channelInfo.channel, arguments)
+
+  # Called when disconnected from a channel
+  channelDisconnected = (channelInfo) ->
+    () ->
+      channelInfo.connectedDep.changed()
+      channelInfo.callbacks.disconnected?.apply(channelInfo.channel, arguments)
+
+  # Returns channel connection status
+  channelIsConnected = (channelInfo) ->
+    () ->
+      channelInfo.connectedDep.depend()
+      !channelInfo.channel.consumer.connection.disconnected
 
   # Public methods
   #######################################
 
   # Register a new collection
-  registerCollection: (collection) ->
-    if @collections[collection]
-      console.warn '[registerCollection]: Collection already exists'
+  registerCollection: (name, channel, tableName) ->
+    tableName = name unless tableName
+    if @collections[name]
+      console.warn "[registerCollection]: Collection '#{name}' already exists"
     else
-      @collections[collection] = new CableNotifications.Collection(this, collection)
-    @collections[collection]
+      @collections[name] = new CableNotifications.Collection(this, name, tableName)
+      if channel
+        @syncToChannel(channel, @collections[name])
+
+    @collections[name]
 
   # Sync store using ActionCable received events
   # collection parameter overrides the collection name specified in the incoming packets for this channel
   syncToChannel: (channel, collection) ->
+    if !channel
+      console.warn "[syncToChannel]: Channel must be specified"
+      return false
+
+    if !collection
+      console.warn "[syncToChannel]: Collection must be specified"
+      return false
+
     channelId = JSON.parse(channel.identifier)?.channel
 
     if !channelId
       console.warn "[syncToChannel]: Channel specified doesn't have an identifier"
+      return false
+
+    if @collections[collection.name] < 0
+      console.warn "[syncToChannel]: Collection does not exists in the store"
+      return false
+
+    if @channels[channelId]
+      channelInfo = @channels[channelId]
+      if _.find(channelInfo.collections, {name: collection.name})
+        console.warn "[syncToChannel]: Collection '#{collection.name}' is already being synced with channel '#{channelId}'"
+        return false
+      else
+        collection.syncToChannel(channel)
+        channelInfo.collections.push collection
+
+        # Fetch data from uptream server
+        collection.fetch()
     else
+      # Initialize channelInfo
       @channels[channelId] =
+        id: channelId
         channel: channel
+        collections: [collection]
         callbacks: {
           received: channel.received
+          connected: channel.connected
+          disconnected: channel.disconnected
         }
+        connectedDep: new Tracker.Dependency
 
-      channel.received = packetReceived(@channels[channelId], collection).bind(this)
-    channel
+      channel.received = packetReceived(@channels[channelId]).bind(this)
+      channel.connected = channelConnected(@channels[channelId]).bind(this)
+      channel.disconnected = channelDisconnected(@channels[channelId]).bind(this)
+      channel.isConnected = channelIsConnected(@channels[channelId]).bind(this)
 
-  # Dispatch received packet to registered stores
-  # collection overrides the collection name specified in the incoming packet
-  storePacket: (packet, collection) ->
-    if packet && packet.msg
-      @callbacks[packet.msg]?(packet, collection)
+      # Assigns channel to collection and turns on Sync
+      collection.syncToChannel(channel)
+
+      # Fetch data from upstream server
+      collection.fetch()
+
+    return true

data/app/assets/javascripts/action_cable_notifications/tracker.js

@@ -0,0 +1,633 @@
+/////////////////////////////////////////////////////
+// Package docs at http://docs.meteor.com/#tracker //
+/////////////////////////////////////////////////////
+
+/**
+ * @namespace Tracker
+ * @summary The namespace for Tracker-related methods.
+ */
+Tracker = {};
+
+// http://docs.meteor.com/#tracker_active
+
+/**
+ * @summary True if there is a current computation, meaning that dependencies on reactive data sources will be tracked and potentially cause the current computation to be rerun.
+ * @locus Client
+ * @type {Boolean}
+ */
+Tracker.active = false;
+
+// http://docs.meteor.com/#tracker_currentcomputation
+
+/**
+ * @summary The current computation, or `null` if there isn't one.  The current computation is the [`Tracker.Computation`](#tracker_computation) object created by the innermost active call to `Tracker.autorun`, and it's the computation that gains dependencies when reactive data sources are accessed.
+ * @locus Client
+ * @type {Tracker.Computation}
+ */
+Tracker.currentComputation = null;
+
+var setCurrentComputation = function (c) {
+  Tracker.currentComputation = c;
+  Tracker.active = !! c;
+};
+
+var _debugFunc = function () {
+  // We want this code to work without Meteor, and also without
+  // "console" (which is technically non-standard and may be missing
+  // on some browser we come across, like it was on IE 7).
+  //
+  // Lazy evaluation because `Meteor` does not exist right away.(??)
+  return (typeof Meteor !== "undefined" ? Meteor._debug :
+          ((typeof console !== "undefined") && console.error ?
+           function () { console.error.apply(console, arguments); } :
+           function () {}));
+};
+
+var _maybeSuppressMoreLogs = function (messagesLength) {
+  // Sometimes when running tests, we intentionally suppress logs on expected
+  // printed errors. Since the current implementation of _throwOrLog can log
+  // multiple separate log messages, suppress all of them if at least one suppress
+  // is expected as we still want them to count as one.
+  if (typeof Meteor !== "undefined") {
+    if (Meteor._suppressed_log_expected()) {
+      Meteor._suppress_log(messagesLength - 1);
+    }
+  }
+};
+
+var _throwOrLog = function (from, e) {
+  if (throwFirstError) {
+    throw e;
+  } else {
+    var printArgs = ["Exception from Tracker " + from + " function:"];
+    if (e.stack && e.message && e.name) {
+      var idx = e.stack.indexOf(e.message);
+      if (idx < 0 || idx > e.name.length + 2) { // check for "Error: "
+        // message is not part of the stack
+        var message = e.name + ": " + e.message;
+        printArgs.push(message);
+      }
+    }
+    printArgs.push(e.stack);
+    _maybeSuppressMoreLogs(printArgs.length);
+
+    for (var i = 0; i < printArgs.length; i++) {
+      _debugFunc()(printArgs[i]);
+    }
+  }
+};
+
+// Takes a function `f`, and wraps it in a `Meteor._noYieldsAllowed`
+// block if we are running on the server. On the client, returns the
+// original function (since `Meteor._noYieldsAllowed` is a
+// no-op). This has the benefit of not adding an unnecessary stack
+// frame on the client.
+var withNoYieldsAllowed = function (f) {
+  if ((typeof Meteor === 'undefined') || Meteor.isClient) {
+    return f;
+  } else {
+    return function () {
+      var args = arguments;
+      Meteor._noYieldsAllowed(function () {
+        f.apply(null, args);
+      });
+    };
+  }
+};
+
+var nextId = 1;
+// computations whose callbacks we should call at flush time
+var pendingComputations = [];
+// `true` if a Tracker.flush is scheduled, or if we are in Tracker.flush now
+var willFlush = false;
+// `true` if we are in Tracker.flush now
+var inFlush = false;
+// `true` if we are computing a computation now, either first time
+// or recompute.  This matches Tracker.active unless we are inside
+// Tracker.nonreactive, which nullfies currentComputation even though
+// an enclosing computation may still be running.
+var inCompute = false;
+// `true` if the `_throwFirstError` option was passed in to the call
+// to Tracker.flush that we are in. When set, throw rather than log the
+// first error encountered while flushing. Before throwing the error,
+// finish flushing (from a finally block), logging any subsequent
+// errors.
+var throwFirstError = false;
+
+var afterFlushCallbacks = [];
+
+var requireFlush = function () {
+  if (! willFlush) {
+    // We want this code to work without Meteor, see debugFunc above
+    if (typeof Meteor !== "undefined")
+      Meteor._setImmediate(Tracker._runFlush);
+    else
+      setTimeout(Tracker._runFlush, 0);
+    willFlush = true;
+  }
+};
+
+// Tracker.Computation constructor is visible but private
+// (throws an error if you try to call it)
+var constructingComputation = false;
+
+//
+// http://docs.meteor.com/#tracker_computation
+
+/**
+ * @summary A Computation object represents code that is repeatedly rerun
+ * in response to
+ * reactive data changes. Computations don't have return values; they just
+ * perform actions, such as rerendering a template on the screen. Computations
+ * are created using Tracker.autorun. Use stop to prevent further rerunning of a
+ * computation.
+ * @instancename computation
+ */
+Tracker.Computation = function (f, parent, onError) {
+  if (! constructingComputation)
+    throw new Error(
+      "Tracker.Computation constructor is private; use Tracker.autorun");
+  constructingComputation = false;
+
+  var self = this;
+
+  // http://docs.meteor.com/#computation_stopped
+
+  /**
+   * @summary True if this computation has been stopped.
+   * @locus Client
+   * @memberOf Tracker.Computation
+   * @instance
+   * @name  stopped
+   */
+  self.stopped = false;
+
+  // http://docs.meteor.com/#computation_invalidated
+
+  /**
+   * @summary True if this computation has been invalidated (and not yet rerun), or if it has been stopped.
+   * @locus Client
+   * @memberOf Tracker.Computation
+   * @instance
+   * @name  invalidated
+   * @type {Boolean}
+   */
+  self.invalidated = false;
+
+  // http://docs.meteor.com/#computation_firstrun
+
+  /**
+   * @summary True during the initial run of the computation at the time `Tracker.autorun` is called, and false on subsequent reruns and at other times.
+   * @locus Client
+   * @memberOf Tracker.Computation
+   * @instance
+   * @name  firstRun
+   * @type {Boolean}
+   */
+  self.firstRun = true;
+
+  self._id = nextId++;
+  self._onInvalidateCallbacks = [];
+  self._onStopCallbacks = [];
+  // the plan is at some point to use the parent relation
+  // to constrain the order that computations are processed
+  self._parent = parent;
+  self._func = f;
+  self._onError = onError;
+  self._recomputing = false;
+
+  var errored = true;
+  try {
+    self._compute();
+    errored = false;
+  } finally {
+    self.firstRun = false;
+    if (errored)
+      self.stop();
+  }
+};
+
+// http://docs.meteor.com/#computation_oninvalidate
+
+/**
+ * @summary Registers `callback` to run when this computation is next invalidated, or runs it immediately if the computation is already invalidated.  The callback is run exactly once and not upon future invalidations unless `onInvalidate` is called again after the computation becomes valid again.
+ * @locus Client
+ * @param {Function} callback Function to be called on invalidation. Receives one argument, the computation that was invalidated.
+ */
+Tracker.Computation.prototype.onInvalidate = function (f) {
+  var self = this;
+
+  if (typeof f !== 'function')
+    throw new Error("onInvalidate requires a function");
+
+  if (self.invalidated) {
+    Tracker.nonreactive(function () {
+      withNoYieldsAllowed(f)(self);
+    });
+  } else {
+    self._onInvalidateCallbacks.push(f);
+  }
+};
+
+/**
+ * @summary Registers `callback` to run when this computation is stopped, or runs it immediately if the computation is already stopped.  The callback is run after any `onInvalidate` callbacks.
+ * @locus Client
+ * @param {Function} callback Function to be called on stop. Receives one argument, the computation that was stopped.
+ */
+Tracker.Computation.prototype.onStop = function (f) {
+  var self = this;
+
+  if (typeof f !== 'function')
+    throw new Error("onStop requires a function");
+
+  if (self.stopped) {
+    Tracker.nonreactive(function () {
+      withNoYieldsAllowed(f)(self);
+    });
+  } else {
+    self._onStopCallbacks.push(f);
+  }
+};
+
+// http://docs.meteor.com/#computation_invalidate
+
+/**
+ * @summary Invalidates this computation so that it will be rerun.
+ * @locus Client
+ */
+Tracker.Computation.prototype.invalidate = function () {
+  var self = this;
+  if (! self.invalidated) {
+    // if we're currently in _recompute(), don't enqueue
+    // ourselves, since we'll rerun immediately anyway.
+    if (! self._recomputing && ! self.stopped) {
+      requireFlush();
+      pendingComputations.push(this);
+    }
+
+    self.invalidated = true;
+
+    // callbacks can't add callbacks, because
+    // self.invalidated === true.
+    for(var i = 0, f; f = self._onInvalidateCallbacks[i]; i++) {
+      Tracker.nonreactive(function () {
+        withNoYieldsAllowed(f)(self);
+      });
+    }
+    self._onInvalidateCallbacks = [];
+  }
+};
+
+// http://docs.meteor.com/#computation_stop
+
+/**
+ * @summary Prevents this computation from rerunning.
+ * @locus Client
+ */
+Tracker.Computation.prototype.stop = function () {
+  var self = this;
+
+  if (! self.stopped) {
+    self.stopped = true;
+    self.invalidate();
+    for(var i = 0, f; f = self._onStopCallbacks[i]; i++) {
+      Tracker.nonreactive(function () {
+        withNoYieldsAllowed(f)(self);
+      });
+    }
+    self._onStopCallbacks = [];
+  }
+};
+
+Tracker.Computation.prototype._compute = function () {
+  var self = this;
+  self.invalidated = false;
+
+  var previous = Tracker.currentComputation;
+  setCurrentComputation(self);
+  var previousInCompute = inCompute;
+  inCompute = true;
+  try {
+    withNoYieldsAllowed(self._func)(self);
+  } finally {
+    setCurrentComputation(previous);
+    inCompute = previousInCompute;
+  }
+};
+
+Tracker.Computation.prototype._needsRecompute = function () {
+  var self = this;
+  return self.invalidated && ! self.stopped;
+};
+
+Tracker.Computation.prototype._recompute = function () {
+  var self = this;
+
+  self._recomputing = true;
+  try {
+    if (self._needsRecompute()) {
+      try {
+        self._compute();
+      } catch (e) {
+        if (self._onError) {
+          self._onError(e);
+        } else {
+          _throwOrLog("recompute", e);
+        }
+      }
+    }
+  } finally {
+    self._recomputing = false;
+  }
+};
+
+/**
+ * @summary Process the reactive updates for this computation immediately
+ * and ensure that the computation is rerun. The computation is rerun only
+ * if it is invalidated.
+ * @locus Client
+ */
+Tracker.Computation.prototype.flush = function () {
+  var self = this;
+
+  if (self._recomputing)
+    return;
+
+  self._recompute();
+};
+
+/**
+ * @summary Causes the function inside this computation to run and
+ * synchronously process all reactive updtes.
+ * @locus Client
+ */
+Tracker.Computation.prototype.run = function () {
+  var self = this;
+  self.invalidate();
+  self.flush();
+};
+
+//
+// http://docs.meteor.com/#tracker_dependency
+
+/**
+ * @summary A Dependency represents an atomic unit of reactive data that a
+ * computation might depend on. Reactive data sources such as Session or
+ * Minimongo internally create different Dependency objects for different
+ * pieces of data, each of which may be depended on by multiple computations.
+ * When the data changes, the computations are invalidated.
+ * @class
+ * @instanceName dependency
+ */
+Tracker.Dependency = function () {
+  this._dependentsById = {};
+};
+
+// http://docs.meteor.com/#dependency_depend
+//
+// Adds `computation` to this set if it is not already
+// present.  Returns true if `computation` is a new member of the set.
+// If no argument, defaults to currentComputation, or does nothing
+// if there is no currentComputation.
+
+/**
+ * @summary Declares that the current computation (or `fromComputation` if given) depends on `dependency`.  The computation will be invalidated the next time `dependency` changes.
+
+If there is no current computation and `depend()` is called with no arguments, it does nothing and returns false.
+
+Returns true if the computation is a new dependent of `dependency` rather than an existing one.
+ * @locus Client
+ * @param {Tracker.Computation} [fromComputation] An optional computation declared to depend on `dependency` instead of the current computation.
+ * @returns {Boolean}
+ */
+Tracker.Dependency.prototype.depend = function (computation) {
+  if (! computation) {
+    if (! Tracker.active)
+      return false;
+
+    computation = Tracker.currentComputation;
+  }
+  var self = this;
+  var id = computation._id;
+  if (! (id in self._dependentsById)) {
+    self._dependentsById[id] = computation;
+    computation.onInvalidate(function () {
+      delete self._dependentsById[id];
+    });
+    return true;
+  }
+  return false;
+};
+
+// http://docs.meteor.com/#dependency_changed
+
+/**
+ * @summary Invalidate all dependent computations immediately and remove them as dependents.
+ * @locus Client
+ */
+Tracker.Dependency.prototype.changed = function () {
+  var self = this;
+  for (var id in self._dependentsById)
+    self._dependentsById[id].invalidate();
+};
+
+// http://docs.meteor.com/#dependency_hasdependents
+
+/**
+ * @summary True if this Dependency has one or more dependent Computations, which would be invalidated if this Dependency were to change.
+ * @locus Client
+ * @returns {Boolean}
+ */
+Tracker.Dependency.prototype.hasDependents = function () {
+  var self = this;
+  for(var id in self._dependentsById)
+    return true;
+  return false;
+};
+
+// http://docs.meteor.com/#tracker_flush
+
+/**
+ * @summary Process all reactive updates immediately and ensure that all invalidated computations are rerun.
+ * @locus Client
+ */
+Tracker.flush = function (options) {
+  Tracker._runFlush({ finishSynchronously: true,
+                      throwFirstError: options && options._throwFirstError });
+};
+
+// Run all pending computations and afterFlush callbacks.  If we were not called
+// directly via Tracker.flush, this may return before they're all done to allow
+// the event loop to run a little before continuing.
+Tracker._runFlush = function (options) {
+  // XXX What part of the comment below is still true? (We no longer
+  // have Spark)
+  //
+  // Nested flush could plausibly happen if, say, a flush causes
+  // DOM mutation, which causes a "blur" event, which runs an
+  // app event handler that calls Tracker.flush.  At the moment
+  // Spark blocks event handlers during DOM mutation anyway,
+  // because the LiveRange tree isn't valid.  And we don't have
+  // any useful notion of a nested flush.
+  //
+  // https://app.asana.com/0/159908330244/385138233856
+  if (inFlush)
+    throw new Error("Can't call Tracker.flush while flushing");
+
+  if (inCompute)
+    throw new Error("Can't flush inside Tracker.autorun");
+
+  options = options || {};
+
+  inFlush = true;
+  willFlush = true;
+  throwFirstError = !! options.throwFirstError;
+
+  var recomputedCount = 0;
+  var finishedTry = false;
+  try {
+    while (pendingComputations.length ||
+           afterFlushCallbacks.length) {
+
+      // recompute all pending computations
+      while (pendingComputations.length) {
+        var comp = pendingComputations.shift();
+        comp._recompute();
+        if (comp._needsRecompute()) {
+          pendingComputations.unshift(comp);
+        }
+
+        if (! options.finishSynchronously && ++recomputedCount > 1000) {
+          finishedTry = true;
+          return;
+        }
+      }
+
+      if (afterFlushCallbacks.length) {
+        // call one afterFlush callback, which may
+        // invalidate more computations
+        var func = afterFlushCallbacks.shift();
+        try {
+          func();
+        } catch (e) {
+          _throwOrLog("afterFlush", e);
+        }
+      }
+    }
+    finishedTry = true;
+  } finally {
+    if (! finishedTry) {
+      // we're erroring due to throwFirstError being true.
+      inFlush = false; // needed before calling `Tracker.flush()` again
+      // finish flushing
+      Tracker._runFlush({
+        finishSynchronously: options.finishSynchronously,
+        throwFirstError: false
+      });
+    }
+    willFlush = false;
+    inFlush = false;
+    if (pendingComputations.length || afterFlushCallbacks.length) {
+      // We're yielding because we ran a bunch of computations and we aren't
+      // required to finish synchronously, so we'd like to give the event loop a
+      // chance. We should flush again soon.
+      if (options.finishSynchronously) {
+        throw new Error("still have more to do?");  // shouldn't happen
+      }
+      setTimeout(requireFlush, 10);
+    }
+  }
+};
+
+// http://docs.meteor.com/#tracker_autorun
+//
+// Run f(). Record its dependencies. Rerun it whenever the
+// dependencies change.
+//
+// Returns a new Computation, which is also passed to f.
+//
+// Links the computation to the current computation
+// so that it is stopped if the current computation is invalidated.
+
+/**
+ * @callback Tracker.ComputationFunction
+ * @param {Tracker.Computation}
+ */
+/**
+ * @summary Run a function now and rerun it later whenever its dependencies
+ * change. Returns a Computation object that can be used to stop or observe the
+ * rerunning.
+ * @locus Client
+ * @param {Tracker.ComputationFunction} runFunc The function to run. It receives
+ * one argument: the Computation object that will be returned.
+ * @param {Object} [options]
+ * @param {Function} options.onError Optional. The function to run when an error
+ * happens in the Computation. The only argument it recieves is the Error
+ * thrown. Defaults to the error being logged to the console.
+ * @returns {Tracker.Computation}
+ */
+Tracker.autorun = function (f, options) {
+  if (typeof f !== 'function')
+    throw new Error('Tracker.autorun requires a function argument');
+
+  options = options || {};
+
+  constructingComputation = true;
+  var c = new Tracker.Computation(
+    f, Tracker.currentComputation, options.onError);
+
+  if (Tracker.active)
+    Tracker.onInvalidate(function () {
+      c.stop();
+    });
+
+  return c;
+};
+
+// http://docs.meteor.com/#tracker_nonreactive
+//
+// Run `f` with no current computation, returning the return value
+// of `f`.  Used to turn off reactivity for the duration of `f`,
+// so that reactive data sources accessed by `f` will not result in any
+// computations being invalidated.
+
+/**
+ * @summary Run a function without tracking dependencies.
+ * @locus Client
+ * @param {Function} func A function to call immediately.
+ */
+Tracker.nonreactive = function (f) {
+  var previous = Tracker.currentComputation;
+  setCurrentComputation(null);
+  try {
+    return f();
+  } finally {
+    setCurrentComputation(previous);
+  }
+};
+
+// http://docs.meteor.com/#tracker_oninvalidate
+
+/**
+ * @summary Registers a new [`onInvalidate`](#computation_oninvalidate) callback on the current computation (which must exist), to be called immediately when the current computation is invalidated or stopped.
+ * @locus Client
+ * @param {Function} callback A callback function that will be invoked as `func(c)`, where `c` is the computation on which the callback is registered.
+ */
+Tracker.onInvalidate = function (f) {
+  if (! Tracker.active)
+    throw new Error("Tracker.onInvalidate requires a currentComputation");
+
+  Tracker.currentComputation.onInvalidate(f);
+};
+
+// http://docs.meteor.com/#tracker_afterflush
+
+/**
+ * @summary Schedules a function to be called during the next flush, or later in the current flush if one is in progress, after all invalidated computations have been rerun.  The function will be run once and not on subsequent flushes unless `afterFlush` is called again.
+ * @locus Client
+ * @param {Function} callback A function to call at flush time.
+ */
+Tracker.afterFlush = function (f) {
+  afterFlushCallbacks.push(f);
+  requireFlush();
+};