stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/transition/transition-test-each.js

@@ -0,0 +1,163 @@
+var assert = require("../assert");
+
+module.exports = {
+  "start": {
+    topic: function(d3) {
+      var cb = this.callback,
+          div = d3.select("body").html("").selectAll().data(["foo", "bar"]).enter().append("div").attr("class", String),
+          transition = div.transition().delay(350),
+          then = Date.now(),
+          n = 0,
+          calls = [],
+          context = [],
+          data = [],
+          index = [],
+          count = [],
+          delay = [];
+
+      // A callback to verify that multiple callbacks are allowed.
+      transition.each("start.other", function() {
+        ++n;
+      });
+
+      // A callback which captures arguments and context.
+      transition.each("start", function(d, i) {
+        context.push(this);
+        data.push(d);
+        index.push(i);
+        count.push(++n);
+        delay.push(Date.now() - then);
+        if (n >= 4) cb(null, {
+          selection: div,
+          delay: delay,
+          context: context,
+          data: data,
+          index: index,
+          count: count,
+          id: transition.id
+        });
+      });
+    },
+
+    "invokes the listener after the specified delay": function(result) {
+      assert.inDelta(result.delay, [350, 350], 20);
+    },
+    "invokes each listener exactly once, in order": function(result) {
+      assert.deepEqual(result.count, [2, 4]);
+    },
+
+    // For the same node, listeners will be called back in order, according to
+    // the implementation of d3.dispatch. However, the order of callbacks across
+    // nodes is not guaranteed; currently, callbacks are in reverse order if
+    // they share the same delay, because of the timer queue. I suppose it'd be
+    // slightly better if the callbacks were invoked in node order (consistent
+    // with selections), but since these callbacks happen asynchronously I don't
+    // think the API needs to guarantee the order of callbacks.
+
+    "uses the node as the context": function(result) {
+      assert.domEqual(result.context[0], result.selection[0][0]);
+      assert.domEqual(result.context[1], result.selection[0][1]);
+    },
+    "passes the data and index to the function": function(result) {
+      assert.deepEqual(result.data, ["foo", "bar"], "expected data, got {actual}");
+      assert.deepEqual(result.index, [0, 1], "expected index, got {actual}");
+    },
+
+    "sets an exclusive lock on transitioning nodes": function(result) {
+      var id = result.id;
+      assert.isTrue(id > 0);
+      assert.equal(result.selection[0][0].__transition__.count, 1);
+      assert.equal(result.selection[0][1].__transition__.count, 1);
+      assert.equal(result.selection[0][0].__transition__.active, id);
+      assert.equal(result.selection[0][1].__transition__.active, id);
+    }
+  },
+
+  "end": {
+    topic: function(d3) {
+      var cb = this.callback,
+          div = d3.select("body").html("").selectAll().data(["foo", "bar"]).enter().append("div").attr("class", String),
+          transition = div.transition().duration(350),
+          then = Date.now(),
+          n = 0,
+          calls = [],
+          context = [],
+          data = [],
+          index = [],
+          count = [],
+          delay = [];
+
+      // A callback to verify that multiple callbacks are allowed.
+      transition.each("end.other", function() {
+        ++n;
+      });
+
+      // A callback which captures arguments and context.
+      transition.each("end", function(d, i) {
+        context.push(this);
+        data.push(d);
+        index.push(i);
+        count.push(++n);
+        delay.push(Date.now() - then);
+        if (n >= 4) cb(null, {
+          selection: div,
+          delay: delay,
+          context: context,
+          data: data,
+          index: index,
+          count: count,
+          id: transition.id
+        });
+      });
+    },
+
+    "invokes the listener after the specified delay": function(result) {
+      assert.inDelta(result.delay, [350, 350], 20);
+    },
+    "invokes each listener exactly once, in order": function(result) {
+      assert.deepEqual(result.count, [2, 4]);
+    },
+
+    // For the same node, listeners will be called back in order, according to
+    // the implementation of d3.dispatch. However, the order of callbacks across
+    // nodes is not guaranteed; currently, callbacks are in reverse order if
+    // they share the same delay, because of the timer queue. I suppose it'd be
+    // slightly better if the callbacks were invoked in node order (consistent
+    // with selections), but since these callbacks happen asynchronously I don't
+    // think the API needs to guarantee the order of callbacks.
+
+    "uses the node as the context": function(result) {
+      assert.domEqual(result.context[0], result.selection[0][0]);
+      assert.domEqual(result.context[1], result.selection[0][1]);
+    },
+    "passes the data and index to the function": function(result) {
+      assert.deepEqual(result.data, ["foo", "bar"], "expected data, got {actual}");
+      assert.deepEqual(result.index, [0, 1], "expected index, got {actual}");
+    },
+
+    "deletes the transition lock after end": function(result) {
+      assert.isFalse("__transition__" in result.selection[0][0]);
+      assert.isFalse("__transition__" in result.selection[0][1]);
+    },
+
+    // I'd like to test d3.timer.flush here, but unfortunately there's a bug in
+    // Vows where it really doesn't like to receive multiple callbacks from
+    // different tests at the same time!
+
+    "sequenced": {
+      topic: function(result, d3) {
+        var cb = this.callback,
+            node = result.selection[0][0],
+            id = result.id;
+        d3.select(node).transition().delay(150).each("start", function() {
+          cb(null, {id: id, node: this});
+        });
+      },
+      "does not inherit the transition id": function(result) {
+        assert.isTrue(result.id > 0);
+        assert.equal(result.node.__transition__.count, 1);
+        assert.isTrue(result.node.__transition__.active > result.id);
+      }
+    }
+  }
+};

