stripchart 0.0.3

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

@@ -0,0 +1,137 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.time.year");
+
+suite.addBatch({
+  "year": {
+    topic: load("time/year").expression("d3.time.year"),
+    "defaults to floor": function(interval) {
+      assert.strictEqual(interval, interval.floor);
+    },
+    "floor": {
+      topic: function(interval) {
+        return interval.floor;
+      },
+      "returns years": function(floor) {
+        assert.deepEqual(floor(local(2010, 11, 31, 23, 59, 59)), local(2010, 00, 01));
+        assert.deepEqual(floor(local(2011, 00, 01, 00, 00, 00)), local(2011, 00, 01));
+        assert.deepEqual(floor(local(2011, 00, 01, 00, 00, 01)), local(2011, 00, 01));
+      },
+      "correctly handles years in the first century": function(floor) {
+        assert.deepEqual(floor(local(0011, 10, 06, 07)), local(0011, 00, 01));
+      }
+    },
+    "ceil": {
+      topic: function(interval) {
+        return interval.ceil;
+      },
+      "returns years": function(ceil) {
+        assert.deepEqual(ceil(local(2010, 11, 31, 23, 59, 59)), local(2011, 00, 01));
+        assert.deepEqual(ceil(local(2011, 00, 01, 00, 00, 00)), local(2011, 00, 01));
+        assert.deepEqual(ceil(local(2011, 00, 01, 00, 00, 01)), local(2012, 00, 01));
+      }
+    },
+    "offset": {
+      topic: function(interval) {
+        return interval.offset;
+      },
+      "does not modify the passed-in date": function(offset) {
+        var date = local(2010, 11, 31, 23, 59, 59, 999);
+        offset(date, +1);
+        assert.deepEqual(date, local(2010, 11, 31, 23, 59, 59, 999));
+      },
+      "does not round the passed-in-date": function(offset) {
+        assert.deepEqual(offset(local(2010, 11, 31, 23, 59, 59, 999), +1), local(2011, 11, 31, 23, 59, 59, 999));
+        assert.deepEqual(offset(local(2010, 11, 31, 23, 59, 59, 456), -2), local(2008, 11, 31, 23, 59, 59, 456));
+      },
+      "allows negative offsets": function(offset) {
+        assert.deepEqual(offset(local(2010, 11, 01), -1), local(2009, 11, 01));
+        assert.deepEqual(offset(local(2011, 00, 01), -2), local(2009, 00, 01));
+        assert.deepEqual(offset(local(2011, 00, 01), -1), local(2010, 00, 01));
+      },
+      "allows positive offsets": function(offset) {
+        assert.deepEqual(offset(local(2009, 11, 01), +1), local(2010, 11, 01));
+        assert.deepEqual(offset(local(2009, 00, 01), +2), local(2011, 00, 01));
+        assert.deepEqual(offset(local(2010, 00, 01), +1), local(2011, 00, 01));
+      },
+      "allows zero offset": function(offset) {
+        assert.deepEqual(offset(local(2010, 11, 31, 23, 59, 59, 999), 0), local(2010, 11, 31, 23, 59, 59, 999));
+        assert.deepEqual(offset(local(2010, 11, 31, 23, 59, 58, 000), 0), local(2010, 11, 31, 23, 59, 58, 000));
+      }
+    },
+    "UTC": {
+      topic: function(interval) {
+        return interval.utc;
+      },
+      "defaults to floor": function(interval) {
+        assert.strictEqual(interval, interval.floor);
+      },
+      "floor": {
+        topic: function(interval) {
+          return interval.floor;
+        },
+        "returns years": function(floor) {
+          assert.deepEqual(floor(utc(2010, 11, 31, 23, 59, 59)), utc(2010, 00, 01));
+          assert.deepEqual(floor(utc(2011, 00, 01, 00, 00, 00)), utc(2011, 00, 01));
+          assert.deepEqual(floor(utc(2011, 00, 01, 00, 00, 01)), utc(2011, 00, 01));
+        }
+      },
+      "ceil": {
+        topic: function(interval) {
+          return interval.ceil;
+        },
+        "returns years": function(ceil) {
+          assert.deepEqual(ceil(utc(2010, 11, 31, 23, 59, 59)), utc(2011, 00, 01));
+          assert.deepEqual(ceil(utc(2011, 00, 01, 00, 00, 00)), utc(2011, 00, 01));
+          assert.deepEqual(ceil(utc(2011, 00, 01, 00, 00, 01)), utc(2012, 00, 01));
+        }
+      },
+      "offset": {
+        topic: function(interval) {
+          return interval.offset;
+        },
+        "does not modify the passed-in date": function(offset) {
+          var date = utc(2010, 11, 31, 23, 59, 59, 999);
+          offset(date, +1);
+          assert.deepEqual(date, utc(2010, 11, 31, 23, 59, 59, 999));
+        },
+        "does not round the passed-in-date": function(offset) {
+          assert.deepEqual(offset(utc(2010, 11, 31, 23, 59, 59, 999), +1), utc(2011, 11, 31, 23, 59, 59, 999));
+          assert.deepEqual(offset(utc(2010, 11, 31, 23, 59, 59, 456), -2), utc(2008, 11, 31, 23, 59, 59, 456));
+        },
+        "allows negative offsets": function(offset) {
+          assert.deepEqual(offset(utc(2010, 11, 01), -1), utc(2009, 11, 01));
+          assert.deepEqual(offset(utc(2011, 00, 01), -2), utc(2009, 00, 01));
+          assert.deepEqual(offset(utc(2011, 00, 01), -1), utc(2010, 00, 01));
+        },
+        "allows positive offsets": function(offset) {
+          assert.deepEqual(offset(utc(2009, 11, 01), +1), utc(2010, 11, 01));
+          assert.deepEqual(offset(utc(2009, 00, 01), +2), utc(2011, 00, 01));
+          assert.deepEqual(offset(utc(2010, 00, 01), +1), utc(2011, 00, 01));
+        },
+        "allows zero offset": function(offset) {
+          assert.deepEqual(offset(utc(2010, 11, 31, 23, 59, 59, 999), 0), utc(2010, 11, 31, 23, 59, 59, 999));
+          assert.deepEqual(offset(utc(2010, 11, 31, 23, 59, 58, 000), 0), utc(2010, 11, 31, 23, 59, 58, 000));
+        }
+      }
+    }
+  }
+});
+
+function local(year, month, day, hours, minutes, seconds, milliseconds) {
+  var date = new Date();
+  date.setFullYear(year, month, day);
+  date.setHours(hours || 0, minutes || 0, seconds || 0, milliseconds || 0);
+  return date;
+}
+
+function utc(year, month, day, hours, minutes, seconds, milliseconds) {
+  var date = new Date();
+  date.setUTCFullYear(year, month, day);
+  date.setUTCHours(hours || 0, minutes || 0, seconds || 0, milliseconds || 0);
+  return date;
+}
+
+suite.export(module);

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

