bum 0.0.4 → 0.0.12

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

@@ -0,0 +1,165 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("selection.data");
+
+suite.addBatch({
+  "select(body)": {
+    topic: function() {
+      return d3.select("body").html("");
+    },
+    "assigns data as an array": function(body) {
+      var data = new Object();
+      body.data([data]);
+      assert.strictEqual(document.body.__data__, data);
+    },
+    "assigns data as a function": function(body) {
+      var data = new Object();
+      body.data(function() { return [data]; });
+      assert.strictEqual(document.body.__data__, data);
+    },
+    "stores data in the DOM": function(body) {
+      var expected = new Object(), actual;
+      document.body.__data__ = expected;
+      body.each(function(d) { actual = d; });
+      assert.strictEqual(actual, expected);
+    },
+    "returns a new selection": function(body) {
+      assert.isFalse(body.data([1]) === body);
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: function() {
+      return d3.select("body").html("").selectAll("div").data(d3.range(2)).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);
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div).selectAll(span)": {
+    topic: function() {
+      return d3.select("body").html("").selectAll("div")
+          .data(d3.range(2))
+        .enter().append("div").selectAll("span")
+          .data(d3.range(2))
+        .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(d3.range(4));
+      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(d3.range(4)).enter();
+      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(d3.range(1)).exit();
+      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.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]);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/selection-each-test.js

@@ -0,0 +1,83 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("selection.each");
+
+suite.addBatch({
+  "select(body)": {
+    topic: function() {
+      return d3.select("body").html("");
+    },
+    "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 === document.body);
+    },
+    "returns the same selection": function(body) {
+      assert.isTrue(body.each(function() {}) === body);
+    },
+    "ignores null nodes": function() {
+      var count = 0, body = d3.select("body");
+      body[0][0] = null;
+      body.each(function() { ++count; });
+      assert.equal(count, 0);
+    },
+    "returns the current selection": function(body) {
+      assert.isTrue(body.each(function() {}) === body);
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: function() {
+      return d3.select("body").html("").selectAll("div").data(d3.range(2)).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);
+    },
+    "ignores null nodes": function(div) {
+      var count = 0, some = d3.selectAll("div");
+      some[0][0] = null;
+      some.each(function() { ++count; });
+      assert.equal(count, 1);
+    },
+    "returns the current selection": function(div) {
+      assert.isTrue(div.each(function() {}) === div);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/selection-empty-test.js

@@ -0,0 +1,51 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("selection.empty");
+
+suite.addBatch({
+  "select(body)": {
+    topic: function() {
+      return d3.select("body").html("");
+    },
+    "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) {
+      var some = d3.select("body");
+      some[0][0] = null;
+      assert.isTrue(some.empty());
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: function() {
+      var body = d3.select("body").html("");
+      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) {
+      var some = d3.selectAll("div");
+      some[0][0] = null;
+      assert.isTrue(some.select("span").empty());
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/selection-filter-test.js

@@ -0,0 +1,63 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("selection.filter");
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: function() {
+      return d3.select("body").html("").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 = d3.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]);
+    },
+    "ignores null nodes": function() {
+      var span = d3.selectAll("span");
+      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, 1);
+    },
+    "returns a new selection": function(span) {
+      assert.isFalse(span.filter(function() { return 1; }) === span);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/core/selection-html-test.js

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