stripchart 0.0.3

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

@@ -0,0 +1,37 @@
+var assert = require("../assert");
+
+module.exports = {
+  "with a single element selected": {
+    topic: function(d3) {
+      return d3.select("body").transition();
+    },
+    "returns zero for empty subselections": function(body) {
+      assert.equal(body.select("foo").size(), 0);
+    },
+    "returns one for a singleton selection": function(body) {
+      assert.equal(body.size(), 1);
+    },
+    "does not count null nodes": function(body) {
+      body[0][0] = null;
+      assert.equal(body.size(), 0);
+    }
+  },
+  "with multiple elements selected": {
+    topic: function(d3) {
+      var body = d3.select("body").html(null);
+      body.append("div").append("span");
+      body.append("div");
+      return body.selectAll("div").transition();
+    },
+    "returns null for empty selections": function(div) {
+      assert.equal(div.select("foo").size(), 0);
+    },
+    "returns the number of non-null nodes": function(div) {
+      assert.equal(div.size(), 2);
+    },
+    "does not count null nodes": function(div) {
+      div[0][0] = null;
+      assert.equal(div.size(), 1);
+    }
+  }
+};

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

@@ -0,0 +1,51 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    var s = d3.select("body").append("div")
+        .style("background-color", "white")
+        .style("color", "red")
+        .style("display", "none")
+        .style("font-size", "20px");
+
+    var t = s.transition()
+        .style("display", null)
+        .style("font-size", function() { return null; })
+        .style("display", null)
+        .style("background-color", "green")
+        .style("background-color", "red")
+        .style("color", function() { return "green"; }, "important");
+
+    return {selection: s, transition: t};
+  },
+  "defines the corresponding style tween": function(result) {
+    assert.typeOf(result.transition.tween("style.background-color"), "function");
+    assert.typeOf(result.transition.tween("style.color"), "function");
+  },
+  "on end": {
+    topic: function(result) {
+      var cb = this.callback;
+      result.transition.each("end", function() { cb(null, result); });
+    },
+    "the last style operator takes precedence": function(result) {
+      assert.equal(result.selection.style("background-color"), "#ff0000");
+    },
+    "sets a property as a string": function(result) {
+      assert.equal(result.selection.style("background-color"), "#ff0000");
+    },
+    "sets a property as a function": function(result) {
+      assert.equal(result.selection.style("color"), "#008000");
+    },
+    "observes the specified priority": function(result) {
+      var style = result.selection.node().style;
+      assert.equal(style.getPropertyPriority("background-color"), "");
+      assert.equal(style.getPropertyPriority("color"), "important");
+    },
+    "removes a property using a constant null": function(result) {
+      assert.equal(result.selection.style("display"), "");
+    },
+    "removes a property using a function null": function(result) {
+      assert.equal(result.selection.style("font-size"), "");
+    }
+  }
+};

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

@@ -0,0 +1,65 @@
+var assert = require("../assert"),
+    _ = require("../../");
+
+module.exports = {
+  topic: function(d3) {
+    var cb = this.callback,
+        dd = [],
+        ii = [],
+        tt = [],
+        vv = [],
+        fails = 0;
+
+    var s = d3.select("body").html("").append("div").selectAll("div")
+        .data(["red", "green"])
+      .enter().append("div")
+        .style("background-color", function(d) { return d3.rgb(d)+""; });
+
+    var t = s.transition()
+        .styleTween("background-color", function() { ++fails; })
+        .styleTween("background-color", tween);
+
+    function tween(d, i, v) {
+      dd.push(d);
+      ii.push(i);
+      vv.push(v);
+      if (tt.push(this) >= 2) cb(null, {
+        selection: s,
+        transition: t,
+        data: dd,
+        index: ii,
+        value: vv,
+        context: tt,
+        fails: fails
+      });
+      return i && _.interpolateHsl(v, "blue");
+    }
+  },
+
+  "defines the corresponding style tween": function(result) {
+    assert.typeOf(result.transition.tween("style.background-color"), "function");
+  },
+  "the last style tween takes precedence": function(result) {
+    assert.equal(result.fails, 0);
+  },
+  "invokes the tween function": function(result) {
+    assert.deepEqual(result.data, ["red", "green"], "expected data, got {actual}");
+    assert.deepEqual(result.index, [0, 1], "expected index, got {actual}");
+    assert.deepEqual(result.value, ["#ff0000", "#008000"], "expected value, got {actual}");
+    assert.domEqual(result.context[0], result.selection[0][0], "expected this, got {actual}");
+    assert.domEqual(result.context[1], result.selection[0][1], "expected this, got {actual}");
+  },
+
+  "end": {
+    topic: function(result) {
+      var cb = this.callback;
+      result.transition.each("end", function(d, i) { if (i >= 1) cb(null, result); });
+    },
+    "uses the returned interpolator": function(result) {
+      assert.equal(result.selection[0][1].style.getPropertyValue("background-color"), "#0000ff");
+    },
+    "does nothing if the interpolator is falsey": function(result) {
+      assert.equal(result.selection[0][0].style.getPropertyValue("background-color"), "#ff0000");
+    }
+  }
+};

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

