bum 0.0.4 → 0.0.12

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

@@ -0,0 +1,47 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.descending");
+
+suite.addBatch({
+  "numbers": {
+    "returns a negative number if a > b": function() {
+      assert.isTrue(d3.descending(1, 0) < 0);
+    },
+    "returns a positive number if a < b": function() {
+      assert.isTrue(d3.descending(0, 1) > 0);
+    },
+    "returns zero if a == b": function() {
+      assert.equal(d3.descending(0, 0), 0);
+    },
+    "returns NaN if a or b is undefined": function() {
+      assert.isNaN(d3.descending(0, undefined));
+      assert.isNaN(d3.descending(undefined, 0));
+      assert.isNaN(d3.descending(undefined, undefined));
+    },
+    "returns NaN if a or b is NaN": function() {
+      assert.isNaN(d3.descending(0, NaN));
+      assert.isNaN(d3.descending(NaN, 0));
+      assert.isNaN(d3.descending(NaN, NaN));
+    }
+  }
+});
+
+suite.addBatch({
+  "strings": {
+    "returns a negative number if a > b": function() {
+      assert.isTrue(d3.descending("b", "a") < 0);
+    },
+    "returns a positive number if a < b": function() {
+      assert.isTrue(d3.descending("a", "b") > 0);
+    },
+    "returns zero if a == b": function() {
+      assert.equal(d3.descending("a", "a"), 0);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,116 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.dispatch");
+
+suite.addBatch({
+  "dispatch": {
+    topic: function() {
+      return d3.dispatch;
+    },
+    "returns a map of dispatchers for each event type": function(dispatch) {
+      assert.deepEqual(dispatch(), {});
+      var d = dispatch("foo");
+      assert.isTrue("foo" in d);
+      assert.isFalse("bar" in d);
+      var d = dispatch("foo", "bar");
+      assert.isTrue("foo" in d);
+      assert.isTrue("bar" in d);
+    },
+    "added listeners receive subsequent events": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      d.foo.add(function() { ++events; });
+      d.foo.dispatch();
+      assert.equal(events, 1);
+      d.foo.dispatch();
+      d.foo.dispatch();
+      assert.equal(events, 3);
+    },
+    "the listener is passed any arguments to dispatch": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, aa, bb;
+      d.foo.add(function(a, b) { aa = a; bb = b; });
+      d.foo.dispatch(a, b);
+      assert.equal(aa, a);
+      assert.equal(bb, b);
+      d.foo.dispatch(1, "foo");
+      assert.equal(aa, 1);
+      assert.equal(bb, "foo");
+    },
+    "the listener's context is the same as dispatch's": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, that;
+      d.foo.add(function() { that = this; });
+      d.foo.dispatch.call(a);
+      assert.equal(that, a);
+      d.foo.dispatch.call(b);
+      assert.equal(that, b);
+    },
+    "listeners are notified in the order they are first added": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { those.push(a); }
+      function B() { those.push(b); }
+      d.foo.add(A);
+      d.foo.add(B);
+      d.foo.dispatch();
+      assert.deepEqual(those, [a, b]);
+      those = [];
+      d.foo.remove(A);
+      d.foo.add(A);
+      d.foo.dispatch();
+      assert.deepEqual(those, [a, b]);
+    },
+    "removed listeners do not receive subsequent events": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { those.push(a); }
+      function B() { those.push(b); }
+      d.foo.add(A);
+      d.foo.add(B);
+      d.foo.dispatch();
+      those = [];
+      d.foo.remove(A);
+      d.foo.dispatch();
+      assert.deepEqual(those, [b]);
+    },
+    "adding an existing listener has no effect": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      function A() { ++events; }
+      d.foo.add(A);
+      d.foo.dispatch();
+      d.foo.add(A);
+      d.foo.add(A);
+      d.foo.dispatch();
+      assert.equal(events, 2);
+    },
+    "removing a missing listener has no effect": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      function A() { ++events; }
+      d.foo.remove(A);
+      d.foo.add(A);
+      d.foo.remove(A);
+      d.foo.remove(A);
+      d.foo.dispatch();
+      assert.equal(events, 0);
+    },
+    "adding a listener does not affect the current event": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { d.foo.add(B); those.push(a); }
+      function B() { those.push(b); }
+      d.foo.add(A);
+      d.foo.dispatch();
+      assert.deepEqual(those, [a]);
+    },
+    "removing a listener does affect the current event": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { d.foo.remove(B); those.push(a); }
+      function B() { those.push(b); }
+      d.foo.add(A);
+      d.foo.add(B);
+      d.foo.dispatch();
+      assert.deepEqual(those, [a]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,129 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.ease");
+
+suite.addBatch({
+  "ease": {
+    topic: function() {
+      return d3.ease;
+    },
+    "supports linear easing": function(ease) {
+      var e = ease("linear");
+      assert.inDelta(e(.5), .5, 1e-6);
+    },
+    "supports polynomial easing": function(ease) {
+      var e = ease("poly", 2);
+      assert.inDelta(e(.5), .25, 1e-6);
+    },
+    "supports quadratic easing": function(ease) {
+      var e = ease("quad");
+      assert.inDelta(e(.5), .25, 1e-6);
+    },
+    "supports cubic easing": function(ease) {
+      var e = ease("cubic");
+      assert.inDelta(e(.5), .125, 1e-6);
+    },
+    "supports sinusoidal easing": function(ease) {
+      var e = ease("sin");
+      assert.inDelta(e(.5), 1 - Math.cos(Math.PI / 4), 1e-6);
+    },
+    "supports exponential easing": function(ease) {
+      var e = ease("exp");
+      assert.inDelta(e(.5), 0.03125, 1e-6);
+    },
+    "supports circular easing": function(ease) {
+      var e = ease("circle");
+      assert.inDelta(e(.5), 0.133975, 1e-6);
+    },
+    "supports elastic easing": function(ease) {
+      var e = ease("elastic");
+      assert.inDelta(e(.5), 0.976061, 1e-6);
+    },
+    "supports back easing": function(ease) {
+      var e = ease("back");
+      assert.inDelta(e(.5), -0.0876975, 1e-6);
+    },
+    "supports bounce easing": function(ease) {
+      var e = ease("bounce");
+      assert.inDelta(e(.5), 0.765625, 1e-6);
+    },
+    "all easing functions return exactly 0 for t = 0": function(ease) {
+      assert.equal(ease("linear")(0), 0);
+      assert.equal(ease("poly", 2)(0), 0);
+      assert.equal(ease("quad")(0), 0);
+      assert.equal(ease("cubic")(0), 0);
+      assert.equal(ease("sin")(0), 0);
+      assert.equal(ease("exp")(0), 0);
+      assert.equal(ease("circle")(0), 0);
+      assert.equal(ease("elastic")(0), 0);
+      assert.equal(ease("back")(0), 0);
+      assert.equal(ease("bounce")(0), 0);
+    },
+    "all easing functions return exactly 1 for t = 1": function(ease) {
+      assert.equal(ease("linear")(1), 1);
+      assert.equal(ease("poly", 2)(1), 1);
+      assert.equal(ease("quad")(1), 1);
+      assert.equal(ease("cubic")(1), 1);
+      assert.equal(ease("sin")(1), 1);
+      assert.equal(ease("exp")(1), 1);
+      assert.equal(ease("circle")(1), 1);
+      assert.equal(ease("elastic")(1), 1);
+      assert.equal(ease("back")(1), 1);
+      assert.equal(ease("bounce")(1), 1);
+    },
+    "the -in suffix returns the identity": function(ease) {
+      assert.inDelta(ease("linear-in")(.25), ease("linear")(.25), 1e-6);
+      assert.inDelta(ease("quad-in")(.75), ease("quad")(.75), 1e-6);
+    },
+    "the -out suffix returns the reverse": function(ease) {
+      assert.inDelta(ease("sin-out")(.25), 1 - ease("sin-in")(.75), 1e-6);
+      assert.inDelta(ease("bounce-out")(.25), 1 - ease("bounce-in")(.75), 1e-6);
+      assert.inDelta(ease("elastic-out")(.25), 1 - ease("elastic-in")(.75), 1e-6);
+    },
+    "the -in-out suffix returns the reflection": function(ease) {
+      assert.inDelta(ease("sin-in-out")(.25), .5 * ease("sin-in")(.5), 1e-6);
+      assert.inDelta(ease("bounce-in-out")(.25), .5 * ease("bounce-in")(.5), 1e-6);
+      assert.inDelta(ease("elastic-in-out")(.25), .5 * ease("elastic-in")(.5), 1e-6);
+    },
+    "the -out-in suffix returns the reverse reflection": function(ease) {
+      assert.inDelta(ease("sin-out-in")(.25), .5 * ease("sin-out")(.5), 1e-6);
+      assert.inDelta(ease("bounce-out-in")(.25), .5 * ease("bounce-out")(.5), 1e-6);
+      assert.inDelta(ease("elastic-out-in")(.25), .5 * ease("elastic-out")(.5), 1e-6);
+    },
+    "clamps input time": function(ease) {
+      var e = ease("linear");
+      assert.inDelta(e(-1), 0, 1e-6);
+      assert.inDelta(e(2), 1, 1e-6);
+    },
+    "poly": {
+      "supports an optional polynomial": function(ease) {
+        var e = ease("poly", 1);
+        assert.inDelta(e(.5), .5, 1e-6);
+        var e = ease("poly", .5);
+        assert.inDelta(e(.5), Math.SQRT1_2, 1e-6);
+      }
+    },
+    "elastic": {
+      "supports an optional amplifier (>1)": function(ease) {
+        var e = ease("elastic", 1.5);
+        assert.inDelta(e(.5), 0.998519, 1e-6);
+      },
+      "supports an optional amplifier (>1) and period (>0)": function(ease) {
+        var e = ease("elastic", 1.5, .5);
+        assert.inDelta(e(.5), 0.96875, 1e-6);
+      }
+    },
+    "back": {
+      "supports an optional speed": function(ease) {
+        var e = ease("back", 2);
+        assert.inDelta(e(.5), -0.125, 1e-6);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

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

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

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

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

@@ -0,0 +1,204 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.format");
+
+suite.addBatch({
+  "format": {
+    topic: function() {
+      return d3.format;
+    },
+    "returns a string": function(format) {
+      assert.isString(format("d")(0));
+    },
+    "can zero fill": function(format) {
+      var f = format("08d");
+      assert.strictEqual(f(0), "00000000");
+      assert.strictEqual(f(42), "00000042");
+      assert.strictEqual(f(42000000), "42000000");
+      assert.strictEqual(f(420000000), "420000000");
+      assert.strictEqual(f(-4), "−0000004");
+      assert.strictEqual(f(-42), "−0000042");
+      assert.strictEqual(f(-4200000), "−4200000");
+      assert.strictEqual(f(-42000000), "−42000000");
+    },
+    "can space fill": function(format) {
+      var f = format("8d");
+      assert.strictEqual(f(0), "       0");
+      assert.strictEqual(f(42), "      42");
+      assert.strictEqual(f(42000000), "42000000");
+      assert.strictEqual(f(420000000), "420000000");
+      assert.strictEqual(f(-4), "      −4");
+      assert.strictEqual(f(-42), "     −42");
+      assert.strictEqual(f(-4200000), "−4200000");
+      assert.strictEqual(f(-42000000), "−42000000");
+    },
+    "can output fixed-point notation": function(format) {
+      assert.strictEqual(format(".1f")(0.49), "0.5");
+      assert.strictEqual(format(".2f")(0.449), "0.45");
+      assert.strictEqual(format(".3f")(0.4449), "0.445");
+      assert.strictEqual(format(".5f")(0.444449), "0.44445");
+      assert.strictEqual(format(".1f")(100), "100.0");
+      assert.strictEqual(format(".2f")(100), "100.00");
+      assert.strictEqual(format(".3f")(100), "100.000");
+      assert.strictEqual(format(".5f")(100), "100.00000");
+    },
+    "can output general notation": function(format) {
+      assert.strictEqual(format(".1g")(0.049), "0.05");
+      assert.strictEqual(format(".1g")(0.49), "0.5");
+      assert.strictEqual(format(".2g")(0.449), "0.45");
+      assert.strictEqual(format(".3g")(0.4449), "0.445");
+      assert.strictEqual(format(".5g")(0.444449), "0.44445");
+      assert.strictEqual(format(".1g")(100), "1e+2");
+      assert.strictEqual(format(".2g")(100), "1.0e+2");
+      assert.strictEqual(format(".3g")(100), "100");
+      assert.strictEqual(format(".5g")(100), "100.00");
+      assert.strictEqual(format(".5g")(100.2), "100.20");
+      assert.strictEqual(format(".2g")(0.002), "0.0020");
+    },
+    "can output exponent notation ": function(format) {
+      var f = format("e");
+      assert.strictEqual(f(0), "0e+0");
+      assert.strictEqual(f(42), "4.2e+1");
+      assert.strictEqual(f(42000000), "4.2e+7");
+      assert.strictEqual(f(420000000), "4.2e+8");
+      assert.strictEqual(f(-4), "−4e+0");
+      assert.strictEqual(f(-42), "−4.2e+1");
+      assert.strictEqual(f(-4200000), "−4.2e+6");
+      assert.strictEqual(f(-42000000), "−4.2e+7");
+    },
+    "can output a percentage": function(format) {
+      var f = format("%");
+      assert.strictEqual(f(0), "0%");
+      assert.strictEqual(f(.042), "4%");
+      assert.strictEqual(f(.42), "42%");
+      assert.strictEqual(f(4.2), "420%");
+      assert.strictEqual(f(-.042), "−4%");
+      assert.strictEqual(f(-.42), "−42%");
+      assert.strictEqual(f(-4.2), "−420%");
+    },
+    "can output a percentage with rounding and sign": function(format) {
+      var f = format("+.2p");
+      assert.strictEqual(f(.00123), "+0.12%");
+      assert.strictEqual(f(.0123), "+1.2%");
+      assert.strictEqual(f(.123), "+12%");
+      assert.strictEqual(f(1.23), "+120%");
+      assert.strictEqual(f(-.00123), "−0.12%");
+      assert.strictEqual(f(-.0123), "−1.2%");
+      assert.strictEqual(f(-.123), "−12%");
+      assert.strictEqual(f(-1.23), "−120%");
+    },
+    "can round to significant digits": function(format) {
+      assert.strictEqual(format(".1r")(0.049), "0.05");
+      assert.strictEqual(format(".1r")(0.49), "0.5");
+      assert.strictEqual(format(".2r")(0.449), "0.45");
+      assert.strictEqual(format(".3r")(0.4449), "0.445");
+      assert.strictEqual(format(".5r")(0.444449), "0.44445");
+      assert.strictEqual(format("r")(123.45), "123");
+      assert.strictEqual(format(".1r")(123.45), "100");
+      assert.strictEqual(format(".2r")(123.45), "120");
+      assert.strictEqual(format(".3r")(123.45), "123");
+      assert.strictEqual(format(".4r")(123.45), "123.5");
+      assert.strictEqual(format(".5r")(123.45), "123.45");
+      assert.strictEqual(format(".6r")(123.45), "123.450");
+    },
+    "can round very small numbers": function(format) {
+      var f = format(".2r");
+      assert.strictEqual(f(1e-22), "0.00000000000000000000");
+    },
+    "can group thousands": function(format) {
+      var f = format(",d");
+      assert.strictEqual(f(0), "0");
+      assert.strictEqual(f(42), "42");
+      assert.strictEqual(f(42000000), "42,000,000");
+      assert.strictEqual(f(420000000), "420,000,000");
+      assert.strictEqual(f(-4), "−4");
+      assert.strictEqual(f(-42), "−42");
+      assert.strictEqual(f(-4200000), "−4,200,000");
+      assert.strictEqual(f(-42000000), "−42,000,000");
+    },
+    "can group thousands and zero fill": function(format) {
+      assert.strictEqual(format("01,d")(0), "0");
+      assert.strictEqual(format("01,d")(0), "0");
+      assert.strictEqual(format("02,d")(0), "00");
+      assert.strictEqual(format("03,d")(0), "000");
+      assert.strictEqual(format("05,d")(0), "0,000");
+      assert.strictEqual(format("08,d")(0), "0,000,000");
+      assert.strictEqual(format("013,d")(0), "0,000,000,000");
+      assert.strictEqual(format("021,d")(0), "0,000,000,000,000,000");
+    },
+    "can group thousands and zero fill with overflow": function(format) {
+      assert.strictEqual(format("01,d")(1), "1");
+      assert.strictEqual(format("01,d")(1), "1");
+      assert.strictEqual(format("02,d")(12), "12");
+      assert.strictEqual(format("03,d")(123), "123");
+      assert.strictEqual(format("05,d")(12345), "12,345");
+      assert.strictEqual(format("08,d")(12345678), "12,345,678");
+      assert.strictEqual(format("013,d")(1234567890123), "1,234,567,890,123");
+    },
+    "can group thousands and space fill": function(format) {
+      assert.strictEqual(format("1,d")(0), "0");
+      assert.strictEqual(format("1,d")(0), "0");
+      assert.strictEqual(format("2,d")(0), " 0");
+      assert.strictEqual(format("3,d")(0), "  0");
+      assert.strictEqual(format("5,d")(0), "    0");
+      assert.strictEqual(format("8,d")(0), "       0");
+      assert.strictEqual(format("13,d")(0), "            0");
+      assert.strictEqual(format("21,d")(0), "                    0");
+    },
+    "can group thousands and space fill with overflow": function(format) {
+      assert.strictEqual(format("1,d")(1), "1");
+      assert.strictEqual(format("1,d")(1), "1");
+      assert.strictEqual(format("2,d")(12), "12");
+      assert.strictEqual(format("3,d")(123), "123");
+      assert.strictEqual(format("5,d")(12345), "12,345");
+      assert.strictEqual(format("8,d")(12345678), "12,345,678");
+      assert.strictEqual(format("13,d")(1234567890123), "1,234,567,890,123");
+    },
+    "can group thousands with general notation": function(format) {
+      var f = format(",g");
+      assert.strictEqual(f(0), "0");
+      assert.strictEqual(f(42), "42");
+      assert.strictEqual(f(42000000), "42,000,000");
+      assert.strictEqual(f(420000000), "420,000,000");
+      assert.strictEqual(f(-4), "−4");
+      assert.strictEqual(f(-42), "−42");
+      assert.strictEqual(f(-4200000), "−4,200,000");
+      assert.strictEqual(f(-42000000), "−42,000,000");
+    },
+    "can group thousands, space fill, and round to significant digits": function(format) {
+      assert.strictEqual(format("10,.1f")(123456.49), " 123,456.5");
+      assert.strictEqual(format("10,.2f")(1234567.449), "1,234,567.45");
+      assert.strictEqual(format("10,.3f")(12345678.4449), "12,345,678.445");
+      assert.strictEqual(format("10,.5f")(123456789.444449), "123,456,789.44445");
+      assert.strictEqual(format("10,.1f")(123456), " 123,456.0");
+      assert.strictEqual(format("10,.2f")(1234567), "1,234,567.00");
+      assert.strictEqual(format("10,.3f")(12345678), "12,345,678.000");
+      assert.strictEqual(format("10,.5f")(123456789), "123,456,789.00000");
+    },
+    "can display integers in fixed-point notation": function(format) {
+      assert.strictEqual(format("f")(42), "42");
+    },
+    "will not display non-integers in integer format": function(format) {
+      assert.strictEqual(format("d")(4.2), "");
+    },
+    "supports \"n\" as an alias for \",g\"": function(format) {
+      var f = format("n");
+      assert.strictEqual(f(.0042), "0.0042");
+      assert.strictEqual(f(.42), "0.42");
+      assert.strictEqual(f(0), "0");
+      assert.strictEqual(f(42), "42");
+      assert.strictEqual(f(42000000), "42,000,000");
+      assert.strictEqual(f(420000000), "420,000,000");
+      assert.strictEqual(f(-4), "−4");
+      assert.strictEqual(f(-42), "−42");
+      assert.strictEqual(f(-4200000), "−4,200,000");
+      assert.strictEqual(f(-42000000), "−42,000,000");
+    }
+  }
+});
+
+suite.export(module);