data/lib/stripchart/public/components/d3/test/transition/transition-test-filter.js

@@ -0,0 +1,84 @@
+var assert = require("../assert"),
+    _ = require("../../");
+
+var datum = {};
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").html("").selectAll("div")
+        .data([0, 1])
+      .enter().append("div")
+      .selectAll("span")
+        .data(function(d) { d <<= 1; return [d, d + 1]; })
+      .enter().append("span")
+        .classed("foo", function(d, i) { return d & 1; })
+      .transition()
+        .delay(100)
+        .duration(150)
+        .ease("bounce");
+  },
+
+  "preserves matching elements": function(span) {
+    var some = span.filter(function(d, i) { return i === 0; });
+    assert.isTrue(some[0][0] === span[0][0]);
+    assert.isTrue(some[1][0] === span[1][0]);
+  },
+  "removes non-matching elements": function(span) {
+    var some = _.merge(span.filter(function(d, i) { return d & 1; }));
+    assert.equal(some.indexOf(span[0][0]), -1);
+    assert.equal(some.indexOf(span[1][0]), -1);
+  },
+  "preserves data": function(span) {
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.equal(some[0][0].__data__, 1);
+    assert.equal(some[1][0].__data__, 3);
+  },
+  "preserves grouping": function(span) {
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.equal(some.length, 2);
+    assert.equal(some[0].length, 1);
+    assert.equal(some[1].length, 1);
+  },
+  "preserves parent node": function(span) {
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.isTrue(some[0].parentNode === span[0].parentNode);
+    assert.isTrue(some[1].parentNode === span[1].parentNode);
+  },
+  "does not preserve index": function(span) {
+    var indexes = [];
+    span.filter(function(d, i) { return d & 1; }).each(function(d, i) { indexes.push(i); });
+    assert.deepEqual(indexes, [0, 0]);
+  },
+  "ignores null nodes": function(span) {
+    var node = span[0][1];
+    span[0][1] = null;
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.isTrue(some[0][0] === span[0][3]);
+    assert.equal(some.length, 2);
+    span[0][1] = node;
+  },
+  "can be specified as a selector": function(span) {
+    var some = span.filter(".foo");
+    assert.equal(some.length, 2);
+    assert.equal(some[0].length, 1);
+    assert.equal(some[1].length, 1);
+  },
+  "returns a new selection": function(span) {
+    assert.isFalse(span.filter(function() { return 1; }) === span);
+  },
+  "inherits the delay": function(t1) {
+    var t2 = t1.filter(function() { return 1; });
+    assert.equal(t2[0][0].__transition__[t2.id].delay, 100); // TODO should inherit the whole transition object
+  },
+  "inherits the duration": function(t1) {
+    var t2 = t1.filter(function() { return 1; });
+    assert.equal(t2[0][0].__transition__[t2.id].duration, 150);
+  },
+  "inherits easing": function(t1) {
+    // TODO how to test this?
+  },
+  "inherits the transition id": function(t1) {
+    var t2 = t1.filter(function() { return 1; });
+    assert.equal(t2.id, t1.id);
+  }
+};