@@ -0,0 +1,27 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").append("div").text("foo").transition().text("bar");
+  },
+  "sets the text tween": function(div) {
+    assert.typeOf(div.tween("text"), "function");
+  },
+  "start": {
+    topic: function(div) {
+      var cb = this.callback,
+          tween = div.tween("text");
+      div.tween("text", function() {
+        var result = tween.apply(this, arguments);
+        cb(null, {transition: div, tween: result});
+        return result;
+      });
+    },
+    "sets the text content as a string": function(result) {
+      assert.equal(result.transition[0][0].textContent, "bar");
+    },
+    "does not interpolate text": function(result) {
+      assert.isTrue(!result.tween);
+    }
+  }
+};

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

@@ -0,0 +1,38 @@
+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();
+    },
+    "is approximately equal to now": function(transition) {
+      var time = transition[0][0].__transition__[transition.id].time;
+      assert.inDelta(time, Date.now(), 20);
+    }
+  },
+  "increases monotonically across transitions": function(d3) {
+    var now = Date.now, then = Date.now();
+    try {
+      Date.now = function() { return ++then; };
+      var t0 = d3.select("body").append("div").transition(),
+          t1 = d3.select("body").append("div").transition();
+      assert.isTrue(t1[0][0].__transition__[t1.id].time > t0[0][0].__transition__[t0.id].time);
+    } finally {
+      Date.now = now;
+    }
+  },
+  "is inherited by subtransitions": function(d3) {
+    var now = Date.now, then = Date.now();
+    try {
+      Date.now = function() { return ++then; };
+      var t0 = d3.select("body").append("div").transition(),
+          t1 = t0.transition();
+      assert.equal(t1[0][0].__transition__[t1.id].time, t0[0][0].__transition__[t0.id].time);
+    } finally {
+      Date.now = now;
+    }
+  }
+};

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

@@ -0,0 +1,59 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").append("div").transition()
+        .delay(101)
+        .duration(152)
+        .ease("bounce");
+  },
+
+  "starts immediately after the previous transition ends": function(t1) {
+    var t2 = t1.transition();
+    assert.equal(t2[0][0].__transition__[t2.id].delay, 253);
+  },
+  "inherits the previous transition's duration": function(t1) {
+    var t2 = t1.transition();
+    assert.equal(t2[0][0].__transition__[t2.id].duration, 152);
+  },
+  "inherits easing": function(t1) {
+    // TODO how to test this?
+  },
+  "gets a new transition id": function(t1) {
+    var t2 = t1.transition();
+    assert.isTrue(t2.id > t1.id);
+  },
+
+  "while transitioning": {
+    topic: function(t1) {
+      var callback = this.callback;
+      var t2 = t1.transition().tween("custom", function() {
+        return function(t) {
+          if (callback) {
+            callback(null, t2);
+            callback = null;
+          }
+        };
+      });
+    },
+    "increments the lock's reference count": function(t2) {
+      assert.isTrue(t2[0][0].__transition__.count > 1);
+    }
+  },
+
+  "after transitioning": {
+    topic: function(t1) {
+      var cb = this.callback;
+      var t2 = t1.transition();
+      t2.each("end", function() {
+        setTimeout(function() {
+          cb(null, t2);
+          return true;
+        }, 50);
+      });
+    },
+    "decrements the lock's reference count": function(t2) {
+      assert.isFalse("__transition__" in t2[0][0]);
+    }
+  }
+};

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