@@ -0,0 +1,74 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.time.years");
+
+suite.addBatch({
+  "years": {
+    topic: load("time/year").expression("d3.time.years"),
+    "returns years": function(range) {
+      assert.deepEqual(range(local(2010, 0, 1), local(2013, 0, 1)), [
+        local(2010, 0, 1),
+        local(2011, 0, 1),
+        local(2012, 0, 1)
+      ]);
+    },
+    "has an inclusive lower bound": function(range) {
+      assert.deepEqual(range(local(2010, 0, 1), local(2013, 0, 1))[0], local(2010, 0, 1));
+    },
+    "has an exclusive upper bound": function(range) {
+      assert.deepEqual(range(local(2010, 0, 1), local(2013, 0, 1))[2], local(2012, 0, 1));
+    },
+    "can skip years": function(range) {
+      assert.deepEqual(range(local(2009, 0, 1), local(2029, 0, 1), 5), [
+        local(2010, 0, 1),
+        local(2015, 0, 1),
+        local(2020, 0, 1),
+        local(2025, 0, 1)
+      ]);
+    },
+    "UTC": {
+      topic: function(range) {
+        return range.utc;
+      },
+      "returns years": function(range) {
+        assert.deepEqual(range(utc(2010, 0, 1), utc(2013, 0, 1)), [
+          utc(2010, 0, 1),
+          utc(2011, 0, 1),
+          utc(2012, 0, 1)
+        ]);
+      },
+      "has an inclusive lower bound": function(range) {
+        assert.deepEqual(range(utc(2010, 0, 1), utc(2013, 0, 1))[0], utc(2010, 0, 1));
+      },
+      "has an exclusive upper bound": function(range) {
+        assert.deepEqual(range(utc(2010, 0, 1), utc(2013, 0, 1))[2], utc(2012, 0, 1));
+      },
+      "can skip years": function(range) {
+        assert.deepEqual(range(utc(2009, 0, 1), utc(2029, 0, 1), 5), [
+          utc(2010, 0, 1),
+          utc(2015, 0, 1),
+          utc(2020, 0, 1),
+          utc(2025, 0, 1)
+        ]);
+      }
+    }
+  }
+});
+
+function local(year, month, day, hours, minutes, seconds, milliseconds) {
+  var date = new Date();
+  date.setFullYear(year, month, day);
+  date.setHours(hours || 0, minutes || 0, seconds || 0, milliseconds || 0);
+  return date;
+}
+
+function utc(year, month, day, hours, minutes, seconds, milliseconds) {
+  var date = new Date();
+  date.setUTCFullYear(year, month, day);
+  date.setUTCHours(hours || 0, minutes || 0, seconds || 0, milliseconds || 0);
+  return date;
+}
+
+suite.export(module);

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