data/lib/stripchart/public/components/d3/test/transition/transition-test-id.js

@@ -0,0 +1,22 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3; // bug in vows where topic is not propagated automatically
+  },
+  "on a new transition": {
+    topic: function(d3) {
+      return d3.select("body").append("div").transition();
+    },
+    "has a positive integer id": function(transition) {
+      var id = transition.id;
+      assert.isTrue(id > 0);
+      assert.equal(~~id, id);
+    }
+  },
+  "increases monotonically across transitions": function(d3) {
+    var t0 = d3.select("body").append("div").transition(),
+        t1 = d3.select("body").append("div").transition();
+    assert.isTrue(t1.id > t0.id);
+  }
+};

data/lib/stripchart/public/components/d3/test/transition/transition-test-node.js

@@ -0,0 +1,39 @@
+var assert = require("../assert");
+
+module.exports = {
+  "with a single element selected": {
+    topic: function(d3) {
+      return d3.select("body").transition();
+    },
+    "returns null for empty subselections": function(body) {
+      assert.isNull(body.select("foo").node());
+    },
+    "returns the selected element": function(body) {
+      assert.equal(body.node().tagName, "BODY");
+    },
+    "returns null if no elements are slected": function(body) {
+      body[0][0] = null;
+      assert.isNull(body.node());
+    }
+  },
+  "with multiple elements selected": {
+    topic: function(d3) {
+      var body = d3.select("body").html(null);
+      body.append("div").attr("class", "first").append("span");
+      body.append("div").attr("class", "second");
+      return body.selectAll("div").transition();
+    },
+    "returns null for empty subselections": function(div) {
+      assert.isNull(div.select("foo").node());
+    },
+    "returns the first selected element": function(div) {
+      assert.equal(div.node().className, "first");
+      assert.equal(div.node().tagName, "DIV");
+    },
+    "does not count null nodes": function(div) {
+      div[0][0] = null;
+      assert.equal(div.node().className, "second");
+      assert.equal(div.node().tagName, "DIV");
+    }
+  }
+};

data/lib/stripchart/public/components/d3/test/transition/transition-test-remove.js

@@ -0,0 +1,45 @@
+var assert = require("../assert");
+
+module.exports = {
+  "on a new transition": {
+    topic: function(d3) {
+      var cb = this.callback,
+          t = d3.select("body").append("div").transition().remove();
+      t.each("end", function() { cb(null, t); });
+    },
+    "removes the selected elements": function(transition) {
+      assert.domEqual(transition[0][0].parentNode, null);
+    }
+  },
+
+  "when the element is already removed": {
+    topic: function(d3) {
+      var cb = this.callback,
+          t = d3.select("body").append("div").remove().transition().remove();
+      t.each("end", function() { cb(null, t); });
+    },
+    "does nothing": function(transition) {
+      assert.domEqual(transition[0][0].parentNode, null);
+    }
+  },
+
+  // Since these tests are triggered inside the end event of the above topic,
+  // transitions will inherit ids from the original transition. But we want to
+  // test concurrent transitions, so we use timeouts to avoid inheritance. This
+  // test also verifies that if multiple transitions are created at the same
+  // time, the last transition becomes the owner.
+
+  "when another transition is scheduled": {
+    topic: function(d3) {
+      var cb = this.callback,
+          s = d3.select("body").append("div");
+      setTimeout(function() {
+        s.transition().duration(150).remove().each("end", function() { cb(null, s); });
+        s.transition().delay(250);
+      }, 10);
+    },
+    "does nothing": function(selection) {
+      assert.equal(selection[0][0].parentNode.tagName, "BODY");
+    }
+  }
+};

data/lib/stripchart/public/components/d3/test/transition/transition-test-select.js

