stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/interpolate/string-test.js

@@ -0,0 +1,43 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateString");
+
+suite.addBatch({
+  "interpolateString": {
+    topic: load("interpolate/string").expression("d3.interpolateString"),
+    "interpolates matching numbers in both strings": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 100 ")(.2), "18/18 44 ");
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 ");
+    },
+    "coerces objects to strings": function(interpolate) {
+      assert.strictEqual(interpolate({toString: function() { return "2px"; }}, {toString: function() { return "12px"; }})(.4), "6px");
+    },
+    "preserves non-numbers in string b": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 foo ")(.2), "18/18 foo ");
+      assert.strictEqual(interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo ");
+    },
+    "preserves non-matching numbers in string b": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 foo", "50/10 100 ")(.2), "18/18 100 ");
+      assert.strictEqual(interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 ");
+    },
+    "preserves equal-value numbers in both strings": function(interpolate) {
+      assert.strictEqual(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.2), "18/18 100, 20 ");
+      assert.strictEqual(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 ");
+    },
+    "interpolates decimal notation correctly": function(interpolate) {
+      assert.strictEqual(interpolate("1.", "2.")(.5), "1.5");
+    },
+    "interpolates exponent notation correctly": function(interpolate) {
+      assert.strictEqual(interpolate("1e+3", "1e+4")(.5), "5500");
+      assert.strictEqual(interpolate("1e-3", "1e-4")(.5), "0.00055");
+      assert.strictEqual(interpolate("1.e-3", "1.e-4")(.5), "0.00055");
+      assert.strictEqual(interpolate("-1.e-3", "-1.e-4")(.5), "-0.00055");
+      assert.strictEqual(interpolate("+1.e-3", "+1.e-4")(.5), "0.00055");
+      assert.strictEqual(interpolate(".1e-2", ".1e-3")(.5), "0.00055");
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/layout/chord-test.js

@@ -0,0 +1,164 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.chord");
+
+suite.addBatch({
+  "chord": {
+    topic: load("layout/chord").expression("d3.layout.chord"),
+    "of a simple matrix": {
+      topic: function(chord) {
+        return chord()
+            .padding(.05)
+            .sortSubgroups(function(a, b) { return b - a; })
+            .matrix([
+              [11975,  5871, 8916, 2868],
+              [ 1951, 10048, 2060, 6171],
+              [ 8010, 16145, 8090, 8045],
+              [ 1013,   990,  940, 6907]
+            ]);
+      },
+      "computes chord groups": function(chord) {
+        var groups = chord.groups();
+        assert.equal(groups.length, 4);
+
+        assert.equal(groups[0].index, 0);
+        assert.inDelta(groups[0].startAngle, 0.0000000000000000, 1e-6);
+        assert.inDelta(groups[0].endAngle, 1.8024478065173115, 1e-6);
+        assert.inDelta(groups[0].value, 29630, 1e-6);
+
+        assert.equal(groups[1].index, 1);
+        assert.inDelta(groups[1].startAngle, 1.8524478065173116, 1e-6);
+        assert.inDelta(groups[1].endAngle, 3.0830761941597418, 1e-6);
+        assert.inDelta(groups[1].value, 20230, 1e-6);
+
+        assert.equal(groups[2].index, 2);
+        assert.inDelta(groups[2].startAngle, 3.1330761941597416, 1e-6);
+        assert.inDelta(groups[2].endAngle, 5.583991554422396, 1e-6);
+        assert.inDelta(groups[2].value, 40290, 1e-6);
+
+        assert.equal(groups[3].index, 3);
+        assert.inDelta(groups[3].startAngle, 5.6339915544223960, 1e-6);
+        assert.inDelta(groups[3].endAngle, 6.233185307179585, 1e-6);
+        assert.inDelta(groups[3].value, 9850, 1e-6);
+      },
+      "computes chords": function(chord) {
+        var chords = chord.chords();
+        assert.equal(chords.length, 10);
+
+        assert.equal(chords[0].source.index, 0);
+        assert.equal(chords[0].source.subindex, 0);
+        assert.inDelta(chords[0].source.startAngle, 0, 1e-6);
+        assert.inDelta(chords[0].source.endAngle, 0.7284614405347555, 1e-6);
+        assert.equal(chords[0].source.value, 11975);
+        assert.equal(chords[0].target.index, 0);
+        assert.equal(chords[0].target.subindex, 0);
+        assert.inDelta(chords[0].target.startAngle, 0, 1e-6);
+        assert.inDelta(chords[0].target.endAngle, 0.7284614405347555, 1e-6);
+        assert.equal(chords[0].target.value, 11975);
+
+        assert.equal(chords[1].source.index, 0);
+        assert.equal(chords[1].source.subindex, 1);
+        assert.inDelta(chords[1].source.startAngle, 1.2708382425228875, 1e-6);
+        assert.inDelta(chords[1].source.endAngle, 1.6279820519074009, 1e-6);
+        assert.equal(chords[1].source.value, 5871);
+        assert.equal(chords[1].target.index, 1);
+        assert.equal(chords[1].target.subindex, 0);
+        assert.inDelta(chords[1].target.startAngle, 2.964393248816668, 1e-6);
+        assert.inDelta(chords[1].target.endAngle, 3.0830761941597418, 1e-6);
+        assert.equal(chords[1].target.value, 1951);
+
+        assert.equal(chords[2].source.index, 0);
+        assert.equal(chords[2].source.subindex, 2);
+        assert.inDelta(chords[2].source.startAngle, 0.7284614405347555, 1e-6);
+        assert.inDelta(chords[2].source.endAngle, 1.2708382425228875, 1e-6);
+        assert.equal(chords[2].source.value, 8916);
+        assert.equal(chords[2].target.index, 2);
+        assert.equal(chords[2].target.subindex, 0);
+        assert.inDelta(chords[2].target.startAngle, 5.0967284113173115, 1e-6);
+        assert.inDelta(chords[2].target.endAngle, 5.583991554422396, 1e-6);
+        assert.equal(chords[2].target.value, 8010);
+
+        assert.equal(chords[3].source.index, 0);
+        assert.equal(chords[3].source.subindex, 3);
+        assert.inDelta(chords[3].source.startAngle, 1.6279820519074009, 1e-6);
+        assert.inDelta(chords[3].source.endAngle, 1.8024478065173115, 1e-6);
+        assert.equal(chords[3].source.value, 2868);
+        assert.equal(chords[3].target.index, 3);
+        assert.equal(chords[3].target.subindex, 0);
+        assert.inDelta(chords[3].target.startAngle, 6.05415716358929, 1e-6);
+        assert.inDelta(chords[3].target.endAngle, 6.115779830751019, 1e-6);
+        assert.equal(chords[3].target.value, 1013);
+
+        assert.equal(chords[4].source.index, 1);
+        assert.equal(chords[4].source.subindex, 1);
+        assert.inDelta(chords[4].source.startAngle, 1.8524478065173116, 1e-6);
+        assert.inDelta(chords[4].source.endAngle, 2.4636862661827164, 1e-6);
+        assert.equal(chords[4].source.value, 10048);
+        assert.equal(chords[4].target.index, 1);
+        assert.equal(chords[4].target.subindex, 1);
+        assert.inDelta(chords[4].target.startAngle, 1.8524478065173116, 1e-6);
+        assert.inDelta(chords[4].target.endAngle, 2.4636862661827164, 1e-6);
+        assert.equal(chords[4].target.value, 10048);
+
+        assert.equal(chords[5].source.index, 2);
+        assert.equal(chords[5].source.subindex, 1);
+        assert.inDelta(chords[5].source.startAngle, 3.1330761941597416, 1e-6);
+        assert.inDelta(chords[5].source.endAngle, 4.1152064620038855, 1e-6);
+        assert.equal(chords[5].source.value, 16145);
+        assert.equal(chords[5].target.index, 1);
+        assert.equal(chords[5].target.subindex, 2);
+        assert.inDelta(chords[5].target.startAngle, 2.8390796314887687, 1e-6);
+        assert.inDelta(chords[5].target.endAngle, 2.964393248816668, 1e-6);
+        assert.equal(chords[5].target.value, 2060);
+
+        assert.equal(chords[6].source.index, 1);
+        assert.equal(chords[6].source.subindex, 3);
+        assert.inDelta(chords[6].source.startAngle, 2.4636862661827164, 1e-6);
+        assert.inDelta(chords[6].source.endAngle, 2.8390796314887687, 1e-6);
+        assert.equal(chords[6].source.value, 6171);
+        assert.equal(chords[6].target.index, 3);
+        assert.equal(chords[6].target.subindex, 1);
+        assert.inDelta(chords[6].target.startAngle, 6.115779830751019, 1e-6);
+        assert.inDelta(chords[6].target.endAngle, 6.176003365292097, 1e-6);
+        assert.equal(chords[6].target.value, 990);
+
+        assert.equal(chords[7].source.index, 2);
+        assert.equal(chords[7].source.subindex, 2);
+        assert.inDelta(chords[7].source.startAngle, 4.1152064620038855, 1e-6);
+        assert.inDelta(chords[7].source.endAngle, 4.607336153354714, 1e-6);
+        assert.equal(chords[7].source.value, 8090);
+        assert.equal(chords[7].target.index, 2);
+        assert.equal(chords[7].target.subindex, 2);
+        assert.inDelta(chords[7].target.startAngle, 4.1152064620038855, 1e-6);
+        assert.inDelta(chords[7].target.endAngle, 4.607336153354714, 1e-6);
+        assert.equal(chords[7].target.value, 8090);
+
+        assert.equal(chords[8].source.index, 2);
+        assert.equal(chords[8].source.subindex, 3);
+        assert.inDelta(chords[8].source.startAngle, 4.607336153354714, 1e-6);
+        assert.inDelta(chords[8].source.endAngle, 5.0967284113173115, 1e-6);
+        assert.equal(chords[8].source.value, 8045);
+        assert.equal(chords[8].target.index, 3);
+        assert.equal(chords[8].target.subindex, 2);
+        assert.inDelta(chords[8].target.startAngle, 6.176003365292097, 1e-6);
+        assert.inDelta(chords[8].target.endAngle, 6.233185307179585, 1e-6);
+        assert.equal(chords[8].target.value, 940);
+
+        assert.equal(chords[9].source.index, 3);
+        assert.equal(chords[9].source.subindex, 3);
+        assert.inDelta(chords[9].source.startAngle, 5.633991554422396, 1e-6);
+        assert.inDelta(chords[9].source.endAngle, 6.05415716358929, 1e-6);
+        assert.equal(chords[9].source.value, 6907);
+        assert.equal(chords[9].target.index, 3);
+        assert.equal(chords[9].target.subindex, 3);
+        assert.inDelta(chords[9].target.startAngle, 5.633991554422396, 1e-6);
+        assert.inDelta(chords[9].target.endAngle, 6.05415716358929, 1e-6);
+        assert.equal(chords[9].target.value, 6907);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/layout/cluster-test.js

@@ -0,0 +1,44 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.cluster");
+
+suite.addBatch({
+  "cluster": {
+    topic: load("layout/cluster").expression("d3.layout.cluster"),
+    "can handle an empty children array": function(cluster) {
+      var c = cluster();
+      assert.deepEqual(c.nodes({value: 1, children: [{value: 1, children: []}, {value: 1}]}).map(layout), [
+        {value: 1, depth: 0, x: 0.5,  y: 0},
+        {value: 1, depth: 1, x: 0.25, y: 1},
+        {value: 1, depth: 1, x: 0.75, y: 1}
+      ]);
+    },
+    "can handle zero-valued nodes": function(cluster) {
+      var c = cluster();
+      assert.deepEqual(c.nodes({value: 0, children: [{value: 0}, {value: 1}]}).map(layout), [
+        {value: 0, depth: 0, x: 0.5,  y: 0},
+        {value: 0, depth: 1, x: 0.25, y: 1},
+        {value: 1, depth: 1, x: 0.75, y: 1}
+      ]);
+    },
+    "can handle a single node": function(cluster) {
+      var c = cluster();
+      assert.deepEqual(c.nodes({value: 0}).map(layout), [
+        {value: 0, depth: 0, x: 0.5,  y: 0}
+      ]);
+    }
+  }
+});
+
+function layout(node) {
+  return {
+    value: node.value,
+    depth: node.depth,
+    x: node.x,
+    y: node.y
+  };
+}
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/layout/force-test.js

@@ -0,0 +1,119 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.force");
+
+suite.addBatch({
+  "force": {
+    topic: load("layout/force").expression("d3.layout.force").document(),
+
+    "default instance": {
+      topic: function(force) {
+        return force();
+      },
+
+      "friction": {
+        "defaults to .9": function(f) {
+          assert.equal(f.friction(), .9);
+        },
+        "can be a number": function(f) {
+          f.friction(.5);
+          assert.equal(f.friction(), .5);
+        },
+        "coerces to a number": function(f) {
+          f.friction(".5");
+          assert.strictEqual(f.friction(), .5);
+        }
+      },
+
+      "gravity": {
+        "defaults to .1": function(f) {
+          assert.equal(f.gravity(), .1);
+        },
+        "can be a number": function(f) {
+          f.gravity(.5);
+          assert.equal(f.gravity(), .5);
+        },
+        "coerces to a number": function(f) {
+          f.gravity(".5");
+          assert.strictEqual(f.gravity(), .5);
+        }
+      },
+
+      "theta": {
+        "defaults to .8": function(f) {
+          assert.equal(f.theta(), .8);
+        },
+        "can be a number": function(f) {
+          f.theta(.5);
+          assert.equal(f.theta(), .5);
+        },
+        "coerces to a number": function(f) {
+          f.theta(".5");
+          assert.strictEqual(f.theta(), .5);
+        }
+      },
+
+      "charge": {
+        "defaults to -30": function(f) {
+          assert.equal(f.charge(), -30);
+        },
+        "can be a number": function(f) {
+          f.charge(-40);
+          assert.equal(f.charge(), -40);
+        },
+        "can be a function": function(f) { // TODO expose the computed value?
+          f.charge(foo);
+          assert.equal(f.charge(), foo);
+        },
+        "coerces to a number": function(f) {
+          f.charge("-40");
+          assert.strictEqual(f.charge(), -40);
+        }
+      },
+
+      "linkDistance": {
+        "defaults to 20": function(f) {
+          assert.equal(f.linkDistance(), 20);
+        },
+        "can be a number": function(f) {
+          f.linkDistance(40);
+          assert.equal(f.linkDistance(), 40);
+        },
+        "can be a function": function(f) { // TODO expose the computed value?
+          f.linkDistance(foo);
+          assert.equal(f.linkDistance(), foo);
+        },
+        "coerces to a number": function(f) {
+          f.linkDistance("40");
+          assert.strictEqual(f.linkDistance(), 40);
+        }
+      },
+
+      "linkStrength": {
+        "defaults to 1": function(f) {
+          assert.equal(f.linkStrength(), 1);
+        },
+        "can be a number": function(f) {
+          f.linkStrength(.5);
+          assert.equal(f.linkStrength(), .5);
+        },
+        "can be a function": function(f) { // TODO expose the computed value?
+          f.linkStrength(foo);
+          assert.equal(f.linkStrength(), foo);
+        },
+        "coerces to a number": function(f) {
+          f.linkStrength(".5");
+          assert.strictEqual(f.linkStrength(), .5);
+        }
+      }
+    }
+  }
+});
+
+function foo(d) {
+  return d.foo;
+}
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/layout/hierarchy-test.js

@@ -0,0 +1,27 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.hierarchy");
+
+suite.addBatch({
+  "hierarchy": {
+    topic: load("layout/treemap").expression("d3.layout.treemap"), // hierarchy is abstract, so test a subclass
+    "doesn't overwrite the value of a node that has an empty children array": function(hierarchy) {
+      var h = hierarchy(),
+          nodes = h.sticky(true).nodes({value: 1, children: []});
+      assert.equal(nodes[0].value, 1);
+      h.nodes(nodes[0]);
+      assert.equal(nodes[0].value, 1);
+    },
+    "a valueless node that has an empty children array gets a value of 0": function(hierarchy) {
+      var h = hierarchy(),
+          nodes = h.sticky(true).nodes({children: []});
+      assert.equal(nodes[0].value, 0);
+      h.nodes(nodes[0]);
+      assert.equal(nodes[0].value, 0);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/layout/histogram-test.js

@@ -0,0 +1,92 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.histogram");
+
+suite.addBatch({
+  "histogram": {
+    topic: load("layout/histogram").expression("d3.layout.histogram"),
+    "defaults to frequencies": function(histogram) {
+      var h = histogram();
+      assert.deepEqual(h([0,0,0,1,2,2]).map(elements), [[0, 0, 0], [], [1], [2, 2]]);
+    },
+    "each bin contains the matching source elements": function(histogram) {
+      var h = histogram();
+      assert.deepEqual(h([0,0,0,1,2,2]).map(elements), [[0, 0, 0], [], [1], [2, 2]]);
+    },
+    "each bin also has defined x, y and dx properties": function(histogram) {
+      var h = histogram();
+      assert.deepEqual(h([0,0,0,1,2,2]).map(metadata), [
+        {x:   0, y: 3, dx: 0.5},
+        {x: 0.5, y: 0, dx: 0.5},
+        {x:   1, y: 1, dx: 0.5},
+        {x: 1.5, y: 2, dx: 0.5}
+      ]);
+    },
+    "can output frequencies": function(histogram) {
+      var h = histogram().frequency(true);
+      assert.deepEqual(h([0,0,0,1,2,2]).map(metadata), [
+        {x:   0, y: 3, dx: 0.5},
+        {x: 0.5, y: 0, dx: 0.5},
+        {x:   1, y: 1, dx: 0.5},
+        {x: 1.5, y: 2, dx: 0.5}
+      ]);
+    },
+    "can output probabilities": function(histogram) {
+      var h = histogram().frequency(false);
+      assert.deepEqual(h([0,0,0,1,2,2]).map(metadata), [
+        {x:   0, y: 3/6, dx: 0.5},
+        {x: 0.5, y:   0, dx: 0.5},
+        {x:   1, y: 1/6, dx: 0.5},
+        {x: 1.5, y: 2/6, dx: 0.5}
+      ]);
+    },
+    "can specify number of bins": function(histogram) {
+      var h = histogram().bins(2);
+      assert.deepEqual(h([0,0,0,1,2,2]).map(elements), [
+        [0, 0, 0],
+        [1, 2, 2]
+      ]);
+      assert.deepEqual(h([0,0,0,1,2,2]).map(metadata), [
+        {x: 0, y: 3, dx: 1},
+        {x: 1, y: 3, dx: 1}
+      ]);
+    },
+    "can specify bin thresholds": function(histogram) {
+      var h = histogram().bins([0,1,2,3]);
+      assert.deepEqual(h([0,0,0,1,2,2]).map(elements), [
+        [0, 0, 0],
+        [1],
+        [2, 2]
+      ]);
+      assert.deepEqual(h([0,0,0,1,2,2]).map(metadata), [
+        {x: 0, y: 3, dx: 1},
+        {x: 1, y: 1, dx: 1},
+        {x: 2, y: 2, dx: 1}
+      ]);
+    },
+    "returns the empty array with fewer than two bins": function(histogram) {
+      var h = histogram().bins([1]);
+      assert.deepEqual(h([0]), []);
+      var h = histogram().bins([]);
+      assert.deepEqual(h([0]), []);
+    }
+  }
+});
+
+function elements(bin) {
+  var array = [], i = -1, n = bin.length;
+  while (++i < n) array.push(bin[i]);
+  return array;
+}
+
+function metadata(bin) {
+  var metadata = {};
+  if ("x" in bin) metadata.x = bin.x;
+  if ("y" in bin) metadata.y = bin.y;
+  if ("dx" in bin) metadata.dx = bin.dx;
+  return metadata;
+}
+
+suite.export(module);