picky-statistics 4.0.0pre3 → 4.0.0pre5

data/lib/picky-statistics/application/javascripts/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/lib/picky-statistics/application/javascripts/d3/test/core/dispatch-test.js

@@ -0,0 +1,129 @@
+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.on("foo", function() { ++events; });
+      d.foo();
+      assert.equal(events, 1);
+      d.foo();
+      d.foo();
+      assert.equal(events, 3);
+    },
+    "the listener is passed any arguments to dispatch": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, aa, bb;
+      d.on("foo", function(a, b) { aa = a; bb = b; });
+      d.foo(a, b);
+      assert.equal(aa, a);
+      assert.equal(bb, b);
+      d.foo(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.on("foo", function() { that = this; });
+      d.foo.call(a);
+      assert.equal(that, a);
+      d.foo.call(b);
+      assert.equal(that, b);
+    },
+    "listeners are notified in the order they are added": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { those.push(a); }
+      function B() { those.push(b); }
+      d.on("foo.a", A).on("foo.b", B);
+      d.foo();
+      assert.deepEqual(those, [a, b]);
+      those = [];
+      d.on("foo.a", A); // move to the end
+      d.foo();
+      assert.deepEqual(those, [b, a]);
+    },
+    "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.on("foo.a", A).on("foo.b", B);
+      d.foo();
+      those = [];
+      d.on("foo.a", null);
+      d.foo();
+      assert.deepEqual(those, [b]);
+    },
+    "removing a shared listener only affects the intended event": function(dispatch) {
+      var d = dispatch("foo", "bar"), a = 0;
+      function A() { ++a; }
+      d.on("foo", A).on("bar", A);
+      d.foo();
+      d.bar();
+      assert.equal(a, 2);
+      d.on("foo", null);
+      d.bar();
+      assert.equal(a, 3);
+    },
+    "adding an existing listener has no effect": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      function A() { ++events; }
+      d.on("foo.a", A);
+      d.foo();
+      d.on("foo.a", A).on("foo.a", A);
+      d.foo();
+      assert.equal(events, 2);
+    },
+    "removing a missing listener has no effect": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      function A() { ++events; }
+      d.on("foo.a", null).on("foo", A).on("foo", null).on("foo", null);
+      d.foo();
+      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.on("foo.b", B); those.push(a); }
+      function B() { those.push(b); }
+      d.on("foo.a", A);
+      d.foo();
+      assert.deepEqual(those, [a]);
+    },
+    "removing a listener does affect the current event": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { d.on("foo.b", null); those.push(a); }
+      function B() { those.push(b); }
+      d.on("foo.a", A).on("foo.b", B);
+      d.foo();
+      assert.deepEqual(those, [a]);
+    },
+    "getting a listener returns the correct listener": function(dispatch) {
+      var d = dispatch("foo");
+      function A() {}
+      function B() {}
+      function C() {}
+      d.on("foo.a", A).on("foo.b", B).on("foo", C);
+      assert.equal(d.on("foo.a"), A);
+      assert.equal(d.on("foo.b"), B);
+      assert.equal(d.on("foo"), C);
+    }
+  }
+});
+
+suite.export(module);

data/lib/picky-statistics/application/javascripts/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/lib/picky-statistics/application/javascripts/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/lib/picky-statistics/application/javascripts/d3/test/core/extent-test.js

@@ -0,0 +1,51 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.extent");
+
+suite.addBatch({
+  "extent": {
+    topic: function() {
+      return d3.extent;
+    },
+    "returns the numeric extent for numbers": function(extent) {
+      assert.deepEqual(extent([1]), [1, 1]);
+      assert.deepEqual(extent([5, 1, 2, 3, 4]), [1, 5]);
+      assert.deepEqual(extent([20, 3]), [3, 20]);
+      assert.deepEqual(extent([3, 20]), [3, 20]);
+    },
+    "returns the lexicographic extent for strings": function(extent) {
+      assert.deepEqual(extent(["c", "a", "b"]), ["a", "c"]);
+      assert.deepEqual(extent(["20", "3"]), ["20", "3"]);
+      assert.deepEqual(extent(["3", "20"]), ["20", "3"]);
+    },
+    "ignores null, undefined and NaN": function(extent) {
+      assert.deepEqual(extent([NaN, 1, 2, 3, 4, 5]), [1, 5]);
+      assert.deepEqual(extent([1, 2, 3, 4, 5, NaN]), [1, 5]);
+      assert.deepEqual(extent([10, null, 3, undefined, 5, NaN]), [3, 10]);
+      assert.deepEqual(extent([-1, null, -3, undefined, -5, NaN]), [-5, -1]);
+    },
+    "compares heterogenous types as numbers": function(extent) {
+      assert.deepEqual(extent([20, "3"]), ["3", 20]);
+      assert.deepEqual(extent(["20", 3]), [3, "20"]);
+      assert.deepEqual(extent([3, "20"]), [3, "20"]);
+      assert.deepEqual(extent(["3", 20]), ["3", 20]);
+    },
+    "returns undefined for empty array": function(extent) {
+      assert.deepEqual(extent([]), [undefined, undefined]);
+      assert.deepEqual(extent([null]), [undefined, undefined]);
+      assert.deepEqual(extent([undefined]), [undefined, undefined]);
+      assert.deepEqual(extent([NaN]), [undefined, undefined]);
+      assert.deepEqual(extent([NaN, NaN]), [undefined, undefined]);
+    },
+    "applies the optional accessor function exactly once": function(extent) {
+      var i = 10;
+      assert.deepEqual(d3.extent([0,1,2,3], function() { return ++i; }), [11, 14]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/picky-statistics/application/javascripts/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);