@@ -0,0 +1,62 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    var cb = this.callback,
+        dd = [],
+        ii = [],
+        tt = [],
+        fails = 0;
+
+    var s = d3.select("body").append("div").selectAll("div")
+        .data(["red", "green"])
+      .enter().append("div")
+        .text(function(d) { return d3.rgb(d)+""; });
+
+    var t = s.transition()
+        .tween("text", function() { ++fails; })
+        .tween("text", tween);
+
+    function tween(d, i) {
+      dd.push(d);
+      ii.push(i);
+      if (tt.push(this) >= 2) cb(null, {
+        selection: s,
+        transition: t,
+        data: dd,
+        index: ii,
+        context: tt,
+        fails: fails
+      });
+      return i && function(t) {
+        this.textContent = d3.hsl(230, 0.5, t) + "";
+      };
+    }
+  },
+
+  "defines the corresponding tween": function(result) {
+    assert.typeOf(result.transition.tween("text"), "function");
+  },
+  "the last tween takes precedence": function(result) {
+    assert.equal(result.fails, 0);
+  },
+  "invokes the tween function": function(result) {
+    assert.deepEqual(result.data, ["red", "green"], "expected data, got {actual}");
+    assert.deepEqual(result.index, [0, 1], "expected data, got {actual}");
+    assert.domEqual(result.context[0], result.selection[0][0], "expected this, got {actual}");
+    assert.domEqual(result.context[1], result.selection[0][1], "expected this, got {actual}");
+  },
+
+  "end": {
+    topic: function(result) {
+      var cb = this.callback;
+      result.transition.each("end", function(d, i) { if (i >= 1) cb(null, result); });
+    },
+    "uses the returned tweener": function(result) {
+      assert.equal(result.selection[0][1].textContent, "#ffffff");
+    },
+    "does nothing if the tweener is falsey": function(result) {
+      assert.equal(result.selection[0][0].textContent, "#ff0000");
+    }
+  }
+};

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

@@ -0,0 +1,89 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.transition");
+
+suite.addBatch({
+  "transition": {
+    topic: load("transition/transition").document(),
+    "selects the document element": function(d3) {
+      var transition = d3.transition();
+      assert.equal(transition.length, 1);
+      assert.equal(transition[0].length, 1);
+      assert.equal(transition[0][0].nodeType, 1);
+      assert.equal(transition[0][0].tagName, "HTML");
+    },
+    "is an instanceof d3.transition": function(d3) {
+      assert.isTrue(d3.transition() instanceof d3.transition);
+    },
+    "subselections are also instanceof d3.transition": function(d3) {
+      var transition = d3.transition();
+      assert.isTrue(transition.select("body") instanceof d3.transition);
+      assert.isTrue(transition.selectAll("body") instanceof d3.transition);
+    },
+    "transition prototype can be extended": function(d3) {
+      var transition = d3.transition(), vv = [];
+      d3.transition.prototype.foo = function(v) { vv.push(v); return this; };
+      transition.select("body").foo(42);
+      assert.deepEqual(vv, [42]);
+      delete d3.transition.prototype.foo;
+    }
+  }
+});
+
+// Subtransitions
+suite.addBatch({
+  "transition": {
+    topic: load("transition/transition").document(),
+    "select": require("./transition-test-select"),
+    "selectAll": require("./transition-test-selectAll"),
+    "transition": require("./transition-test-transition"),
+    "filter": require("./transition-test-filter")
+  }
+});
+
+// Content
+suite.addBatch({
+  "transition": {
+    topic: load("transition/transition").document(),
+    "attr": require("./transition-test-attr"),
+    "attrTween": require("./transition-test-attrTween"),
+    "style": require("./transition-test-style"),
+    "styleTween": require("./transition-test-styleTween"),
+    "text": require("./transition-test-text"),
+    "remove": require("./transition-test-remove")
+  }
+});
+
+// Animation
+suite.addBatch({
+  "transition": {
+    topic: load("transition/transition").document(),
+    "delay": require("./transition-test-delay"),
+    "duration": require("./transition-test-duration")
+  }
+});
+
+// Control
+suite.addBatch({
+  "transition": {
+    topic: load("transition/transition").document(),
+    "each": require("./transition-test-each"),
+    "call": require("./transition-test-call"),
+    "tween": require("./transition-test-tween"),
+    "id": require("./transition-test-id"),
+    "time": require("./transition-test-time")
+  }
+});
+
+// Inspection
+suite.addBatch({
+  "transition": {
+    topic: load("transition/transition").document(),
+    "size": require("./transition-test-size"),
+    "node": require("./transition-test-node")
+  }
+})
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/xhr/html-test.js

@@ -0,0 +1,37 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.html");
+
+suite.addBatch({
+  "html": {
+    topic: load("xhr/html").expression("d3.html").document(),
+
+    "on a sample file": {
+      topic: function(html) {
+        html("test/data/sample.html", this.callback);
+      },
+      "invokes the callback with the loaded html": function(document) {
+        assert.equal(document.getElementsByTagName("H1")[0].textContent, "Hello & world!");
+      },
+      "override the mime type to text/html": function(document) {
+        assert.equal(XMLHttpRequest._last._info.mimeType, "text/html");
+      }
+    },
+
+    "on a file that does not exist": {
+      topic: function(html) {
+        var callback = this.callback;
+        html("//does/not/exist.html", function(error, document) {
+          callback(null, document);
+        });
+      },
+      "invokes the callback with undefined when an error occurs": function(document) {
+        assert.isUndefined(document);
+      }
+    }
+  }
+});
+
+suite.export(module);