bum 0.0.4 → 0.0.12

data/public/d3/test/geo/greatCircle-test.js

@@ -0,0 +1,42 @@
+require("../env");
+require("../../d3");
+require("../../d3.geo");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.greatCircle");
+
+suite.addBatch({
+  "greatCircle": {
+    topic: function() {
+      return d3.geo.greatCircle()
+          .n(12);
+    },
+    "distance": function(circle) {
+      assert.equal(circle.distance({source: [0, 0], target: [0, 0]}), 0);
+      assert.inDelta(circle.distance({
+        source: [118 + 24 / 60, 33 + 57 / 60],
+        target: [ 73 + 47 / 60, 40 + 38 / 60]
+      }), 3973, .5);
+    },
+    "geodesic": function(circle) {
+      assert.inDelta(circle({source: [5, 52], target: [-120, 37]}), [
+        [   5,        52      ],
+        [  -3.805036, 57.05083],
+        [ -15.122869, 61.30118],
+        [ -29.396213, 64.34584],
+        [ -46.132729, 65.72409],
+        [ -63.394401, 65.15597],
+        [ -78.854311, 62.76337],
+        [ -91.401599, 58.96701],
+        [-101.190927, 54.21333],
+        [-108.843633, 48.83586],
+        [-114.961152, 43.05231],
+        [-120,        37      ]
+      ], .5);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/geo/mercator-test.js

@@ -0,0 +1,57 @@
+require("../env");
+require("../../d3");
+require("../../d3.geo");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.mercator");
+
+suite.addBatch({
+  "mercator": {
+    topic: function() {
+      return d3.geo.mercator().translate([0, 0]).scale(100);
+    },
+    "Arctic": function(mercator) {
+      var coords = mercator([0, 85]);
+      assert.inDelta(coords[0], 0, 1e-6);
+      assert.inDelta(coords[1], -49.8362085, 1e-6);
+      var lonlat = mercator.invert(coords);
+      assert.inDelta(lonlat[0], 0, 1e-6);
+      assert.inDelta(lonlat[1], 85, 1e-6);
+    },
+    "Antarctic": function(mercator) {
+      var coords = mercator([0, -85]);
+      assert.inDelta(coords[0], 0, 1e-6);
+      assert.inDelta(coords[1], 49.8362085, 1e-6);
+      var lonlat = mercator.invert(coords);
+      assert.inDelta(lonlat[0], 0, 1e-6);
+      assert.inDelta(lonlat[1], -85, 1e-6);
+    },
+    "Hawaii": function(mercator) {
+      var coords = mercator([-180, 0]);
+      assert.inDelta(coords[0], -50, 1e-6);
+      assert.inDelta(coords[1], 0, 1e-6);
+      var lonlat = mercator.invert(coords);
+      assert.inDelta(lonlat[0], -180, 1e-6);
+      assert.inDelta(lonlat[1], 0, 1e-6);
+    },
+    "Phillipines": function(mercator) {
+      var coords = mercator([180, 0]);
+      assert.inDelta(coords[0], 50, 1e-6);
+      assert.inDelta(coords[1], 0, 1e-6);
+      var lonlat = mercator.invert(coords);
+      assert.inDelta(lonlat[0], 180, 1e-6);
+      assert.inDelta(lonlat[1], 0, 1e-6);
+    },
+    "Inversion works for non-zero translation": function() {
+      var mercator = d3.geo.mercator().translate([123, 99]).scale(100),
+          coords = mercator([0, 85]),
+          lonlat = mercator.invert(coords);
+      assert.inDelta(lonlat[0], 0, 1e-6);
+      assert.inDelta(lonlat[1], 85, 1e-6);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/layout/histogram-test.js

@@ -0,0 +1,91 @@
+require("../env");
+require("../../d3");
+require("../../d3.layout");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.layout.histogram");
+
+suite.addBatch({
+  "histogram": {
+    topic: function() {
+      return 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}
+      ]);
+    }
+  }
+});
+
+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);

data/public/d3/test/layout/partition-test.js

@@ -0,0 +1,39 @@
+require("../env");
+require("../../d3");
+require("../../d3.layout");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.layout.partition");
+
+suite.addBatch({
+  "partition": {
+    topic: function() {
+      return d3.layout.partition;
+    },
+    "ignores zero values": function(partition) {
+      var p = partition().size([3, 3]);
+      assert.deepEqual(p({children: [{value: 1}, {value: 0}, {value: 2}, {children: [{value: 0}, {value: 0}]}]}).map(metadata), [
+        {x: 0, y: 0, dx: 3, dy: 1},
+        {x: 2, y: 1, dx: 1, dy: 1},
+        {x: 3, y: 1, dx: 0, dy: 1},
+        {x: 0, y: 1, dx: 2, dy: 1},
+        {x: 3, y: 1, dx: 0, dy: 1},
+        {x: 3, y: 2, dx: 0, dy: 1},
+        {x: 3, y: 2, dx: 0, dy: 1}
+      ]);
+    }
+  }
+});
+
+function metadata(node) {
+  var metadata = {};
+  if ("x" in node) metadata.x = node.x;
+  if ("y" in node) metadata.y = node.y;
+  if ("dx" in node) metadata.dx = node.dx;
+  if ("dy" in node) metadata.dy = node.dy;
+  return metadata;
+}
+
+suite.export(module);

data/public/d3/test/layout/tree-test.js

@@ -0,0 +1,21 @@
+require("../env");
+require("../../d3");
+require("../../d3.layout");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.layout.tree");
+
+suite.addBatch({
+  "tree": {
+    topic: d3.layout.tree,
+    "can handle an empty children array": function(tree) {
+      assert.deepEqual(tree.nodes({children: []}), [
+        {children: [], depth: 0, x: 0.5, y: 0}
+      ]);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/layout/treemap-test.js

@@ -0,0 +1,180 @@
+require("../env");
+require("../../d3");
+require("../../d3.layout");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.layout.treemap");
+
+suite.addBatch({
+  "treemap": {
+    topic: function() {
+      return d3.layout.treemap;
+    },
+    "outputs a squarified treemap": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 0, y: 833, dx: 1000, dy: 167},
+        {x: 600, y: 0, dx: 400, dy: 833},
+        {x: 0, y: 0, dx: 600, dy: 833},
+        {x: 0, y: 555, dx: 600, dy: 278},
+        {x: 0, y: 0, dx: 600, dy: 555}
+      ]);
+    },
+    "sorts by value by default": function(treemap) {
+      var t = treemap().size([1000, 1000]);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 0, y: 0, dx: 333, dy: 500},
+        {x: 333, y: 0, dx: 667, dy: 500},
+        {x: 0, y: 500, dx: 1000, dy: 500},
+        {x: 0, y: 500, dx: 333, dy: 500},
+        {x: 333, y: 500, dx: 667, dy: 500}
+      ]);
+    },
+    "ignores zero values": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 0}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 0, y: 833, dx: 1000, dy: 167},
+        {x: 1000, y: 0, dx: 0, dy: 833},
+        {x: 600, y: 0, dx: 400, dy: 833},
+        {x: 0, y: 0, dx: 600, dy: 833},
+        {x: 0, y: 555, dx: 600, dy: 278},
+        {x: 0, y: 0, dx: 600, dy: 555}
+      ]);
+    },
+    "ignores NaN values": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: NaN}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 0, y: 833, dx: 1000, dy: 167},
+        {x: 1000, y: 0, dx: 0, dy: 833},
+        {x: 600, y: 0, dx: 400, dy: 833},
+        {x: 0, y: 0, dx: 600, dy: 833},
+        {x: 0, y: 555, dx: 600, dy: 278},
+        {x: 0, y: 0, dx: 600, dy: 555}
+      ]);
+    },
+    "does not overflow empty size": function(treemap) {
+      var t = treemap().size([0, 0]).sort(null);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 0, dy: 0},
+        {x: 0, y: 0, dx: 0, dy: 0},
+        {x: 0, y: 0, dx: 0, dy: 0},
+        {x: 0, y: 0, dx: 0, dy: 0},
+        {x: 0, y: 0, dx: 0, dy: 0},
+        {x: 0, y: 0, dx: 0, dy: 0}
+      ]);
+    },
+    "can specify padding as a number": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null).padding(1);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 1, y: 833, dx: 998, dy: 166},
+        {x: 600, y: 1, dx: 399, dy: 832},
+        {x: 1, y: 1, dx: 599, dy: 832},
+        {x: 2, y: 555, dx: 597, dy: 277},
+        {x: 2, y: 2, dx: 597, dy: 553}
+      ]);
+    },
+    "can specify padding as an array": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null).padding([1,2,3,4]);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 4, y: 831, dx: 994, dy: 166},
+        {x: 600, y: 1, dx: 398, dy: 830},
+        {x: 4, y: 1, dx: 596, dy: 830},
+        {x: 8, y: 553, dx: 590, dy: 275},
+        {x: 8, y: 2, dx: 590, dy: 551}
+      ]);
+    },
+    "can specify padding as null": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null).padding(null);
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 0, y: 833, dx: 1000, dy: 167},
+        {x: 600, y: 0, dx: 400, dy: 833},
+        {x: 0, y: 0, dx: 600, dy: 833},
+        {x: 0, y: 555, dx: 600, dy: 278},
+        {x: 0, y: 0, dx: 600, dy: 555}
+      ]);
+    },
+    "can specify padding as a function that returns a number": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return d.depth; });
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 0, y: 833, dx: 1000, dy: 167},
+        {x: 600, y: 0, dx: 400, dy: 833},
+        {x: 0, y: 0, dx: 600, dy: 833},
+        {x: 1, y: 555, dx: 598, dy: 277},
+        {x: 1, y: 1, dx: 598, dy: 554}
+      ]);
+    },
+    "can specify padding as a function that returns an array": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return [d.depth,2,3,4]; });
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 4, y: 831, dx: 994, dy: 166},
+        {x: 600, y: 0, dx: 398, dy: 831},
+        {x: 4, y: 0, dx: 596, dy: 831},
+        {x: 8, y: 552, dx: 590, dy: 276},
+        {x: 8, y: 1, dx: 590, dy: 551}
+      ]);
+    },
+    "can specify padding as a function that returns null": function(treemap) {
+      var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return d.depth & 1 ? null : 1; });
+      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
+        {x: 0, y: 0, dx: 1000, dy: 1000},
+        {x: 1, y: 833, dx: 998, dy: 166},
+        {x: 600, y: 1, dx: 399, dy: 832},
+        {x: 1, y: 1, dx: 599, dy: 832},
+        {x: 1, y: 556, dx: 599, dy: 277},
+        {x: 1, y: 1, dx: 599, dy: 555}
+      ]);
+    },
+    "no negatively sized rectangles": function(treemap) {
+      var t = treemap().size([615, 500]).sort(function(a, b) { return a.value - b.value; }).padding(29),
+          nodes = t.nodes({"children": [
+            {"value": 1},
+            {"value": 9},
+            {"value": 3},
+            {"value": 15},
+            {"value": 44},
+            {"value": 28},
+            {"value": 32},
+            {"value": 41},
+            {"value": 50},
+            {"value": 60},
+            {"value": 64},
+            {"value": 75},
+            {"value": 76},
+            {"value": 84},
+            {"value": 88},
+            {"value": 100},
+            {"value": 140},
+            {"value": 142},
+            {"value": 363},
+            {"value": 657},
+            {"value": 670},
+            {"value": 822},
+            {"value": 1173},
+            {"value": 1189}
+          ]}).map(layout);
+      assert.equal(nodes.filter(function(n) { return n.dx < 0 || n.dy < 0; }).length, 0);
+    }
+  }
+});
+
+function layout(node) {
+  return {
+    x: node.x,
+    y: node.y,
+    dx: node.dx,
+    dy: node.dy
+  };
+}
+
+suite.export(module);

