picky-statistics 4.5.0 → 4.5.1

data/lib/picky-statistics/application/javascripts/d3/test/core/html-test.js

@@ -1,37 +0,0 @@
-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/lib/picky-statistics/application/javascripts/d3/test/core/interpolate-test.js

@@ -1,209 +0,0 @@
-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);
-      assert.equal(interpolate("2px", 12)(.4), 6);
-    },
-    "interpolates colors": function(interpolate) {
-      assert.equal(interpolate("#abcdef", "#fedcba")(.4), "#ccd3da");
-    },
-    "interpolates strings": function(interpolate) {
-      assert.equal(interpolate("width:10px;", "width:50px;")(.2), "width:18px;");
-      assert.equal(interpolate(2, "12px")(.4), "6px");
-    },
-    "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 ");
-    },
-    "interpolates exponent notation correctly": function(interpolate) {
-      assert.equal(interpolate("1e+3", "1e+4")(.5), "5500");
-      assert.equal(interpolate("1e-3", "1e-4")(.5), "0.00055");
-    }
-  }
-});
-
-suite.addBatch({
-  "interpolateRgb": {
-    topic: function() {
-      return d3.interpolateRgb;
-    },
-    "parses string input": function(interpolate) {
-      assert.equal(interpolate("steelblue", "#f00")(.2), "#6b6890");
-      assert.equal(interpolate("steelblue", "#f00")(.6), "#b53448");
-    },
-    "parses d3.rgb input": function(interpolate) {
-      assert.equal(interpolate(d3.rgb("steelblue"), "#f00")(.2), "#6b6890");
-      assert.equal(interpolate("steelblue", d3.rgb(255, 0, 0))(.6), "#b53448");
-    },
-    "parses d3.hsl input": function(interpolate) {
-      assert.equal(interpolate(d3.hsl("steelblue"), "#f00")(.2), "#6b6890");
-      assert.equal(interpolate("steelblue", d3.hsl(0, 1, .5))(.6), "#b53448");
-    },
-    "interpolates in RGB color space": function(interpolate) {
-      assert.equal(interpolate("steelblue", "#f00")(.2), "#6b6890");
-    },
-    "outputs an RGB string": function(interpolate) {
-      assert.equal(interpolate("steelblue", "#f00")(.2), "#6b6890");
-    }
-  }
-});
-
-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: "#804000"});
-      assert.deepEqual(interpolate({fill: "red"}, {fill: "green"})(.5), {fill: "#804000"});
-      assert.deepEqual(interpolate({stroke: "red"}, {stroke: "green"})(.5), {stroke: "#804000"});
-      assert.deepEqual(interpolate({color: "red"}, {color: "green"})(.5), {color: "#804000"});
-    },
-    "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/lib/picky-statistics/application/javascripts/d3/test/core/json-test.js

@@ -1,37 +0,0 @@
-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/lib/picky-statistics/application/javascripts/d3/test/core/keys-test.js

@@ -1,31 +0,0 @@
-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/lib/picky-statistics/application/javascripts/d3/test/core/last-test.js

@@ -1,42 +0,0 @@
-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);

data/lib/picky-statistics/application/javascripts/d3/test/core/max-test.js

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

data/lib/picky-statistics/application/javascripts/d3/test/core/mean-test.js

@@ -1,43 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.mean");
-
-suite.addBatch({
-  "mean": {
-    topic: function() {
-      return d3.mean;
-    },
-    "returns the mean value for numbers": function(mean) {
-      assert.equal(mean([1]), 1);
-      assert.equal(mean([5, 1, 2, 3, 4]), 3);
-      assert.equal(mean([20, 3]), 11.5);
-      assert.equal(mean([3, 20]), 11.5);
-    },
-    "ignores null, undefined and NaN": function(mean) {
-      assert.equal(mean([NaN, 1, 2, 3, 4, 5]), 3);
-      assert.equal(mean([1, 2, 3, 4, 5, NaN]), 3);
-      assert.equal(mean([10, null, 3, undefined, 5, NaN]), 6);
-    },
-    "can handle large numbers without overflowing": function(mean) {
-      assert.equal(mean([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
-      assert.equal(mean([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE);
-    },
-    "returns undefined for empty array": function(mean) {
-      assert.isUndefined(mean([]));
-      assert.isUndefined(mean([null]));
-      assert.isUndefined(mean([undefined]));
-      assert.isUndefined(mean([NaN]));
-      assert.isUndefined(mean([NaN, NaN]));
-    },
-    "applies the optional accessor function": function(mean) {
-      assert.equal(d3.mean([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.mean(d); }), 4.5);
-      assert.equal(d3.mean([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
-    }
-  }
-});
-
-suite.export(module);