stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/arrays/min-test.js

@@ -0,0 +1,51 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.min");
+
+suite.addBatch({
+  "min": {
+    topic: load("arrays/min").expression("d3.min"),
+    "returns the least numeric value for numbers": function(min) {
+      assert.equal(min([1]), 1);
+      assert.equal(min([5, 1, 2, 3, 4]), 1);
+      assert.equal(min([20, 3]), 3);
+      assert.equal(min([3, 20]), 3);
+    },
+    "returns the least lexicographic value for strings": function(min) {
+      assert.equal(min(["c", "a", "b"]), "a");
+      assert.equal(min(["20", "3"]), "20");
+      assert.equal(min(["3", "20"]), "20");
+    },
+    "ignores null, undefined and NaN": function(min) {
+      var o = {valueOf: function() { return NaN; }};
+      assert.equal(min([NaN, 1, 2, 3, 4, 5]), 1);
+      assert.equal(min([o, 1, 2, 3, 4, 5]), 1);
+      assert.equal(min([1, 2, 3, 4, 5, NaN]), 1);
+      assert.equal(min([1, 2, 3, 4, 5, o]), 1);
+      assert.equal(min([10, null, 3, undefined, 5, NaN]), 3);
+      assert.equal(min([-1, null, -3, undefined, -5, NaN]), -5);
+    },
+    "compares heterogenous types as numbers": function(min) {
+      assert.strictEqual(min([20, "3"]), "3");
+      assert.strictEqual(min(["20", 3]), 3);
+      assert.strictEqual(min([3, "20"]), 3);
+      assert.strictEqual(min(["3", 20]), "3");
+    },
+    "returns undefined for empty array": function(min) {
+      assert.isUndefined(min([]));
+      assert.isUndefined(min([null]));
+      assert.isUndefined(min([undefined]));
+      assert.isUndefined(min([NaN]));
+      assert.isUndefined(min([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(min) {
+      assert.equal(min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.max(d); }), 5);
+      assert.equal(min([1, 2, 3, 4, 5], function(d, i) { return i; }), 0);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/arrays/nest-test.js

@@ -0,0 +1,256 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.nest");
+
+suite.addBatch({
+  "entries": {
+    topic: load("arrays/nest").expression("d3.nest"),
+    "returns an array of each distinct key in arbitrary order": function(nest) {
+      var keys = nest()
+          .key(function(d) { return d.foo; })
+          .entries([{foo: 1}, {foo: 1}, {foo: 2}])
+          .map(function(d) { return d.key; })
+          .sort(_.ascending);
+      assert.deepEqual(keys, ["1", "2"]);
+    },
+    "each entry is a key-values object, with values in input order": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .entries([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [{foo: 1, bar: 0}, {foo: 1, bar: 1}]},
+        {key: "2", values: [{foo: 2}]}
+      ]);
+    },
+    "keys can be sorted using an optional comparator": function(nest) {
+      var keys = nest()
+          .key(function(d) { return d.foo; }).sortKeys(_.descending)
+          .entries([{foo: 1}, {foo: 1}, {foo: 2}])
+          .map(function(d) { return d.key; });
+      assert.deepEqual(keys, ["2", "1"]);
+    },
+    "values can be sorted using an optional comparator": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .sortValues(function(a, b) { return a.bar - b.bar; })
+          .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [{foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 1, bar: 2}]},
+        {key: "2", values: [{foo: 2}]}
+      ]);
+    },
+    "values can be aggregated using an optional rollup": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
+          .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: 3},
+        {key: "2", values: 0}
+      ]);
+    },
+    "multiple key functions can be specified": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2], [0, 2]]}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]}
+      ]);
+    },
+    "the rollup function only applies to leaf values": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .rollup(function(values) { return values.length; })
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: 1},
+          {key: "2", values: 2}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: 1},
+          {key: "2", values: 1}
+        ]}
+      ]);
+    },
+    "the value comparator only applies to leaf values": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .sortValues(function(a, b) { return a[2] - b[2]; })
+          .entries([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2, 0], [0, 2, 1]]}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]}
+      ]);
+    },
+    "the key comparator only applies to the last-specified key": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.descending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "2", values: [[0, 2], [0, 2]]},
+          {key: "1", values: [[0, 1]]}
+        ]},
+        {key: "1", values: [
+          {key: "2", values: [[1, 2]]},
+          {key: "1", values: [[1, 1]]}
+        ]}
+      ]);
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.descending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]},
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2], [0, 2]]}
+        ]}
+      ]);
+    },
+    "if no keys are specified, the input array is returned": function(nest) {
+      var array = [new Object()];
+      assert.strictEqual(nest().entries(array), array);
+    }
+  }
+});
+
+suite.addBatch({
+  "map": {
+    topic: load("arrays/nest").expression("d3.nest"),
+    "returns a map of each distinct key": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .map([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
+      assert.deepEqual(map, {
+        "1": [{foo: 1, bar: 0}, {foo: 1, bar: 1}],
+        "2": [{foo: 2}]
+      });
+    },
+    "values can be sorted using an optional comparator": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .sortValues(function(a, b) { return a.bar - b.bar; })
+          .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(map, {
+        "1": [{foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 1, bar: 2}],
+        "2": [{foo: 2}]
+      });
+    },
+    "values can be aggregated using an optional rollup": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
+          .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(map, {
+        "1": 3,
+        "2": 0
+      });
+    },
+    "multiple key functions can be specified": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": [[0, 1]],
+          "2": [[0, 2], [0, 2]]
+        },
+        "1": {
+          "1": [[1, 1]],
+          "2": [[1, 2]]
+        }
+      });
+    },
+    "the rollup function only applies to leaf values": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .rollup(function(values) { return values.length; })
+          .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": 1,
+          "2": 2
+        },
+        "1": {
+          "1": 1,
+          "2": 1
+        }
+      });
+    },
+    "the value comparator only applies to leaf values": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .sortValues(function(a, b) { return a[2] - b[2]; })
+          .map([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": [[0, 1]],
+          "2": [[0, 2, 0], [0, 2, 1]]
+        },
+        "1": {
+          "1": [[1, 1]],
+          "2": [[1, 2]]
+        }
+      });
+    },
+    "if no keys are specified, the input array is returned": function(nest) {
+      var array = [new Object()];
+      assert.strictEqual(nest().map(array), array);
+    },
+    "handles keys that are built-in prototype properties": function(nest) {
+      var map = nest()
+          .key(String)
+          .map(["hasOwnProperty"]); // but note __proto__ wouldn’t work!
+      assert.deepEqual(map, {hasOwnProperty: ["hasOwnProperty"]});
+    },
+    "a custom map implementation can be specified": function(nest) {
+      var map = nest()
+          .key(String)
+          .map(["hasOwnProperty", "__proto__"], _.map);
+      assert.deepEqual(map.entries(), [
+        {key: "hasOwnProperty", value: ["hasOwnProperty"]},
+        {key: "__proto__", value: ["__proto__"]}
+      ]);
+    },
+    "the custom map implementation works on multiple levels of nesting": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .key(function(d) { return d.bar; })
+          .map([{foo: 42, bar: "red"}], _.map);
+      assert.deepEqual(map.keys(), ["42"]);
+      assert.deepEqual(map.get("42").keys(), ["red"]);
+      assert.deepEqual(map.get("42").values(), [[{foo: 42, bar: "red"}]]);
+      assert.deepEqual(map.get("42").entries(), [{key: "red", value: [{foo: 42, bar: "red"}]}]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/arrays/permute-test.js

@@ -0,0 +1,49 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.permute");
+
+suite.addBatch({
+  "permute": {
+    topic: load("arrays/permute").expression("d3.permute"),
+    "permutes according to the specified index": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [2, 1, 0]), [5, 4, 3]);
+      assert.deepEqual(permute([3, 4, 5], [2, 0, 1]), [5, 3, 4]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 2]), [3, 4, 5]);
+    },
+    "does not modify the input array": function(permute) {
+      var input = [3, 4, 5];
+      permute(input, [2, 1, 0]);
+      assert.deepEqual(input, [3, 4, 5]);
+    },
+    "can duplicate input values": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 0]), [3, 4, 3]);
+      assert.deepEqual(permute([3, 4, 5], [2, 2, 2]), [5, 5, 5]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 1]), [3, 4, 4]);
+    },
+    "can return more elements": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0, 0, 1, 2]), [3, 3, 4, 5]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 1, 1]), [3, 4, 4, 4]);
+    },
+    "can return fewer elements": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0]), [3]);
+      assert.deepEqual(permute([3, 4, 5], [1, 2]), [4, 5]);
+      assert.deepEqual(permute([3, 4, 5], []), []);
+    },
+    "can return undefined elements": function(permute) {
+      var v1 = permute([3, 4, 5], [10]);
+      assert.equal(v1.length, 1);
+      assert.isUndefined(v1[0]);
+      var v2 = permute([3, 4, 5], [-1]);
+      assert.equal(v2.length, 1);
+      assert.isUndefined(v2[0]);
+      var v3 = permute([3, 4, 5], [0, -1]);
+      assert.equal(v3.length, 2);
+      assert.equal(v3[0], 3);
+      assert.isUndefined(v3[1]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/arrays/quantile-test.js

@@ -0,0 +1,56 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.quantile");
+
+suite.addBatch({
+  "quantile": {
+    topic: load("arrays/quantile").expression("d3.quantile"),
+    "requires sorted numeric input": function(quantile) {
+      assert.equal(quantile([1, 2, 3, 4], 0), 1);
+      assert.equal(quantile([1, 2, 3, 4], 1), 4);
+      assert.equal(quantile([4, 3, 2, 1], 0), 4);
+      assert.equal(quantile([4, 3, 2, 1], 1), 1);
+    },
+    "uses the R-7 algorithm": function(quantile) {
+      var data = [3, 6, 7, 8, 8, 10, 13, 15, 16, 20];
+      assert.equal(quantile(data, 0), 3);
+      assert.equal(quantile(data, .25), 7.25);
+      assert.equal(quantile(data, .5), 9);
+      assert.equal(quantile(data, .75), 14.5);
+      assert.equal(quantile(data, 1), 20);
+      var data = [3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20];
+      assert.equal(quantile(data, 0), 3);
+      assert.equal(quantile(data, .25), 7.5);
+      assert.equal(quantile(data, .5), 9);
+      assert.equal(quantile(data, .75), 14);
+      assert.equal(quantile(data, 1), 20);
+    },
+    "coerces values to numbers": function(quantile) {
+      var strings = ["1", "2", "3", "4"];
+      assert.strictEqual(quantile(strings, 1/3), 2);
+      assert.strictEqual(quantile(strings, 1/2), 2.5);
+      assert.strictEqual(quantile(strings, 2/3), 3);
+      var dates = [new Date(2011, 0, 1), new Date(2012, 0, 1)];
+      assert.strictEqual(quantile(dates, 0), +new Date(2011, 0, 1));
+      assert.strictEqual(quantile(dates, 1/2), +new Date(2011, 6, 2, 13));
+      assert.strictEqual(quantile(dates, 1), +new Date(2012, 0, 1));
+    },
+    "returns an exact value for integer p-values": function(quantile) {
+      var data = [1, 2, 3, 4];
+      assert.equal(quantile(data, 1/3), 2);
+      assert.equal(quantile(data, 2/3), 3);
+    },
+    "returns the first value for p = 0": function(quantile) {
+      var data = [1, 2, 3, 4];
+      assert.equal(quantile(data, 0), 1);
+    },
+    "returns the last value for p = 1": function(quantile) {
+      var data = [1, 2, 3, 4];
+      assert.equal(quantile(data, 1), 4);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/arrays/range-test.js

@@ -0,0 +1,99 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.range");
+
+suite.addBatch({
+  "range": {
+    topic: load("arrays/range").expression("d3.range"),
+    "start is an inclusive lower bound": function(range) {
+      assert.equal(range(5)[0], 0);
+      assert.equal(range(1, 5)[0], 1);
+      assert.equal(range(5, 1, -1)[0], 5);
+    },
+    "stop is an exclusive upper bound": function(range) {
+      assert.equal(range(5)[4], 4);
+      assert.equal(range(1, 5)[3], 4);
+      assert.equal(range(5, 1, -1)[3], 2);
+    },
+    "with one argument, returns integers [0 … stop)": function(range) {
+      assert.deepEqual(range(0), []);
+      assert.deepEqual(range(1), [0]);
+      assert.deepEqual(range(5), [0, 1, 2, 3, 4]);
+    },
+    "with two arguments, returns integers [start … stop)": function(range) {
+      assert.deepEqual(range(0, 5), [0, 1, 2, 3, 4]);
+      assert.deepEqual(range(5, 9), [5, 6, 7, 8]);
+    },
+    "with three arguments, returns start + k * step": function(range) {
+      assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]);
+      assert.deepEqual(range(5, 9, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5]);
+      assert.deepEqual(range(5, 8.5, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8]);
+      assert.deepEqual(range(2, 0, -.5), [2, 1.5, 1, .5]);
+    },
+    "handles fractional steps without rounding errors": function(range) {
+      assert.deepEqual(range(0, 0.5, 0.1), [0, 0.1, 0.2, 0.3, 0.4]);
+      assert.deepEqual(range(-2, -1.2, 0.1), [-2, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3]);
+    },
+    "handles extremely small steps without rounding errors": function(range) {
+      assert.deepEqual(range(2.1e-31, 5e-31, 1.1e-31), [2.1e-31, 3.2e-31, 4.3e-31]);
+    },
+    "handles extremely large steps without rounding errors": function(range) {
+      assert.deepEqual(range(1e300, 2e300, 0.3e300), [1e300, 1.3e300, 1.6e300, 1.9e300]);
+    },
+    "returns an ascending range if step is positive": function(range) {
+      assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]);
+    },
+    "returns a descending range if step is negative": function(range) {
+      assert.deepEqual(range(5, 0, -1), [5, 4, 3, 2, 1]);
+    },
+    "returns an empty range if start, stop or step are NaN": function(range) {
+      assert.isEmpty(range(0, NaN));
+      assert.isEmpty(range(1, NaN));
+      assert.isEmpty(range(-1, NaN));
+      assert.isEmpty(range(0, undefined));
+      assert.isEmpty(range(1, undefined));
+      assert.isEmpty(range(-1, undefined));
+      assert.isEmpty(range(NaN, 0));
+      assert.isEmpty(range(NaN, 1));
+      assert.isEmpty(range(NaN, -1));
+      assert.isEmpty(range(undefined, 0));
+      assert.isEmpty(range(undefined, 1));
+      assert.isEmpty(range(undefined, -1));
+      assert.isEmpty(range(NaN, NaN));
+      assert.isEmpty(range(undefined, undefined));
+      assert.isEmpty(range(NaN, NaN, NaN));
+      assert.isEmpty(range(undefined, undefined, undefined));
+      assert.isEmpty(range(0, 10, NaN));
+      assert.isEmpty(range(10, 0, NaN));
+      assert.isEmpty(range(0, 10, undefined));
+      assert.isEmpty(range(10, 0, undefined));
+    },
+    "returns an empty range if start equals stop": function(range) {
+      assert.isEmpty(range(10, 10));
+      assert.isEmpty(range(10, 10, 1));
+      assert.isEmpty(range(10, 10, -1));
+      assert.isEmpty(range(10, 10, -.5));
+      assert.isEmpty(range(10, 10, .5));
+      assert.isEmpty(range(0, 0));
+      assert.isEmpty(range(0, 0, 1));
+      assert.isEmpty(range(0, 0, -1));
+      assert.isEmpty(range(0, 0, -.5));
+      assert.isEmpty(range(0, 0, .5));
+    },
+    "returns an empty range if stop is less than start and step is positive": function(range) {
+      assert.isEmpty(range(20, 10));
+      assert.isEmpty(range(20, 10, 2));
+      assert.isEmpty(range(20, 10, 1));
+      assert.isEmpty(range(20, 10, .5));
+    },
+    "returns an empty range if stop is greater than start and step is negative": function(range) {
+      assert.isEmpty(range(10, 20, -2));
+      assert.isEmpty(range(10, 20, -1));
+      assert.isEmpty(range(10, 20, -.5));
+    }
+  }
+});
+
+suite.export(module);