data/public/d3/test/scale/category-test.js

@@ -0,0 +1,74 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.scale.category");
+
+suite.addBatch({
+  "category10": category(d3.scale.category10, 10),
+  "category20": category(d3.scale.category20, 20),
+  "category20b": category(d3.scale.category20b, 20),
+  "category20c": category(d3.scale.category20c, 20)
+});
+
+function category(category, n) {
+  return {
+    "is an ordinal scale": function() {
+      var x = category(), colors = x.range();
+      assert.length(x.domain(), 0);
+      assert.length(x.range(), n);
+      assert.equal(x(1), colors[0]);
+      assert.equal(x(2), colors[1]);
+      assert.equal(x(1), colors[0]);
+      var y = x.copy();
+      assert.deepEqual(y.domain(), x.domain());
+      assert.deepEqual(y.range(), x.range());
+      x.domain(d3.range(n));
+      for (var i = 0; i < n; ++i) assert.equal(x(i + n), x(i));
+      assert.equal(y(1), colors[0]);
+      assert.equal(y(2), colors[1]);
+    },
+    "each instance is isolated": function() {
+      var a = category(), b = category(), colors = a.range();
+      assert.equal(a(1), colors[0]);
+      assert.equal(b(2), colors[0]);
+      assert.equal(b(1), colors[1]);
+      assert.equal(a(1), colors[0]);
+    },
+    "contains the expected number of values in the range": function() {
+      var x = category();
+      assert.length(x.range(), n);
+    },
+    "each range value is distinct": function() {
+      var map = {}, count = 0, x = category();
+      x.range().forEach(function(v) {
+        if (!(v in map)) {
+          map[v] = ++count;
+        }
+      });
+      assert.equal(count, x.range().length);
+    },
+    "each range value is a hexadecimal color": function() {
+      var x = category();
+      x.range().forEach(function(v) {
+        assert.match(v, /#[0-9a-f]{6}/);
+        v = d3.rgb(v);
+        assert.isFalse(isNaN(v.r));
+        assert.isFalse(isNaN(v.g));
+        assert.isFalse(isNaN(v.b));
+      });
+    },
+    "no range values are very dark or very light": function() {
+      var x = category();
+      x.range().forEach(function(v) {
+        var c = d3.hsl(v);
+        assert.isTrue(c.l >= .34, "expected " + v + " to be lighter (l = " + c.l + ")");
+        assert.isTrue(c.l <= .89, "expected " + v + " to be darker (l = " + c.l + ")");
+      });
+    }
+  };
+}
+
+suite.export(module);