stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/selection/data-test.js

@@ -0,0 +1,270 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.data");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "assigns data as an array": function(body) {
+        var data = new Object();
+        body.data([data]);
+        assert.strictEqual(body.node().__data__, data);
+      },
+      "assigns data as a function": function(body) {
+        var data = new Object();
+        body.data(function() { return [data]; });
+        assert.strictEqual(body.node().__data__, data);
+      },
+      "stores data in the DOM": function(body) {
+        var expected = new Object(), actual;
+        body.node().__data__ = expected;
+        body.each(function(d) { actual = d; });
+        assert.strictEqual(actual, expected);
+      },
+      "returns a new selection": function(body) {
+        assert.isFalse(body.data([1]) === body);
+      },
+      "with no arguments, returns an array of data": function(body) {
+        var data = new Object();
+        body.data([data]);
+        assert.deepEqual(body.data(), [data]);
+        assert.strictEqual(body.data()[0], data);
+      },
+      "throws an error if data is null": function(body) {
+        var errored;
+        try { body.data(null); } catch (e) { errored = true; }
+        assert.isTrue(errored);
+      },
+      "throws an error if data is a function that returns null": function(body) {
+        var errored;
+        try { body.data(function() {}); } catch (e) { errored = true; }
+        assert.isTrue(errored);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/data").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div").data([0, 1]).enter().append("div");
+      },
+      "assigns data as an array": function(div) {
+        var a = new Object(), b = new Object();
+        div.data([a, b]);
+        assert.strictEqual(div[0][0].__data__, a);
+        assert.strictEqual(div[0][1].__data__, b);
+      },
+      "assigns data as a function": function(div) {
+        var a = new Object(), b = new Object();
+        div.data(function() { return [a, b]; });
+        assert.strictEqual(div[0][0].__data__, a);
+        assert.strictEqual(div[0][1].__data__, b);
+      },
+      "stores data in the DOM": function(div) {
+        var a = new Object(), b = new Object(), actual = [];
+        div[0][0].__data__ = a;
+        div[0][1].__data__ = b;
+        div.each(function(d) { actual.push(d); });
+        assert.deepEqual(actual, [a, b]);
+      },
+      "returns a new selection": function(div) {
+        assert.isFalse(div.data([0, 1]) === div);
+      },
+      "throws an error if data is null": function(div) {
+        var errored;
+        try { div.data(null); } catch (e) { errored = true; }
+        assert.isTrue(errored);
+      },
+      "throws an error if data is a function that returns null": function(div) {
+        var errored;
+        try { div.data(function() {}); } catch (e) { errored = true; }
+        assert.isTrue(errored);
+      },
+      "with no arguments, returns an array of data": function(div) {
+        var a = new Object(), b = new Object(), actual = [];
+        div[0][0].__data__ = a;
+        div[0][1].__data__ = b;
+        assert.deepEqual(div.data(), [a, b]);
+      },
+      "with no arguments, returned array has undefined for null nodes": function(div) {
+        var b = new Object(), actual = [];
+        div[0][0] = null;
+        div[0][1].__data__ = b;
+        var data = div.data();
+        assert.isUndefined(data[0]);
+        assert.strictEqual(data[1], b);
+        assert.equal(data.length, 2);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/data").document(),
+    "on a simple page": {
+      "ignores duplicate keys in both data and selection": function(d3) {
+        var div = d3.select("body").html("").selectAll("div")
+            .data(["aa", "ab", "ac", "ba", "bb", "bc"])
+          .enter().append("div")
+            .text(function(d) { return d; });
+
+        var update = div.data(["aa", "ab", "ba", "bb"], function(d) { return d.substring(0, 1); }),
+            enter = update.enter(),
+            exit = update.exit();
+
+        assert.equal(update.length, 1);
+
+        // enter     - [   null,   null,   null,   null]
+        assert.equal(enter[0].length, 4);
+        assert.equal(enter[0][0], null);
+        assert.equal(enter[0][1], null);
+        assert.equal(enter[0][2], null);
+        assert.equal(enter[0][3], null);
+
+        // update    - [ aa (a),   null, ba (b),   null]
+        assert.equal(update[0].length, 4);
+        assert.strictEqual(update[0][0], div[0][0]);
+        assert.equal(update[0][1], null);
+        assert.strictEqual(update[0][2], div[0][3]);
+        assert.equal(update[0][3], null);
+
+        // exit      - [   null, ab (a), ac (a),   null, bb (b), bc (b)]
+        assert.equal(exit[0].length, 6);
+        assert.equal(exit[0][0], null);
+        assert.strictEqual(exit[0][1], div[0][1]);
+        assert.strictEqual(exit[0][2], div[0][2]);
+        assert.equal(exit[0][3], null);
+        assert.strictEqual(exit[0][4], div[0][4]);
+        assert.strictEqual(exit[0][5], div[0][5]);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div).selectAll(span)": {
+    topic: load("selection/data").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div")
+            .data([0, 1])
+          .enter().append("div").selectAll("span")
+            .data([0, 1])
+          .enter().append("span");
+      },
+      "assigns data as an array": function(span) {
+        var a = new Object(), b = new Object();
+        span.data([a, b]);
+        assert.strictEqual(span[0][0].__data__, a);
+        assert.strictEqual(span[0][1].__data__, b);
+        assert.strictEqual(span[1][0].__data__, a);
+        assert.strictEqual(span[1][1].__data__, b);
+      },
+      "assigns data as a function": function(span) {
+        var a = new Object(), b = new Object(), c = new Object(), d = new Object();
+        span.data(function(z, i) { return i ? [c, d] : [a, b]; });
+        assert.strictEqual(span[0][0].__data__, a);
+        assert.strictEqual(span[0][1].__data__, b);
+        assert.strictEqual(span[1][0].__data__, c);
+        assert.strictEqual(span[1][1].__data__, d);
+      },
+      "evaluates the function once per group": function(span) {
+        var count = 0;
+        span.data(function() { ++count; return [0, 1]; });
+        assert.equal(count, 2);
+      },
+      "defines an update selection for updating data": function(span) {
+        var update = span.data([0, 1, 2, 3]);
+        assert.equal(update.length, 2);
+        assert.equal(update[0].length, 4);
+        assert.equal(update[1].length, 4);
+        assert.domEqual(update[0][0], span[0][0]);
+        assert.domEqual(update[0][1], span[0][1]);
+        assert.domNull(update[0][2]);
+        assert.domNull(update[0][3]);
+        assert.domEqual(update[1][0], span[1][0]);
+        assert.domEqual(update[1][1], span[1][1]);
+        assert.domNull(update[1][2]);
+        assert.domNull(update[1][3]);
+      },
+      "defines an enter selection for entering data": function(span) {
+        var enter = span.data([0, 1, 2, 3]).enter();
+        assert.isFalse(enter.empty());
+        assert.equal(enter.length, 2);
+        assert.equal(enter[0].length, 4);
+        assert.equal(enter[1].length, 4);
+        assert.domNull(enter[0][0]);
+        assert.domNull(enter[0][1]);
+        assert.deepEqual(enter[0][2], {__data__: 2});
+        assert.deepEqual(enter[0][3], {__data__: 3});
+        assert.domNull(enter[1][0]);
+        assert.domNull(enter[1][1]);
+        assert.deepEqual(enter[1][2], {__data__: 2});
+        assert.deepEqual(enter[1][3], {__data__: 3});
+      },
+      "defines an exit selection for exiting data": function(span) {
+        var exit = span.data([0]).exit();
+        assert.isFalse(exit.empty());
+        assert.equal(exit.length, 2);
+        assert.equal(exit[0].length, 2);
+        assert.equal(exit[1].length, 2);
+        assert.domNull(exit[0][0]);
+        assert.domEqual(exit[0][1], span[0][1]);
+        assert.domNull(exit[1][0]);
+        assert.domEqual(exit[1][1], span[1][1]);
+      },
+      "observes the specified key function": function(span) {
+        var update = span.data([1, 2], Number);
+        assert.isFalse(update.empty());
+        assert.equal(update.length, 2);
+        assert.equal(update[0].length, 2);
+        assert.equal(update[1].length, 2);
+        assert.domEqual(update[0][0], span[0][1]);
+        assert.domNull(update[0][1]);
+        assert.domEqual(update[1][0], span[1][1]);
+        assert.domNull(update[1][1]);
+
+        var enter = update.enter();
+        assert.equal(enter.length, 2);
+        assert.equal(enter[0].length, 2);
+        assert.equal(enter[1].length, 2);
+        assert.domNull(enter[0][0]);
+        assert.deepEqual(enter[0][1], {__data__: 2});
+        assert.domNull(enter[1][0]);
+        assert.deepEqual(enter[1][1], {__data__: 2});
+
+        var exit = update.exit();
+        assert.equal(exit.length, 2);
+        assert.equal(exit[0].length, 2);
+        assert.equal(exit[1].length, 2);
+        assert.domEqual(exit[0][0], span[0][0]);
+        assert.domNull(exit[0][1]);
+        assert.domEqual(exit[1][0], span[1][0]);
+        assert.domNull(exit[1][1]);
+      },
+      "handles keys that are in the default object's prototype chain": function(span) {
+        // This also applies to the non-standard "watch" and "unwatch" in Mozilla Firefox.
+        var update = span.data(["hasOwnProperty", "isPrototypeOf", "toLocaleString", "toString", "valueOf"], String);
+        assert.domNull(update[0][0]);
+        assert.domNull(update[0][1]);
+        assert.domNull(update[0][2]);
+        assert.domNull(update[0][3]);
+        assert.domNull(update[0][4]);
+        // This throws an error if Object.hasOwnProperty isn't used.
+        span.data([0], function() { return "hasOwnProperty"; });
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/selection/datum-test.js

@@ -0,0 +1,87 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.datum");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/datum").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "updates the data according to the specified function": function(body) {
+        body.data([42]).datum(function(d, i) { return d + i; });
+        assert.equal(body.node().__data__, 42);
+      },
+      "updates the data to the specified constant": function(body) {
+        body.datum(43);
+        assert.equal(body.node().__data__, 43);
+      },
+      "deletes the data if the function returns null": function(body) {
+        body.data([42]).datum(function() { return null; });
+        assert.isFalse("__data__" in body.node());
+      },
+      "deletes the data if the constant is null": function(body) {
+        body.data([42]).datum(null);
+        assert.isFalse("__data__" in body.node());
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.datum(function() { return 1; }) === body);
+        assert.isTrue(body.datum(2) === body);
+      },
+      "with no arguments, returns the first node's datum": function(body) {
+        body.data([42]);
+        assert.equal(body.datum(), 42);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/datum").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div").data([0, 1]).enter().append("div");
+      },
+      "updates the data according to the specified function": function(div) {
+        div.data([42, 43]).datum(function(d, i) { return d + i; });
+        assert.equal(div[0][0].__data__, 42);
+        assert.equal(div[0][1].__data__, 44);
+      },
+      "updates the data to the specified constant": function(div) {
+        div.datum(44);
+        assert.equal(div[0][0].__data__, 44);
+        assert.equal(div[0][1].__data__, 44);
+      },
+      "deletes the data if the function returns null": function(div) {
+        div.datum(function() { return null; });
+        assert.isFalse("__data__" in div[0][0]);
+        assert.isFalse("__data__" in div[0][1]);
+      },
+      "deletes the data if the constant is null": function(div) {
+        div.datum(null);
+        assert.isFalse("__data__" in div[0][0]);
+        assert.isFalse("__data__" in div[0][1]);
+      },
+      "returns the current selection": function(div) {
+        assert.isTrue(div.datum(function() { return 1; }) === div);
+        assert.isTrue(div.datum(2) === div);
+      },
+      "ignores null nodes": function(div) {
+        var node = div[0][1];
+        div[0][1] = null;
+        div.datum(function() { return 1; });
+        assert.equal(div[0][0].__data__, 1);
+        assert.equal(node.__data__, 2);
+        div.datum(43);
+        assert.equal(div[0][0].__data__, 43);
+        assert.equal(node.__data__, 2);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/selection/each-test.js

@@ -0,0 +1,87 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.each");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/each").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "calls the function once per element": function(body) {
+        var count = 0;
+        body.each(function() { ++count; });
+        assert.equal(count, 1);
+      },
+      "passes the data and index to the function": function(body) {
+        var data = new Object(), dd, ii;
+        body.data([data]).each(function(d, i) { dd = d; ii = i; });
+        assert.isTrue(dd === data);
+        assert.isTrue(ii === 0);
+      },
+      "uses the node as the context": function(body) {
+        var node;
+        body.each(function() { node = this; });
+        assert.isTrue(node === body.node());
+      },
+      "returns the same selection": function(body) {
+        assert.isTrue(body.each(function() {}) === body);
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.each(function() {}) === body);
+      },
+      "ignores null nodes": function(body) {
+        var count = 0;
+        body[0][0] = null;
+        body.each(function() { ++count; });
+        assert.equal(count, 0);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/each").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div").data([0, 1]).enter().append("div");
+      },
+      "calls the function once per element": function(div) {
+        var count = 0;
+        div.each(function() { ++count; });
+        assert.equal(count, 2);
+      },
+      "passes the data and index to the function": function(div) {
+        var data = [new Object(), new Object()], dd = [], ii = [];
+        div.data(data).each(function(d, i) { dd.push(d); ii.push(i); });
+        assert.deepEqual(dd, data);
+        assert.deepEqual(ii, [0, 1]);
+      },
+      "uses the node as the context": function(div) {
+        var nodes = [];
+        div.each(function() { nodes.push(this); });
+        assert.equal(nodes.length, 2);
+        assert.isTrue(div[0][0] == nodes[0]);
+        assert.isTrue(div[0][1] == nodes[1]);
+      },
+      "returns the same selection": function(div) {
+        assert.isTrue(div.each(function() {}) === div);
+      },
+      "returns the current selection": function(div) {
+        assert.isTrue(div.each(function() {}) === div);
+      },
+      "ignores null nodes": function(div) {
+        var count = 0;
+        div[0][0] = null;
+        div.each(function() { ++count; });
+        assert.equal(count, 1);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/selection/empty-test.js

@@ -0,0 +1,53 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.empty");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/empty").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "returns true for empty selections": function(body) {
+        assert.isTrue(body.select("foo").empty());
+      },
+      "returns false for non-empty selections": function(body) {
+        assert.isFalse(body.empty());
+      },
+      "ignores null nodes": function(body) {
+        body[0][0] = null;
+        assert.isTrue(body.empty());
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/empty").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        var body = d3.select("body");
+        body.append("div").append("span");
+        body.append("div");
+        return body.selectAll("div");
+      },
+      "returns true for empty selections": function(div) {
+        assert.isTrue(div.select("foo").empty());
+      },
+      "returns false for non-empty selections": function(div) {
+        assert.isFalse(div.empty());
+        assert.isFalse(div.select("span").empty());
+      },
+      "ignores null nodes": function(div) {
+        div[0][0] = null;
+        assert.isTrue(div.select("span").empty());
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/selection/enter-test.js

@@ -0,0 +1,24 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.enter");
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/enter").document(),
+    "is an instanceof d3.selection.enter": function(d3) {
+      var enter = d3.select("body").selectAll("div").data([0, 1]).enter();
+      assert.instanceOf(enter, d3.selection.enter);
+    },
+    "selection prototype can be extended": function(d3) {
+      var enter = d3.select("body").html("").selectAll("div").data([0, 1]).enter();
+      d3.selection.enter.prototype.foo = function() { return this.append("foo"); };
+      var selection = enter.foo();
+      assert.equal(d3.select("body").html(), "<foo></foo><foo></foo>");
+      delete d3.selection.enter.prototype.foo;
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/selection/filter-test.js

@@ -0,0 +1,72 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.filter");
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/filter").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div")
+            .data([0, 1])
+          .enter().append("div")
+          .selectAll("span")
+            .data(function(d) { d <<= 1; return [d, d + 1]; })
+          .enter().append("span");
+      },
+      "preserves matching elements": function(span) {
+        var some = span.filter(function(d, i) { return i === 0; });
+        assert.isTrue(some[0][0] === span[0][0]);
+        assert.isTrue(some[1][0] === span[1][0]);
+      },
+      "removes non-matching elements": function(span) {
+        var some = _.merge(span.filter(function(d, i) { return d & 1; }));
+        assert.equal(some.indexOf(span[0][0]), -1);
+        assert.equal(some.indexOf(span[1][0]), -1);
+      },
+      "preserves data": function(span) {
+        var some = span.filter(function(d, i) { return d & 1; });
+        assert.equal(some[0][0].__data__, 1);
+        assert.equal(some[1][0].__data__, 3);
+      },
+      "preserves grouping": function(span) {
+        var some = span.filter(function(d, i) { return d & 1; });
+        assert.equal(some.length, 2);
+        assert.equal(some[0].length, 1);
+        assert.equal(some[1].length, 1);
+      },
+      "preserves parent node": function(span) {
+        var some = span.filter(function(d, i) { return d & 1; });
+        assert.isTrue(some[0].parentNode === span[0].parentNode);
+        assert.isTrue(some[1].parentNode === span[1].parentNode);
+      },
+      "does not preserve index": function(span) {
+        var indexes = [];
+        span.filter(function(d, i) { return d & 1; }).each(function(d, i) { indexes.push(i); });
+        assert.deepEqual(indexes, [0, 0]);
+      },
+      "can be specified as a selector": function(span) {
+        span.classed("foo", function(d, i) { return d & 1; });
+        var some = span.filter(".foo");
+        assert.equal(some.length, 2);
+        assert.equal(some[0].length, 1);
+        assert.equal(some[1].length, 1);
+      },
+      "returns a new selection": function(span) {
+        assert.isFalse(span.filter(function() { return 1; }) === span);
+      },
+      "ignores null nodes": function(span) {
+        var node = span[0][1];
+        span[0][1] = null;
+        var some = span.filter(function(d, i) { return d & 1; });
+        assert.isTrue(some[0][0] === span[0][3]);
+        assert.equal(some.length, 2);
+      }
+    }
+  }
+});
+
+suite.export(module);