picky-statistics 4.0.0pre3 → 4.0.0pre5

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

@@ -0,0 +1,35 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.selection");
+
+suite.addBatch({
+  "selection": {
+    topic: function() {
+      return d3.selection();
+    },
+    "selects the document": function(selection) {
+      assert.equal(selection.length, 1);
+      assert.equal(selection[0].length, 1);
+      assert.equal(selection[0][0], document);
+    },
+    "is an instanceof d3.selection": function(selection) {
+      assert.isTrue(selection instanceof d3.selection);
+    },
+    "subselections are also instanceof d3.selection": function(selection) {
+      assert.isTrue(selection.select("body") instanceof d3.selection);
+      assert.isTrue(selection.selectAll("body") instanceof d3.selection);
+    },
+    "selection prototype can be extended": function(selection) {
+      d3.selection.prototype.foo = function(v) { return this.attr("foo", v); };
+      selection.select("body").foo(42);
+      assert.equal(document.body.getAttribute("foo"), "42");
+      delete d3.selection.prototype.foo;
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,109 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("selection.text");
+
+suite.addBatch({
+  "select(body)": {
+    topic: function() {
+      return d3.select("body").html("");
+    },
+    "sets the text content as a string": function(body) {
+      body.text("Hello, world!");
+      assert.equal(document.body.textContent, "Hello, world!");
+    },
+    "sets the text content as a number": function(body) {
+      body.text(42);
+      assert.equal(document.body.textContent, "42");
+    },
+    "sets the text content as a function": function(body) {
+      body.data(["Subject"]).text(function(d, i) { return "Hello, " + d + " " + i + "!"; });
+      assert.equal(document.body.textContent, "Hello, Subject 0!");
+    },
+    "escapes html content to text": function(body) {
+      body.text("<h1>Hello, world!</h1>");
+      assert.equal(document.body.textContent, "<h1>Hello, world!</h1>");
+      assert.equal(document.body.firstChild.nodeType, document.TEXT_NODE);
+    },
+    /*
+    https://github.com/tmpvar/jsdom/issues/276
+    "clears the text content as null": function(body) {
+      body.text(null);
+      assert.equal(document.body.textContent, "");
+    },
+    "clears the text content as a function": function(body) {
+      body.text(function() { return null; });
+      assert.equal(document.body.textContent, "");
+    },
+    */
+    "ignores null nodes": function() {
+      var body = d3.select("body");
+      body[0][0] = null;
+      document.body.textContent = "foo";
+      body.text("bar");
+      assert.equal(document.body.textContent, "foo");
+    },
+    "returns the current selection": function(body) {
+      assert.isTrue(body.text("hello") === body);
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: function() {
+      return d3.select("body").html("").selectAll("div").data(d3.range(2)).enter().append("div");
+    },
+    "sets the text content as a string": function(div) {
+      div.text("Hello, world!");
+      assert.equal(div[0][0].textContent, "Hello, world!");
+      assert.equal(div[0][1].textContent, "Hello, world!");
+    },
+    "sets the text content as a number": function(div) {
+      div.text(42);
+      assert.equal(div[0][0].textContent, "42");
+      assert.equal(div[0][1].textContent, "42");
+    },
+    "sets the text content as a function": function(div) {
+      div.data(["foo", "bar"]).text(function(d, i) { return "Hello, " + d + " " + i + "!"; });
+      assert.equal(div[0][0].textContent, "Hello, foo 0!");
+      assert.equal(div[0][1].textContent, "Hello, bar 1!");
+    },
+    "escapes html content to text": function(div) {
+      div.text("<h1>Hello, world!</h1>");
+      assert.equal(div[0][0].textContent, "<h1>Hello, world!</h1>");
+      assert.equal(div[0][1].textContent, "<h1>Hello, world!</h1>");
+      assert.equal(div[0][0].firstChild.nodeType, document.TEXT_NODE);
+      assert.equal(div[0][1].firstChild.nodeType, document.TEXT_NODE);
+    },
+    /*
+    https://github.com/tmpvar/jsdom/issues/276
+    "clears the text content as null": function(div) {
+      div.text(null);
+      assert.equal(div[0][0].textContent, "");
+      assert.equal(div[0][1].textContent, "");
+    },
+    "clears the text content as a function": function(div) {
+      div.text(function() { return null; });
+      assert.equal(dv[0][0].textContent, "");
+      assert.equal(dv[0][1].textContent, "");
+    },
+    */
+    "ignores null nodes": function(div) {
+      div[0][0].textContent = "foo";
+      var some = d3.selectAll("div");
+      some[0][0] = null;
+      some.text("bar");
+      assert.equal(div[0][0].textContent, "foo");
+      assert.equal(div[0][1].textContent, "bar");
+    },
+    "returns the current selection": function(div) {
+      assert.isTrue(div.text("hello") === div);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,34 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.split");
+
+suite.addBatch({
+  "split": {
+    topic: function() {
+      return d3.split;
+    },
+    "splits an array into arrays": function(split) {
+      var a = {}, b = {}, c = {}, d = {}, e = {}, f = {};
+      assert.deepEqual(d3.split([a, null, b, c, undefined, d, e, f]), [[a], [b, c], [d, e, f]]);
+    },
+    "splits using the specified function": function(split) {
+      assert.deepEqual(d3.split([1, 0, 2, 3, -1, 4, 5, 6], function(d) { return d <= 0; }), [[1], [2, 3], [4, 5, 6]]);
+      assert.deepEqual(d3.split([1, 0, 2, 3, -1, 4, 5, 6], function(d, i) { return i & 1; }), [[1], [2], [-1], [5]]);
+    },
+    "ignores delimiters at the start or end": function(split) {
+      var a = {}, b = {}, c = {};
+      assert.deepEqual(d3.split([null, a, b, null, c]), [[a, b], [c]]);
+      assert.deepEqual(d3.split([a, b, null, c, null]), [[a, b], [c]]);
+      assert.deepEqual(d3.split([null, a, b, null, c, null]), [[a, b], [c]]);
+      assert.deepEqual(d3.split([undefined, a, b, undefined, c]), [[a, b], [c]]);
+      assert.deepEqual(d3.split([a, b, undefined, c, undefined]), [[a, b], [c]]);
+      assert.deepEqual(d3.split([undefined, a, b, undefined, c, undefined]), [[a, b], [c]]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,47 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.sum");
+
+suite.addBatch({
+  "sum": {
+    topic: function() {
+      return d3.sum;
+    },
+    "sums numbers": function(sum) {
+      assert.equal(d3.sum([1]), 1);
+      assert.equal(d3.sum([5, 1, 2, 3, 4]), 15);
+      assert.equal(d3.sum([20, 3]), 23);
+      assert.equal(d3.sum([3, 20]), 23);
+    },
+    "sums types that can be coerced to numbers": function(sum) {
+      assert.equal(d3.sum(["20", "3"]), 23);
+      assert.equal(d3.sum(["3", "20"]), 23);
+      assert.equal(d3.sum(["3", 20]), 23);
+      assert.equal(d3.sum([20, "3"]), 23);
+      assert.equal(d3.sum([3, "20"]), 23);
+      assert.equal(d3.sum(["20", 3]), 23);
+    },
+    "ignores non-numeric types": function(sum) {
+      assert.equal(d3.sum(["a", "b", "c"]), 0);
+      assert.equal(d3.sum(["a", 1, "2"]), 3);
+    },
+    "ignores null, undefined and NaN": function(sum) {
+      assert.equal(d3.sum([NaN, 1, 2, 3, 4, 5]), 15);
+      assert.equal(d3.sum([1, 2, 3, 4, 5, NaN]), 15);
+      assert.equal(d3.sum([10, null, 3, undefined, 5, NaN]), 18);
+    },
+    "applies the optional acccessor function": function(sum) {
+      assert.equal(d3.sum([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.sum(d); }), 45);
+      assert.equal(d3.sum([1, 2, 3, 4, 5], function(d, i) { return i; }), 10);
+    },
+    "returns zero for the empty array": function(sum) {
+      assert.equal(d3.sum([]), 0);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,48 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.text");
+
+suite.addBatch({
+  "text": {
+    topic: function() {
+      var cb = this.callback;
+      return d3.text("examples/data/sample.txt", function(text) {
+        cb(null, text);
+      });
+    },
+    "invokes the callback with the loaded text": function(text) {
+      assert.equal(text, "Hello, world!\n");
+    },
+    "does not override the mime type by default": function(text) {
+      assert.isUndefined(XMLHttpRequest._last._info.mimeType);
+    },
+    "": {
+      topic: function() {
+        var cb = this.callback;
+        return d3.text("examples/data/sample.txt", "text/plain+sample", function(text) {
+          cb(null, text);
+        });
+      },
+      "observes the optional mime type": function(text) {
+        assert.equal(XMLHttpRequest._last._info.mimeType, "text/plain+sample");
+      }
+    },
+    " ": {
+      topic: function() {
+        var cb = this.callback;
+        return d3.text("//does/not/exist.txt", function(text) {
+          cb(null, text);
+        });
+      },
+      "invokes the callback with null when an error occurs": function(text) {
+        assert.isNull(text);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,62 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.timer");
+
+suite.addBatch({
+  "timer": {
+    topic: function() {
+      return d3.timer;
+    },
+    "with no delay": {
+      topic: timer(),
+      "first calls after 17 ms or less": function(info) {
+        assert.inDelta(info.start - info.scheduled, 17, 20);
+      },
+      "calls until the function returns true": function(info) {
+        assert.equal(info.count, 4);
+      },
+      "calls every 17 ms": function(info) {
+        assert.inDelta(info.stop - info.start, 17 * 3, 20);
+      }
+    },
+    "with a specified delay": {
+      topic: timer(250),
+      "first calls after the delay": function(info) {
+        assert.inDelta(info.start - info.scheduled, 250, 20);
+      },
+      "calls until the function returns true": function(info) {
+        assert.equal(info.count, 4);
+      },
+      "calls every 17 ms": function(info) {
+        assert.inDelta(info.stop - info.start, 17 * 3, 20);
+      }
+    }
+  }
+});
+
+function timer(delay) {
+  var args = Array.prototype.slice.call(arguments);
+  return function() {
+    var cb = this.callback,
+        info = {scheduled: Date.now(), count: 0};
+
+    args.unshift(function() {
+      var count = ++info.count;
+      if (count === 1) {
+        info.start = Date.now();
+      } else if (count === 4) {
+        info.stop = Date.now();
+        cb(null, info);
+        return true;
+      }
+    });
+
+    d3.timer.apply(this, args);
+  };
+}
+
+suite.export(module);

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

@@ -0,0 +1,54 @@
+require("../env");
+require("../../d3");
+
+var assert = require("assert");
+
+module.exports = {
+  topic: function() {
+    var cb = this.callback;
+
+    var s = d3.select("body").append("div")
+        .attr("display", "none")
+        .attr("font-size", "20px")
+        .attr("width", 20)
+        .attr("color", "red")
+        .attr("xlink:type", "simple")
+        .attr("xlink:href", "http://mbostock.github.com/d3/");
+
+    var t = s.transition()
+        .attr("display", null)
+        .attr("font-size", function() { return null; })
+        .attr("display", null)
+        .attr("width", 100)
+        .attr("width", 200)
+        .attr("color", function() { return "green"; })
+        .attr("xlink:href", null)
+        .attr("xlink:type", function() { return null; })
+        .each("end", function() { cb(null, {selection: s, transition: t}); });
+  },
+  "defines the corresponding attr tween": function(result) {
+    assert.typeOf(result.transition.tween("attr.width"), "function");
+    assert.typeOf(result.transition.tween("attr.color"), "function");
+  },
+  "the last attr operator takes precedence": function(result) {
+    assert.equal(result.selection.attr("width"), "200");
+  },
+  "sets an attribute as a number": function(result) {
+    assert.equal(result.selection.attr("width"), "200");
+  },
+  "sets an attribute as a function": function(result) {
+    assert.equal(result.selection.attr("color"), "#008000");
+  },
+  "removes an attribute using a constant null": function(result) {
+    assert.equal(result.selection.attr("display"), "");
+  },
+  "removes an attribute using a function null": function(result) {
+    assert.equal(result.selection.attr("font-size"), "");
+  },
+  "removes a namespaced attribute using a constant null": function(result) {
+    assert.equal(result.selection.attr("xlink:href"), "");
+  },
+  "removes a namespaced attribute using a function null": function(result) {
+    assert.equal(result.selection.attr("xlink:type"), "");
+  }
+};

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

@@ -0,0 +1,67 @@
+require("../env");
+require("../../d3");
+
+var assert = require("assert");
+
+module.exports = {
+  topic: function() {
+    var cb = this.callback,
+        dd = [],
+        ii = [],
+        tt = [],
+        vv = [];
+
+    var s = d3.select("body").html("").append("div").selectAll("div")
+        .data(["red", "green"])
+      .enter().append("div")
+        .attr("color", function(d) { return d3.rgb(d)+""; });
+
+    var t = s.transition()
+        .attrTween("color", tween);
+
+    function tween(d, i, v) {
+      dd.push(d);
+      ii.push(i);
+      vv.push(v);
+      if (tt.push(this) >= 2) cb(null, {
+        selection: s,
+        transition: t,
+        data: dd,
+        index: ii,
+        value: vv,
+        context: tt
+      });
+      return i && d3.interpolateHsl(v, "blue");
+    }
+  },
+
+  // The order here is a bit brittle: because the transition has zero delay,
+  // it's invoking the start event immediately for all nodes, rather than
+  // pushing each node onto the timer queue (which would reverse the order of
+  // callbacks). The order in which tweens are invoked is undefined, so perhaps
+  // we should sort the expected and actual values before comparing.
+
+  "defines the corresponding attr tween": function(result) {
+    assert.typeOf(result.transition.tween("attr.color"), "function");
+  },
+  "invokes the tween function": function(result) {
+    assert.deepEqual(result.data, ["red", "green"], "expected data, got {actual}");
+    assert.deepEqual(result.index, [0, 1], "expected data, got {actual}");
+    assert.deepEqual(result.value, ["#ff0000", "#008000"], "expected value, got {actual}");
+    assert.domEqual(result.context[0], result.selection[0][0], "expected this, got {actual}");
+    assert.domEqual(result.context[1], result.selection[0][1], "expected this, got {actual}");
+  },
+
+  "end": {
+    topic: function(result) {
+      var cb = this.callback;
+      result.transition.each("end", function(d, i) { if (i >= 1) cb(null, result); });
+    },
+    "uses the returned interpolator": function(result) {
+      assert.equal(result.selection[0][1].getAttribute("color"), "#0000ff");
+    },
+    "does nothing if the interpolator is falsey": function(result) {
+      assert.equal(result.selection[0][0].getAttribute("color"), "#ff0000");
+    }
+  }
+};