bum 0.0.4 → 0.0.12

data/public/d3/test/core/functor-test.js

@@ -0,0 +1,29 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.functor");
+
+suite.addBatch({
+  "functor": {
+    topic: function() {
+      return d3.functor;
+    },
+    "when passed a function, returns the function": function(functor) {
+      function foo() {}
+      assert.strictEqual(functor(foo), foo);
+    },
+    "when passed a non-function, returns a wrapper function": function(functor) {
+      var a = {};
+      assert.isNull(functor(null)());
+      assert.isUndefined(functor(undefined)());
+      assert.strictEqual(functor(a)(), a);
+      assert.strictEqual(functor(1)(), 1);
+      assert.deepEqual(functor([1])(), [1]);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/hsl-test.js

@@ -0,0 +1,87 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.hsl");
+
+suite.addBatch({
+  "hsl": {
+    topic: function() {
+      return d3.hsl;
+    },
+    "does not clamp channel values": function(hsl) {
+      assert.hslEqual(hsl(-100, -1, -2), -100, -1, -2);
+      assert.hslEqual(hsl(400, 2, 3), 400, 2, 3);
+    },
+    "converts string channel values to numbers": function(hsl) {
+      assert.hslEqual(hsl("180", ".5", ".6"), 180, .5, .6);
+    },
+    "converts null channel values to zero": function(hsl) {
+      assert.hslEqual(hsl(null, null, null), 0, 0, 0);
+    },
+    "exposes h, s and l properties": function(hsl) {
+      var color = hsl("hsl(180, 50%, 60%)");
+      assert.equal(color.h, 180);
+      assert.equal(color.s, .5);
+      assert.equal(color.l, .6);
+    },
+    "changing h, s or l affects the string format": function(hsl) {
+      var color = hsl("hsl(180, 50%, 60%)");
+      color.h++;
+      color.s += .1;
+      color.l += .1;
+      assert.equal(color + "", "hsl(181,60%,70%)");
+    },
+    "parses hexadecimal shorthand format (e.g., \"#abc\")": function(hsl) {
+      assert.hslEqual(hsl("#abc"), 210, .25, .733333);
+    },
+    "parses hexadecimal format (e.g., \"#abcdef\")": function(hsl) {
+      assert.hslEqual(hsl("#abcdef"), 210, .68, .803922);
+    },
+    "parses HSL format (e.g., \"hsl(210, 64%, 13%)\")": function(hsl) {
+      assert.hslEqual(hsl("hsl(210, 64.7058%, 13.33333%)"), 210, .647058, .133333);
+    },
+    "parses color names (e.g., \"moccasin\")": function(hsl) {
+      assert.hslEqual(hsl("moccasin"), 38.108108, 1, .854902);
+      assert.hslEqual(hsl("aliceblue"), 208, 1, .970588);
+      assert.hslEqual(hsl("yellow"), 60, 1, .5);
+    },
+    "parses and converts RGB format (e.g., \"rgb(102, 102, 0)\")": function(hsl) {
+      assert.hslEqual(hsl("rgb(102, 102, 0)"), 60, 1, .2);
+    },
+    "can convert from RGB": function(hsl) {
+      assert.hslEqual(hsl(d3.rgb(12, 34, 56)), 210, .647058, .133333);
+    },
+    "can convert from HSL": function(hsl) {
+      assert.hslEqual(hsl(d3.hsl(20, .8, .3)), 20, .8, .3);
+    },
+    "can convert to RGB": function(hsl) {
+      assert.rgbEqual(hsl("steelblue").rgb(), 70, 130, 180);
+    },
+    "can derive a brighter color": function(hsl) {
+      assert.hslEqual(hsl("steelblue").brighter(), 207.272727, .44, .7002801);
+      assert.hslEqual(hsl("steelblue").brighter(.5), 207.272727, .44, .5858964);
+      assert.hslEqual(hsl("steelblue").brighter(1), 207.272727, .44, .7002801);
+      assert.hslEqual(hsl("steelblue").brighter(2), 207.272727, .44, 1.0004002);
+    },
+    "can derive a darker color": function(hsl) {
+      assert.hslEqual(hsl("lightsteelblue").darker(), 213.913043, .4107143, .5462745);
+      assert.hslEqual(hsl("lightsteelblue").darker(.5), 213.913043, .4107143, .6529229);
+      assert.hslEqual(hsl("lightsteelblue").darker(1), 213.913043, .4107143, .5462745);
+      assert.hslEqual(hsl("lightsteelblue").darker(2), 213.913043, .4107143, .38239216);
+    },
+    "string coercion returns HSL format": function(hsl) {
+      var re = /^hsl\([0-9]+(.[0-9]+)?,[0-9.]+%,[0-9.]+%\)$/;
+      assert.match(hsl("#abcdef"), re);
+      assert.match(hsl("moccasin"), re);
+      assert.strictEqual(hsl("hsl(60, 100%, 20%)") + "", "hsl(60,100%,20%)");
+      assert.match(hsl("rgb(12, 34, 56))"), re);
+      assert.match(hsl(d3.rgb(12, 34, 56)), re);
+      assert.strictEqual(hsl(d3.hsl(60, 1, .2)) + "", "hsl(60,100%,20%)");
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/html-test.js

@@ -0,0 +1,37 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.html");
+
+suite.addBatch({
+  "html": {
+    topic: function() {
+      var cb = this.callback;
+      return d3.html("examples/data/sample.html", function(document) {
+        cb(null, document);
+      });
+    },
+    "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(xml) {
+      assert.equal(XMLHttpRequest._last._info.mimeType, "text/html");
+    },
+    "": {
+      topic: function() {
+        var cb = this.callback;
+        return d3.html("//does/not/exist.html", function(document) {
+          cb(null, document);
+        });
+      },
+      "invokes the callback with null when an error occurs": function(document) {
+        assert.isNull(document);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/interpolate-test.js

@@ -0,0 +1,203 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.interpolate");
+
+suite.addBatch({
+  "interpolate": {
+    topic: function() {
+      return d3.interpolate;
+    },
+    "interpolates numbers": function(interpolate) {
+      assert.equal(interpolate(2, 12)(.4), 6);
+    },
+    "interpolates colors": function(interpolate) {
+      assert.equal(interpolate("#abcdef", "#fedcba")(.4), "rgb(204,211,218)");
+    },
+    "interpolates strings": function(interpolate) {
+      assert.equal(interpolate("width:10px;", "width:50px;")(.2), "width:18px;");
+    },
+    "interpolates arrays": function(interpolate) {
+      assert.deepEqual(interpolate([2, 4], [12, 24])(.4), [6, 12]);
+    },
+    "interpolates objects": function(interpolate) {
+      assert.deepEqual(interpolate({foo: 2}, {foo: 12})(.4), {foo: 6});
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolateNumber": {
+    topic: function() {
+      return d3.interpolateNumber;
+    },
+    "interpolates numbers": function(interpolate) {
+      assert.equal(interpolate(2, 12)(.4), 6);
+      assert.equal(interpolate(2, 12)(.6), 8);
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolateRound": {
+    topic: function() {
+      return d3.interpolateRound;
+    },
+    "interpolates integers": function(interpolate) {
+      assert.equal(interpolate(2, 12)(.456), 7);
+      assert.equal(interpolate(2, 12)(.678), 9);
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolateString": {
+    topic: function() {
+      return d3.interpolateString;
+    },
+    "interpolates matching numbers in both strings": function(interpolate) {
+      assert.equal(interpolate(" 10/20 30", "50/10 100 ")(.2), "18/18 44 ");
+      assert.equal(interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 ");
+    },
+    "preserves non-numbers in string b": function(interpolate) {
+      assert.equal(interpolate(" 10/20 30", "50/10 foo ")(.2), "18/18 foo ");
+      assert.equal(interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo ");
+    },
+    "preserves non-matching numbers in string b": function(interpolate) {
+      assert.equal(interpolate(" 10/20 foo", "50/10 100 ")(.2), "18/18 100 ");
+      assert.equal(interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 ");
+    },
+    "preserves equal-value numbers in both strings": function(interpolate) {
+      assert.equal(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.2), "18/18 100, 20 ");
+      assert.equal(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 ");
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolateRgb": {
+    topic: function() {
+      return d3.interpolateRgb;
+    },
+    "parses string input": function(interpolate) {
+      assert.equal(interpolate("steelblue", "#f00")(.2), "rgb(107,104,144)");
+      assert.equal(interpolate("steelblue", "#f00")(.6), "rgb(181,52,72)");
+    },
+    "parses d3.rgb input": function(interpolate) {
+      assert.equal(interpolate(d3.rgb("steelblue"), "#f00")(.2), "rgb(107,104,144)");
+      assert.equal(interpolate("steelblue", d3.rgb(255, 0, 0))(.6), "rgb(181,52,72)");
+    },
+    "parses d3.hsl input": function(interpolate) {
+      assert.equal(interpolate(d3.hsl("steelblue"), "#f00")(.2), "rgb(107,104,144)");
+      assert.equal(interpolate("steelblue", d3.hsl(0, 1, .5))(.6), "rgb(181,52,72)");
+    },
+    "interpolates in RGB color space": function(interpolate) {
+      assert.equal(interpolate("steelblue", "#f00")(.2), "rgb(107,104,144)");
+    },
+    "outputs an RGB string": function(interpolate) {
+      assert.equal(interpolate("steelblue", "#f00")(.2), "rgb(107,104,144)");
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolateHsl": {
+    topic: function() {
+      return d3.interpolateHsl;
+    },
+    "parses string input": function(interpolate) {
+      assert.equal(interpolate("steelblue", "#f00")(.2), "#38c3a2");
+      assert.equal(interpolate("steelblue", "#f00")(.6), "#96e11c");
+    },
+    "parses d3.hsl input": function(interpolate) {
+      assert.equal(interpolate(d3.hsl("steelblue"), "#f00")(.2), "#38c3a2");
+      assert.equal(interpolate("steelblue", d3.hsl(0, 1, .5))(.6), "#96e11c");
+    },
+    "parses d3.rgb input": function(interpolate) {
+      assert.equal(interpolate(d3.rgb("steelblue"), "#f00")(.2), "#38c3a2");
+      assert.equal(interpolate("steelblue", d3.rgb(255, 0, 0))(.6), "#96e11c");
+    },
+    "interpolates in HSL color space": function(interpolate) {
+      assert.equal(interpolate("steelblue", "#f00")(.2), "#38c3a2");
+    },
+    "outputs a hexadecimal string": function(interpolate) {
+      assert.equal(interpolate("steelblue", "#f00")(.2), "#38c3a2");
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolateArray": {
+    topic: function() {
+      return d3.interpolateArray;
+    },
+    "interpolates defined elements": function(interpolate) {
+      assert.deepEqual(interpolate([2, 12], [4, 24])(.5), [3, 18]);
+    },
+    "interpolates nested objects and arrays": function(interpolate) {
+      assert.deepEqual(interpolate([[2, 12]], [[4, 24]])(.5), [[3, 18]]);
+      assert.deepEqual(interpolate([{foo: [2, 12]}], [{foo: [4, 24]}])(.5), [{foo: [3, 18]}]);
+    },
+    "merges non-shared elements": function(interpolate) {
+      assert.deepEqual(interpolate([2, 12], [4, 24, 12])(.5), [3, 18, 12]);
+      assert.deepEqual(interpolate([2, 12, 12], [4, 24])(.5), [3, 18, 12]);
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolateObject": {
+    topic: function() {
+      return d3.interpolateObject;
+    },
+    "interpolates defined properties": function(interpolate) {
+      assert.deepEqual(interpolate({a: 2, b: 12}, {a: 4, b: 24})(.5), {a: 3, b: 18});
+    },
+    "interpolates inherited properties": function(interpolate) {
+      function a(a) { this.a = a; }
+      a.prototype.b = 12;
+      assert.deepEqual(interpolate(new a(2), new a(4))(.5), {a: 3, b: 12});
+    },
+    "interpolates color properties as rgb": function(interpolate) {
+      assert.deepEqual(interpolate({background: "red"}, {background: "green"})(.5), {background: "rgb(128,64,0)"});
+      assert.deepEqual(interpolate({fill: "red"}, {fill: "green"})(.5), {fill: "rgb(128,64,0)"});
+      assert.deepEqual(interpolate({stroke: "red"}, {stroke: "green"})(.5), {stroke: "rgb(128,64,0)"});
+      assert.deepEqual(interpolate({color: "red"}, {color: "green"})(.5), {color: "rgb(128,64,0)"});
+    },
+    "interpolates nested objects and arrays": function(interpolate) {
+      assert.deepEqual(interpolate({foo: [2, 12]}, {foo: [4, 24]})(.5), {foo: [3, 18]});
+      assert.deepEqual(interpolate({foo: {bar: [2, 12]}}, {foo: {bar: [4, 24]}})(.5), {foo: {bar: [3, 18]}});
+    },
+    "merges non-shared properties": function(interpolate) {
+      assert.deepEqual(interpolate({foo: 2}, {foo: 4, bar: 12})(.5), {foo: 3, bar: 12});
+      assert.deepEqual(interpolate({foo: 2, bar: 12}, {foo: 4})(.5), {foo: 3, bar: 12});
+    }
+  }
+});
+
+suite.addBatch({
+  "interpolators": {
+    topic: function() {
+      return d3.interpolate;
+    },
+    "can register a custom interpolator": function(interpolate) {
+      try {
+        d3.interpolators.push(function(a, b) {
+          return a == "one" && b == "two" && d3.interpolateNumber(1, 2);
+        });
+        assert.equal(interpolate("one", "two")(-.5), .5);
+        assert.equal(interpolate("one", "two")(0), 1);
+        assert.equal(interpolate("one", "two")(.5), 1.5);
+        assert.equal(interpolate("one", "two")(1), 2);
+        assert.equal(interpolate("one", "two")(1.5), 2.5);
+      } finally {
+        d3.interpolators.pop();
+      }
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/json-test.js

@@ -0,0 +1,37 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.json");
+
+suite.addBatch({
+  "json": {
+    topic: function() {
+      var cb = this.callback;
+      return d3.json("examples/data/sample.json", function(json) {
+        cb(null, json);
+      });
+    },
+    "invokes the callback with the loaded JSON": function(json) {
+      assert.deepEqual(json, [{"Hello":42,"World":"\"fish\""}]);
+    },
+    "overrides the mime type to application/json": function(json) {
+      assert.equal(XMLHttpRequest._last._info.mimeType, "application/json");
+    },
+    "": {
+      topic: function() {
+        var cb = this.callback;
+        return d3.json("//does/not/exist.json", function(json) {
+          cb(null, json);
+        });
+      },
+      "invokes the callback with null when an error occurs": function(json) {
+        assert.isNull(json);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/keys-test.js

@@ -0,0 +1,31 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.keys");
+
+suite.addBatch({
+  "keys": {
+    topic: function() {
+      return d3.keys;
+    },
+    "enumerates every defined key": function(keys) {
+      assert.deepEqual(keys({a: 1, b: 1}), ["a", "b"]);
+    },
+    "includes keys defined on prototypes": function(keys) {
+      function abc() {
+        this.a = 1;
+        this.b = 2;
+      }
+      abc.prototype.c = 3;
+      assert.deepEqual(keys(new abc()), ["a", "b", "c"]);
+    },
+    "includes keys with null or undefined values": function(keys) {
+      assert.deepEqual(keys({a: undefined, b: null, c: NaN}), ["a", "b", "c"]);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/last-test.js

@@ -0,0 +1,42 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.last");
+
+suite.addBatch({
+  "last": {
+    topic: function() {
+      return d3.last;
+    },
+    "compares using natural order by default": function(last) {
+      assert.strictEqual(last([1, 0]), 1);
+      assert.strictEqual(last(["1", 0]), "1");
+      assert.strictEqual(last(["2", "10"]), "2");
+      assert.strictEqual(last(["2", NaN, "10"]), "2");
+      assert.strictEqual(last([2, NaN, 10]), 10);
+    },
+    "compares using optional comparator": function(last) {
+      var i = 0, aa, bb, o = new Object();
+      assert.strictEqual(last([1, o], function(a, b) { aa = a; bb = b; return ++i; }), 1);
+      assert.strictEqual(aa, 1);
+      assert.strictEqual(bb, o);
+      assert.strictEqual(last([1, 0], d3.descending), 0);
+      assert.strictEqual(last(["1", 0], d3.descending), 0);
+      assert.strictEqual(last(["2", "10"], d3.descending), "10");
+      assert.strictEqual(last(["2", NaN, "10"], d3.descending), "10");
+      assert.strictEqual(last([2, NaN, 10], d3.descending), 2);
+    },
+    "returns the last of equal values": function(last) {
+      var a = new Object(), b = new Object(), c = new Object();
+      assert.strictEqual(last([a, b, c], function() { return 0; }), c);
+    },
+    "returns undefined for an empty array": function(last) {
+      assert.isUndefined(last([]));
+    }
+  }
+});
+
+suite.export(module);