@@ -0,0 +1,56 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    var s = d3.select("body").append("div")
+        .attr("display", "none")
+        .attr("font-size", "20px")
+        .attr("width", 20)
+        .attr("color", "red")
+        .attr("xlink:type", "simple")
+        .attr("xlink:href", "http://mbostock.github.com/d3/");
+
+    var t = s.transition()
+        .attr("display", null)
+        .attr("font-size", function() { return null; })
+        .attr("display", null)
+        .attr("width", 100)
+        .attr("width", 200)
+        .attr("color", function() { return "green"; })
+        .attr("xlink:href", null)
+        .attr("xlink:type", function() { return null; });
+
+    return {selection: s, transition: t};
+  },
+  "defines the corresponding attr tween": function(result) {
+    assert.typeOf(result.transition.tween("attr.width"), "function");
+    assert.typeOf(result.transition.tween("attr.color"), "function");
+  },
+  "on end": {
+    topic: function(result) {
+      var cb = this.callback;
+      result.transition.each("end", function() { cb(null, result); });
+    },
+    "the last attr operator takes precedence": function(result) {
+      assert.equal(result.selection.attr("width"), "200");
+    },
+    "sets an attribute as a number": function(result) {
+      assert.equal(result.selection.attr("width"), "200");
+    },
+    "sets an attribute as a function": function(result) {
+      assert.equal(result.selection.attr("color"), "#008000");
+    },
+    "removes an attribute using a constant null": function(result) {
+      assert.isNull(result.selection.attr("display"));
+    },
+    "removes an attribute using a function null": function(result) {
+      assert.isNull(result.selection.attr("font-size"));
+    },
+    "removes a namespaced attribute using a constant null": function(result) {
+      assert.isNull(result.selection.attr("xlink:href"));
+    },
+    "removes a namespaced attribute using a function null": function(result) {
+      assert.isNull(result.selection.attr("xlink:type"));
+    }
+  }
+};

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

@@ -0,0 +1,59 @@
+var assert = require("../assert"),
+    _ = require("../../");
+
+module.exports = {
+  topic: function(d3) {
+    var callback = this.callback,
+        dd = [],
+        ii = [],
+        tt = [],
+        vv = [];
+
+    var s = d3.select("body").html("").append("div").selectAll("div")
+        .data(["red", "green"])
+      .enter().append("div")
+        .attr("color", function(d, i) { return i ? "#008000" : "#ff0000"; });
+
+    var t = s.transition()
+        .attrTween("color", tween);
+
+    function tween(d, i, v) {
+      dd.push(d);
+      ii.push(i);
+      vv.push(v);
+      if (tt.push(this) >= 2) callback(null, {
+        selection: s,
+        transition: t,
+        data: dd,
+        index: ii,
+        value: vv,
+        context: tt
+      });
+      return i && _.interpolateHsl(v, "blue");
+    }
+  },
+
+  "defines the corresponding attr tween": function(result) {
+    assert.typeOf(result.transition.tween("attr.color"), "function");
+  },
+  "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.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 callback = this.callback;
+      result.transition.each("end", function(d, i) { if (i >= 1) callback(null, result); });
+    },
+    "uses the returned interpolator": function(result) {
+      assert.equal(result.selection[0][1].getAttribute("color"), "#0000ff");
+    },
+    "does nothing if the interpolator is falsey": function(result) {
+      assert.equal(result.selection[0][0].getAttribute("color"), "#ff0000");
+    }
+  }
+};

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