@@ -0,0 +1,60 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    var s = d3.select("body").append("div").selectAll("div")
+        .data(["one", "two", "three", "four"])
+      .enter().append("div")
+        .attr("class", String);
+
+    s.filter(function(d, i) { return i > 0; }).append("span");
+    s[0][3] = null;
+
+    return s.transition()
+        .delay(function(d, i) { return i * 13; })
+        .duration(function(d, i) { return i * 21; });
+  },
+
+  "selects the first matching element": function(transition) {
+    var t = transition.select("span");
+    assert.domEqual(t[0][1].parentNode, transition[0][1]);
+    assert.domEqual(t[0][2].parentNode, transition[0][2]);
+  },
+  "ignores null elements": function(transition) {
+    var t = transition.select("span");
+    assert.isNull(t[0][3]);
+  },
+  "propagates data to the selected elements": function(transition) {
+    var t = transition.select("span");
+    assert.equal(t[0][1].__data__, "two");
+    assert.equal(t[0][2].__data__, "three");
+  },
+  "propagates delay to the selected elements": function(transition) {
+    var t = transition.select("span");
+    assert.equal(t[0][1].__transition__[t.id].delay, 13);
+    assert.equal(t[0][2].__transition__[t.id].delay, 26);
+  },
+  "propagates duration to the selected elements": function(transition) {
+    var t = transition.select("span");
+    assert.equal(t[0][1].__transition__[t.id].duration, 21);
+    assert.equal(t[0][2].__transition__[t.id].duration, 42);
+  },
+  "does not propagate data if no data was specified": function(transition) {
+    delete transition[0][1].__data__;
+    delete transition[0][1].firstChild.__data__;
+    var t = transition.select("span");
+    assert.isUndefined(t[0][1].__data__);
+    assert.equal(t[0][2].__data__, "three");
+  },
+  "returns null if no match is found": function(transition) {
+    var t = transition.select("span");
+    assert.isNull(t[0][0]);
+  },
+  "inherits transition id": function(transition) {
+    var id = transition.id,
+        t0 = transition.select("span"),
+        t1 = transition.select("span");
+    assert.equal(t0.id, id);
+    assert.equal(t1.id, id);
+  }
+};

data/lib/stripchart/public/components/d3/test/transition/transition-test-selectAll.js

@@ -0,0 +1,56 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    var s = d3.select("body").append("div").selectAll("div")
+        .data(["one", "two", "three", "four"])
+      .enter().append("div")
+        .attr("class", String);
+
+    s.filter(function(d, i) { return i > 0; }).append("span");
+    s.filter(function(d, i) { return i > 1; }).append("span");
+    s[0][3] = null;
+
+    return s.transition()
+        .delay(function(d, i) { return i * 13; })
+        .duration(function(d, i) { return i * 21; });
+  },
+
+  "selects all matching elements": function(transition) {
+    var t = transition.selectAll("span");
+    assert.domEqual(t[1][0].parentNode, transition[0][1]);
+    assert.domEqual(t[2][0].parentNode, transition[0][2]);
+    assert.domEqual(t[2][1].parentNode, transition[0][2]);
+  },
+  "ignores null elements": function(transition) {
+    var t = transition.selectAll("span");
+    assert.equal(t.length, 3);
+  },
+  "propagates delay to the selected elements": function(transition) {
+    var t = transition.selectAll("span");
+    assert.domEqual(t[1][0].__transition__[t.id].delay, 13);
+    assert.domEqual(t[2][0].__transition__[t.id].delay, 26);
+    assert.domEqual(t[2][1].__transition__[t.id].delay, 26);
+  },
+  "propagates duration to the selected elements": function(transition) {
+    var t = transition.selectAll("span");
+    assert.domEqual(t[1][0].__transition__[t.id].duration, 21);
+    assert.domEqual(t[2][0].__transition__[t.id].duration, 42);
+    assert.domEqual(t[2][1].__transition__[t.id].duration, 42);
+  },
+  "returns empty if no match is found": function(transition) {
+    var t = transition.selectAll("span");
+    assert.isEmpty(t[0]);
+  },
+  "inherits transition id": function(transition) {
+    var id = transition.id,
+        t0 = transition.selectAll("span"),
+        t1 = transition.selectAll("span");
+    assert.equal(t0.id, id);
+    assert.equal(t1.id, id);
+  },
+  "groups are arrays, not instances of NodeList": function(transition) {
+    var t = transition.selectAll(function() { return this.getElementsByClassName("span"); });
+    assert.isTrue(Array.isArray(t[0]));
+  }
+};