stripchart 0.0.3

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

@@ -0,0 +1,135 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.on");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/on").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "registers an event listener for the specified type": function(body) {
+        var form = body.append("form"), count = 0;
+        form.on("submit", function() { ++count; }); // jsdom has spotty event support
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(count, 1);
+      },
+      "replaces an existing event listener for the same type": function(body) {
+        var form = body.append("form"), count = 0, fail = 0;
+        form.on("submit", function() { ++fail; });
+        form.on("submit", function() { ++count; });
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(count, 1);
+        assert.equal(fail, 0);
+      },
+      "removes an existing event listener": function(body) {
+        var form = body.append("form"), fail = 0;
+        form.on("submit", function() { ++fail; });
+        form.on("submit", null);
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(fail, 0);
+        assert.isUndefined(form.on("submit"));
+      },
+      /* Regrettably, JSDOM ignores the capture flag, so we can't test this yet…
+      "removing a listener doesn't require the capture flag": function(body) {
+        var form = body.append("form"), fail = 0;
+        form.on("submit", function() { ++fail; }, true);
+        form.on("submit", null);
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(fail, 0);
+        assert.isUndefined(form.on("submit"));
+      },
+      */
+      "ignores removal of non-matching event listener": function(body) {
+        body.append("form").on("submit", null);
+      },
+      "observes the specified namespace": function(body) {
+        var form = body.append("form"), foo = 0, bar = 0;
+        form.on("submit.foo", function() { ++foo; });
+        form.on({"submit.bar": function() { ++bar; }});
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(foo, 1);
+        assert.equal(bar, 1);
+      },
+      "can register listeners as a map": function(body) {
+        var form = body.append("form"), count = 0, fail = 0;
+        form.on({submit: function() { ++fail; }});
+        form.on({submit: function() { ++count; }});
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(count, 1);
+        assert.equal(fail, 0);
+        form.on({submit: null});
+        assert.isUndefined(form.on("submit"));
+      },
+      /* Not really sure how to test this one…
+      "observes the specified capture flag": function(body) {
+      },
+      */
+      "passes the current data and index to the event listener": function(body) {
+        var forms = body.html("").selectAll("form").data(["a", "b"]).enter().append("form"), dd, ii, data = new Object();
+        forms.on("submit", function(d, i) { dd = d; ii = i; });
+        forms.append("input").attr("type", "submit")[0][1].click();
+        assert.equal(dd, "b");
+        assert.equal(ii, 1);
+        forms[0][1].__data__ = data;
+        forms.append("input").attr("type", "submit")[0][1].click();
+        assert.equal(dd, data);
+        assert.equal(ii, 1);
+      },
+      "uses the current element as the context": function(body) {
+        var forms = body.html("").selectAll("form").data(["a", "b"]).enter().append("form"), context;
+        forms.on("submit", function() { context = this; });
+        forms.append("input").attr("type", "submit")[0][1].click();
+        assert.domEqual(context, forms[0][1]);
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.on("submit", function() {}) === body);
+      },
+      "returns the assigned listener if called with one argument": function(body) {
+        body.on("mouseover", f).on("click.foo", f);
+        function f() {}
+        assert.equal(body.on("mouseover"), f);
+        assert.equal(body.on("click.foo"), f);
+        assert.isUndefined(body.on("click"));
+        assert.isUndefined(body.on("mouseover.foo"));
+      },
+      "omitting the event type": {
+        "returns undefined when retrieving a listener": function(body) {
+          assert.isUndefined(body.on(".foo"));
+        },
+        "null removes all named event listeners": function(body) {
+          body.on("mouseover.foo", f)
+              .on("click.foo", f)
+              .on("click.foobar", f)
+              .on(".foo", null);
+          function f() {}
+          assert.isUndefined(body.on("mouseover.foo"));
+          assert.isUndefined(body.on("click.foo"));
+          assert.equal(body.on("click.foobar"), f);
+        },
+        "no-op when setting a listener": function(body) {
+          assert.isTrue(body.on(".foo", function() {}) === body);
+          assert.isUndefined(body.on(".foo"));
+        }
+      }
+    },
+    "sets the current event as d3.event": function(d3) {
+      var form = d3.select("body").append("form"), event;
+      form.on("submit", function() { event = d3.event; });
+      form.append("input").attr("type", "submit").node().click();
+      assert.equal(event.type, "submit");
+      assert.domEqual(event.target, form[0][0]);
+    },
+    "restores the original event after notifying listeners": function(d3) {
+      var form = d3.select("body").append("form"), event = d3.event = new Object();
+      form.on("submit", function() {});
+      form.append("input").attr("type", "submit").node().click();
+      assert.equal(d3.event, event);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,32 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.order");
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/call").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div")
+            .data([1, 2, 10, 20])
+          .enter().append("div")
+            .attr("id", String);
+      },
+      "orders elements by data": function(div) {
+        div = div.data([1, 10, 20, 2], String).order();
+        assert.domNull(div[0][0].previousSibling);
+        assert.domEqual(div[0][1].previousSibling, div[0][0]);
+        assert.domEqual(div[0][2].previousSibling, div[0][1]);
+        assert.domEqual(div[0][3].previousSibling, div[0][2]);
+        assert.domNull(div[0][3].nextSibling);
+      },
+      "returns the current selection": function(span) {
+        assert.isTrue(span.order() === span);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,118 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.property");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/property").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "sets a property as a string": function(body) {
+        body.property("bgcolor", "red");
+        assert.equal(body.node().bgcolor, "red");
+      },
+      "sets a property as a number": function(body) {
+        body.property("opacity", 1);
+        assert.equal(body.node().opacity, "1");
+      },
+      "sets a property as a function": function(body) {
+        body.property("bgcolor", function() { return "orange"; });
+        assert.equal(body.node().bgcolor, "orange");
+      },
+      "sets properties as a map of constants": function(body) {
+        body.property({bgcolor: "purple", opacity: .41});
+        assert.equal(body.node().bgcolor, "purple");
+        assert.equal(body.node().opacity, .41);
+      },
+      "sets properties as a map of functions": function(body) {
+        body.data(["cyan"]).property({bgcolor: String, opacity: function(d, i) { return i; }});
+        assert.equal(body.node().bgcolor, "cyan");
+        assert.equal(body.node().opacity, 0);
+      },
+      "gets a property value": function(body) {
+        body.node().bgcolor = "yellow";
+        assert.equal(body.property("bgcolor"), "yellow");
+      },
+      "removes a property as null": function(body) {
+        body.property("bgcolor", "yellow").property("bgcolor", null);
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "removes a property as a function": function(body) {
+        body.property("bgcolor", "yellow").property("bgcolor", function() { return null });
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "removes properties as a map of nulls": function(body) {
+        body.node().bgcolor = "red";
+        body.property({bgcolor: null});
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "removes properties as a map of functions that return null": function(body) {
+        body.node().bgcolor = "red";
+        body.property({bgcolor: function() {}});
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.property("bgcolor", "yellow") === body);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/property").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").html("").selectAll("div").data([0, 1]).enter().append("div");
+      },
+      "sets a property as a string": function(div) {
+        div.property("bgcolor", "red");
+        assert.equal(div[0][0].bgcolor, "red");
+        assert.equal(div[0][1].bgcolor, "red");
+      },
+      "sets a property as a number": function(div) {
+        div.property("opacity", 0.4);
+        assert.strictEqual(div[0][0].opacity, 0.4);
+        assert.strictEqual(div[0][1].opacity, 0.4);
+      },
+      "sets a property as a function": function(div) {
+        var i = _.interpolateRgb("brown", "steelblue");
+        div.property("_color", function(d) { return d3.rgb(i(d)); }); // make a copy
+        assert.rgbEqual(div[0][0]._color, 165, 42, 42);
+        assert.rgbEqual(div[0][1]._color, 70, 130, 180);
+      },
+      "gets a property value": function(div) {
+        div[0][0].bgcolor = "purple";
+        assert.equal(div.property("bgcolor"), "purple");
+      },
+      "removes a property as null": function(div) {
+        div.property("bgcolor", "yellow").property("bgcolor", null);
+        assert.isFalse("bgcolor" in div[0][0]);
+        assert.isFalse("bgcolor" in div[0][1]);
+      },
+      "removes a property as a function": function(div) {
+        div.property("bgcolor", "yellow").property("bgcolor", function() { return null });
+        assert.isFalse("bgcolor" in div[0][0]);
+        assert.isFalse("bgcolor" in div[0][1]);
+      },
+      "returns the current selection": function(div) {
+        assert.isTrue(div.property("bgcolor", "yellow") === div);
+      },
+      "ignores null nodes": function(div) {
+        var node = div[0][1];
+        div.property("bgcolor", null);
+        div[0][1] = null;
+        div.property("bgcolor", "red");
+        assert.equal(div[0][0].bgcolor, "red");
+        assert.isFalse("bgcolor" in node);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,38 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.remove");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/remove").document(),
+    "removes the matching elements": function(d3) {
+      var div = d3.select("body").append("div");
+      div.remove();
+      assert.domNull(div[0][0].parentNode);
+    },
+    "does not remove non-matching elements": function(d3) {
+      var body = d3.select("body"),
+          div1 = body.append("div"),
+          div2 = body.append("div");
+      div1.remove();
+      assert.domEqual(div2[0][0].parentNode, body.node());
+    },
+    "ignores null nodes": function(d3) {
+      var div1 = d3.select("body").append("div"),
+          div2 = div1.selectAll("div").data([0, 1]).enter().append("div"),
+          node = div2[0][0];
+      div2[0][0] = null;
+      div2.remove();
+      assert.domEqual(node.parentNode, div1.node());
+      assert.domNull(div2[0][1].parentNode);
+    },
+    "returns the current selection": function(d3) {
+      var div = d3.select("body").append("div");
+      assert.isTrue(div.remove() === div);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,69 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.select");
+
+suite.addBatch({
+  "select": {
+    topic: load("selection/select").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        var body = d3.select("body");
+        body.append("span").attr("class", "f00").attr("id", "b4r").attr("name", "b4z");
+        body.append("div").attr("class", "foo").attr("id", "bar").attr("name", "baz");
+        return d3;
+      },
+      "selects by element name": function(d3) {
+        var div = d3.select("div");
+        assert.equal(div[0][0].tagName, "DIV");
+      },
+      "selects by class name": function(d3) {
+        var div = d3.select(".foo");
+        assert.equal(div[0][0].className, "foo");
+      },
+      "selects by id": function(d3) {
+        var div = d3.select("div#bar");
+        assert.equal(div[0][0].id, "bar");
+      },
+      "selects by attribute value": function(d3) {
+        var div = d3.select("[name=baz]");
+        assert.equal(div[0][0].getAttribute("name"), "baz");
+      },
+      "selects by node": function(d3) {
+        var body = d3.select("body").node(),
+            div = d3.select(body.lastChild);
+        assert.isTrue(div[0][0] === body.lastChild);
+        assert.lengthOf(div, 1);
+        assert.lengthOf(div[0], 1);
+      },
+      "sets the parentNode to the document element": function(d3) {
+        var selection = d3.select("body"),
+            document = d3.selection().node().ownerDocument;
+        assert.strictEqual(selection[0].parentNode, document.documentElement);
+      },
+      "does not propagate data from the document": function(d3) {
+        var document = d3.selection().node().ownerDocument;
+        document.__data__ = 42;
+        delete document.body.__data__;
+        try {
+          assert.isUndefined(d3.select("body").datum());
+        } finally {
+          delete document.__data__;
+        }
+      },
+      "does not propagate data from the document element": function(d3) {
+        var document = d3.selection().node().ownerDocument;
+        document.documentElement.__data__ = 42;
+        delete document.body.__data__;
+        try {
+          assert.isUndefined(d3.select("body").datum());
+        } finally {
+          delete document.documentElement.__data__;
+        }
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,52 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.selectAll");
+
+suite.addBatch({
+  "selectAll": {
+    topic: load("selection/selectAll").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        var body = d3.select("body");
+        body.append("span").attr("class", "f00").attr("id", "b4r").attr("name", "b4z");
+        body.append("div").attr("class", "foo").attr("id", "bar").attr("name", "baz");
+        return d3;
+      },
+      "selects by element name": function(d3) {
+        var div = d3.selectAll("div");
+        assert.equal(div[0][0].tagName, "DIV");
+      },
+      "selects by class name": function(d3) {
+        var div = d3.selectAll(".foo");
+        assert.equal(div[0][0].className, "foo");
+      },
+      "selects by id": function(d3) {
+        var div = d3.selectAll("div#bar");
+        assert.equal(div[0][0].id, "bar");
+      },
+      "selects by attribute value": function(d3) {
+        var div = d3.selectAll("[name=baz]");
+        assert.equal(div[0][0].getAttribute("name"), "baz");
+      },
+      "selects by array": function(d3) {
+        var body = d3.select("body").node(), div = d3.selectAll([body.lastChild]);
+        assert.isTrue(div[0][0] === body.lastChild);
+        assert.lengthOf(div, 1);
+        assert.lengthOf(div[0], 1);
+      },
+      "groups are arrays, not NodeLists": function(d3) {
+        var div = d3.select("body").selectAll(function() { return this.getElementsByClassName("div"); });
+        assert.isTrue(Array.isArray(div[0]));
+      },
+      "sets the parentNode to the document element": function(d3) {
+        var selection = d3.selectAll("body"),
+            document = d3.selection().node().ownerDocument;
+        assert.strictEqual(selection[0].parentNode, document.documentElement);
+      }
+    }
+  }
+});
+
+suite.export(module);