@@ -0,0 +1,30 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").append("div").transition();
+  },
+  "calls the function once": function(transition) {
+    var count = 0;
+    transition.call(function() { ++count; });
+    assert.equal(count, 1);
+  },
+  "passes any optional arguments": function(transition) {
+    var abc;
+    transition.call(function(selection, a, b, c) { abc = [a, b, c]; }, "a", "b", "c");
+    assert.deepEqual(abc, ["a", "b", "c"]);
+  },
+  "passes the transition as the first argument": function(transition) {
+    var t;
+    transition.call(function(x) { t = x; });
+    assert.isTrue(t === transition);
+  },
+  "uses the transition as the context": function(transition) {
+    var t;
+    transition.call(function() { t = this; });
+    assert.isTrue(t === transition);
+  },
+  "returns the current transition": function(transition) {
+    assert.isTrue(transition.call(function() {}) === transition);
+  }
+};

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

@@ -0,0 +1,56 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").html("").selectAll()
+        .data(["foo", "bar"])
+      .enter().append("div")
+        .attr("class", String);
+  },
+  "defaults to zero": function(selection) {
+    var t = selection.transition();
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 0);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 0);
+  },
+  "can specify delay as a number": function(selection) {
+    var t = selection.transition().delay(150);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 150);
+    t.delay(250);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 250);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 250);
+  },
+  "can specify delay as a negative number": function(selection) {
+    var t = selection.transition().delay(-250);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, -250);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, -250);
+  },
+  "NaN delays are treated as 0ms": function(selection) {
+    var t = selection.transition().delay(NaN);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 0);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 0);
+  },
+  "floating-point durations are floored to integers": function(selection) {
+    var t = selection.transition().delay(14.6);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 14);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 14);
+    var t = selection.transition().delay("16.99");
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 16);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 16);
+  },
+  "can specify delay as a function": function(selection) {
+    var dd = [], ii = [], tt = [], t = selection.transition().delay(f);
+    function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return i * 20; }
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 0);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 20);
+    assert.deepEqual(dd, ["foo", "bar"], "expected data, got {actual}");
+    assert.deepEqual(ii, [0, 1], "expected index, got {actual}");
+    assert.domEqual(tt[0], t[0][0], "expected this, got {actual}");
+    assert.domEqual(tt[1], t[0][1], "expected this, got {actual}");
+  },
+  "coerces delay to a number": function(selection) {
+    var t = selection.transition().delay("150");
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 150);
+  }
+};

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

@@ -0,0 +1,60 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").html("").selectAll()
+        .data(["foo", "bar"])
+      .enter().append("div")
+        .attr("class", String);
+  },
+  "defaults to 250 milliseconds": function(selection) {
+    var t = selection.transition();
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 250);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 250);
+  },
+  "can specify duration as a number": function(selection) {
+    var t = selection.transition().duration(150);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 150);
+    t.duration(50);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 50);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 50);
+  },
+  "NaN, zero, or negative durations are treated as 1ms": function(selection) {
+    var t = selection.transition().duration(NaN);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+    t.duration(0);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+    t.duration(-10);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+    t.duration(-Infinity);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+  },
+  "floating-point durations are floored to integers": function(selection) {
+    var t = selection.transition().duration(14.6);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 14);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 14);
+    var t = selection.transition().duration("16.99");
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 16);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 16);
+  },
+  "can specify duration as a function": function(selection) {
+    var dd = [], ii = [], tt = [], t = selection.transition().duration(f);
+    function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return i * 20 + 10; }
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 10);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 30);
+    assert.deepEqual(dd, ["foo", "bar"], "expected data, got {actual}");
+    assert.deepEqual(ii, [0, 1], "expected index, got {actual}");
+    assert.domEqual(tt[0], t[0][0], "expected this, got {actual}");
+    assert.domEqual(tt[1], t[0][1], "expected this, got {actual}");
+  },
+  "coerces duration to a number": function(selection) {
+    var t = selection.transition().duration("150");
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 150);
+  }
+};