stripchart 0.0.3

data/lib/stripchart/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/stripchart/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);

data/lib/stripchart/public/components/d3/test/selection/html-test.js

@@ -0,0 +1,134 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.html");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "sets the inner HTML as a string": function(body) {
+        body.html("<h1>Hello, world!</h1>");
+        assert.equal(body.node().firstChild.tagName, "H1");
+        assert.equal(body.node().firstChild.textContent, "Hello, world!");
+      },
+      "sets the inner HTML as a number": function(body) {
+        body.html(42);
+        assert.equal(body.node().innerHTML, "42");
+        assert.equal(body.node().firstChild.nodeType, 3);
+      },
+      "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(body.node().firstChild.tagName, "B");
+        assert.equal(body.node().firstChild.textContent, "Subject");
+        assert.equal(body.node().lastChild.tagName, "I");
+        assert.equal(body.node().lastChild.textContent, "0");
+      },
+      "clears the inner HTML as null": function(body) {
+        body.html(null);
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as undefined": function(body) {
+        body.html(undefined);
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as the empty string": function(body) {
+        body.html("");
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as a function returning the empty string": function(body) {
+        body.text(function() { return ""; });
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as a function returning null": function(body) {
+        body.text(function() { return null; });
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as a function returning undefined": function(body) {
+        body.text(function() { return undefined; });
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.html("foo") === body);
+      },
+      "ignores null nodes": function(body) {
+        var node = body.node();
+        body[0][0] = null;
+        node.innerHTML = "<h1>foo</h1>";
+        body.html("bar");
+        assert.equal(node.textContent, "foo");
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div").data([0, 1]).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, 3);
+      },
+      "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");
+      },
+      "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);
+      },
+      "returns the current selection": function(div) {
+        assert.isTrue(div.html("foo") === div);
+      },
+      "ignores null nodes": function(div) {
+        var node = div[0][0];
+        div[0][0] = null;
+        node.innerHTML = "<h1>foo</h1>";
+        div.html("bar");
+        assert.equal(node.textContent, "foo");
+        assert.equal(div[0][1].textContent, "bar");
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/selection/insert-test.js

@@ -0,0 +1,169 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.insert");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/insert").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "inserts before the specified selector": function(body) {
+        var span = body.html("").append("span");
+        var div = body.insert("div", "span");
+        assert.equal(div[0][0].tagName, "DIV");
+        assert.isNull(div[0][0].namespaceURI);
+        assert.domEqual(div[0][0], body.node().firstChild);
+        assert.domEqual(div[0][0].nextSibling, span[0][0]);
+      },
+      "inserts before the specified node": function(body) {
+        var span = body.html("").append("span");
+        var div = body.insert("div", function() { return span.node(); });
+        assert.equal(div[0][0].tagName, "DIV");
+        assert.isNull(div[0][0].namespaceURI);
+        assert.domEqual(div[0][0], body.node().firstChild);
+        assert.domEqual(div[0][0].nextSibling, span[0][0]);
+      },
+      "appends an HTML element": function(body) {
+        var div = body.insert("div");
+        assert.equal(div[0][0].tagName, "DIV");
+        assert.isNull(div[0][0].namespaceURI);
+        assert.domEqual(div[0][0], body.node().lastChild);
+      },
+      "appends an SVG element": function(body) {
+        var svg = body.insert("svg:svg");
+        assert.equal(svg[0][0].tagName, "SVG");
+        assert.equal(svg[0][0].namespaceURI, "http://www.w3.org/2000/svg");
+        assert.domEqual(svg[0][0].parentNode, body.node());
+        assert.domEqual(svg[0][0], body.node().lastChild);
+      },
+      "propagates data to new element": function(body) {
+        var data = new Object(), div = body.data([data]).insert("div");
+        assert.strictEqual(div[0][0].__data__, data);
+      },
+      "returns a new selection": function(body) {
+        assert.isFalse(body.insert("div") === body);
+      },
+      "inherits namespace from parent node": function(body) {
+        var g = body.insert("svg:svg").insert("g");
+        assert.equal(g[0][0].namespaceURI, "http://www.w3.org/2000/svg");
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div").data([0, 1]).enter().insert("div");
+      },
+      "appends an HTML element": function(div) {
+        var span = div.insert("span");
+        assert.equal(span[0].length, 2);
+        assert.equal(span[0][0].tagName, "SPAN");
+        assert.equal(span[0][1].tagName, "SPAN");
+        assert.isNull(span[0][0].namespaceURI);
+        assert.isNull(span[0][1].namespaceURI);
+        assert.domEqual(span[0][0].parentNode, div[0][0]);
+        assert.domEqual(span[0][1].parentNode, div[0][1]);
+        assert.domEqual(div[0][0].lastChild, span[0][0]);
+        assert.domEqual(div[0][1].lastChild, span[0][1]);
+      },
+      "appends an SVG element": function(div) {
+        var svg = div.insert("svg:svg");
+        assert.equal(svg[0].length, 2);
+        assert.equal(svg[0][0].tagName, "SVG");
+        assert.equal(svg[0][1].tagName, "SVG");
+        assert.equal(svg[0][0].namespaceURI, "http://www.w3.org/2000/svg");
+        assert.equal(svg[0][1].namespaceURI, "http://www.w3.org/2000/svg");
+        assert.domEqual(svg[0][0].parentNode, div[0][0]);
+        assert.domEqual(svg[0][1].parentNode, div[0][1]);
+        assert.domEqual(div[0][0].lastChild, svg[0][0]);
+        assert.domEqual(div[0][1].lastChild, svg[0][1]);
+      },
+      "propagates data to new elements": function(div) {
+        var a = new Object(), b = new Object(), span = div.data([a, b]).insert("span");
+        assert.strictEqual(span[0][0].__data__, a);
+        assert.strictEqual(span[0][1].__data__, b);
+      },
+      "returns a new selection": function(div) {
+        assert.isFalse(div.insert("div") === div);
+      },
+      "ignores null nodes": function(div) {
+        div.html("");
+        var node = div[0][1];
+        div[0][1] = null;
+        var span = div.insert("span");
+        assert.equal(span[0].length, 2);
+        assert.equal(span[0][0].tagName, "SPAN");
+        assert.domNull(span[0][1]);
+        assert.domEqual(span[0][0].parentNode, div[0][0]);
+        assert.domEqual(div[0][0].lastChild, span[0][0]);
+        assert.domNull(node.lastChild);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "enter-insert": {
+    topic: load("selection/selection").document(),
+    "on a page with existing elements": {
+      topic: function(d3) {
+        var body = d3.select("body");
+        body.selectAll("div").data(["apple", "orange"]).enter().append("div");
+        return body;
+      },
+      "inserts before the following updating sibling": function(body) {
+        var data = ["peach", "apple", "apple2", "apple3", "banana", "orange", "apricot"];
+        body.selectAll("div").data(data, String).enter().insert("div");
+        assert.deepEqual(body.selectAll("div").data(), data);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div).data(…).enter()": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "inserts before the specified selector": function(body) {
+        var span = body.append("span");
+        var div = body.selectAll("div").data([0, 1]).enter().insert("div", "span");
+        assert.equal(div.length, 1);
+        assert.equal(div[0].length, 2);
+        assert.domEqual(div[0][0], body.node().firstChild);
+        assert.domEqual(div[0][1].previousSibling, div[0][0]);
+        assert.domEqual(div[0][1].nextSibling, span[0][0]);
+      },
+      "propagates data to new elements": function(body) {
+        var a = new Object(), b = new Object(), div = body.html("").selectAll("div").data([a, b]).enter().insert("div");
+        assert.strictEqual(div[0][0].__data__, a);
+        assert.strictEqual(div[0][1].__data__, b);
+      },
+      "ignores null nodes": function(body) {
+        body.html("").insert("div");
+        var div = body.selectAll("div").data([0, 1, 2]).enter().insert("div");
+        assert.equal(div.length, 1);
+        assert.equal(div[0].length, 3);
+        assert.domNull(div[0][0]);
+        assert.domEqual(div[0][1].parentNode, body.node());
+        assert.domEqual(div[0][2].parentNode, body.node());
+      },
+      "returns a new selection": function(body) {
+        var enter = body.html("").selectAll("div").data([0, 1]).enter();
+        assert.isFalse(enter.insert("div") === enter);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/selection/node-test.js

@@ -0,0 +1,55 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.node");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/node").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "returns null for empty selections": function(body) {
+        assert.isNull(body.select("foo").node());
+      },
+      "returns the first element for non-empty selections": function(body) {
+        assert.isTrue(body.node() === body[0][0]);
+        assert.equal(body.node().tagName, "BODY");
+      },
+      "ignores null nodes": function(body) {
+        body[0][0] = null;
+        assert.isNull(body.node());
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/node").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 null for empty selections": function(div) {
+        assert.isNull(div.select("foo").node());
+      },
+      "returns the first element for non-empty selections": function(div) {
+        assert.isTrue(div.node() === div[0][0]);
+        assert.equal(div.node().tagName, "DIV");
+      },
+      "ignores null nodes": function(div) {
+        div[0][0] = null;
+        assert.isTrue(div.node() === div[0][1]);
+        assert.equal(div.node().tagName, "DIV");
+      }
+    }
+  }
+});
+
+suite.export(module);