stripchart 0.0.3

data/lib/stripchart/public/components/d3/src/xhr/xml.js

@@ -0,0 +1,5 @@
+import "xhr";
+
+d3.xml = d3_xhrType(function(request) {
+  return request.responseXML;
+});

data/lib/stripchart/public/components/d3/test/XMLHttpRequest.js

@@ -0,0 +1,55 @@
+var fs = require("fs");
+
+global.XMLHttpRequest = function XMLHttpRequest() {
+  var self = this,
+      info = self._info = {},
+      headers = {},
+      url;
+
+  // TODO handle file system errors?
+
+  self.open = function(m, u, a) {
+    info.url = u;
+    info.async = a;
+    self.send = a ? read : readSync;
+  };
+
+  self.setRequestHeader = function(n, v) {
+    if (/^Accept$/i.test(n)) info.mimeType = v.split(/,/g)[0];
+  };
+
+  function read() {
+    fs.readFile(info.url, "binary", function(e, d) {
+      if (e) {
+        self.status = 404; // assumed
+      } else {
+        self.status = 200;
+        self.responseText = d;
+        self.responseXML = {_xml: d};
+        headers["Content-Length"] = d.length;
+      }
+      self.readyState = 4;
+      XMLHttpRequest._last = self;
+      if (self.onreadystatechange) self.onreadystatechange();
+    });
+  }
+
+  function readSync() {
+    try {
+      var d = fs.readFileSync(info.url, "binary");
+      self.status = 200;
+      self.responseText = d;
+      self.responseXML = {_xml: d};
+      headers["Content-Length"] = d.length;
+    } catch (e) {
+      self.status = 404; // assumed
+    }
+    self.readyState = 4;
+    XMLHttpRequest._last = self;
+    if (self.onreadystatechange) self.onreadystatechange();
+  }
+
+  self.getResponseHeader = function(n) {
+    return headers[n];
+  };
+};

data/lib/stripchart/public/components/d3/test/arrays/ascending-test.js

@@ -0,0 +1,45 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.ascending");
+
+suite.addBatch({
+  "d3.ascending": {
+    topic: load("arrays/ascending").expression("d3.ascending"),
+    "numbers": {
+      "returns a negative number if a < b": function(ascending) {
+        assert.isTrue(ascending(0, 1) < 0);
+      },
+      "returns a positive number if a > b": function(ascending) {
+        assert.isTrue(ascending(1, 0) > 0);
+      },
+      "returns zero if a == b": function(ascending) {
+        assert.equal(ascending(0, 0), 0);
+      },
+      "returns NaN if a or b is undefined": function(ascending) {
+        assert.isNaN(ascending(0, undefined));
+        assert.isNaN(ascending(undefined, 0));
+        assert.isNaN(ascending(undefined, undefined));
+      },
+      "returns NaN if a or b is NaN": function(ascending) {
+        assert.isNaN(ascending(0, NaN));
+        assert.isNaN(ascending(NaN, 0));
+        assert.isNaN(ascending(NaN, NaN));
+      }
+    },
+    "strings": {
+      "returns a negative number if a < b": function(ascending) {
+        assert.isTrue(ascending("a", "b") < 0);
+      },
+      "returns a positive number if a > b": function(ascending) {
+        assert.isTrue(ascending("b", "a") > 0);
+      },
+      "returns zero if a == b": function(ascending) {
+        assert.equal(ascending("a", "a"), 0);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/arrays/bisect-test.js

@@ -0,0 +1,257 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.bisect");
+
+var i30 = 1 << 30;
+
+suite.addBatch({
+  "bisectLeft": {
+    topic: load("arrays/bisect").expression("d3.bisectLeft"),
+    "finds the index of an exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 1), 0);
+      assert.equal(bisect(array, 2), 1);
+      assert.equal(bisect(array, 3), 2);
+    },
+    "finds the index of the first match": function(bisect) {
+      var array = [1, 2, 2, 3];
+      assert.equal(bisect(array, 1), 0);
+      assert.equal(bisect(array, 2), 1);
+      assert.equal(bisect(array, 3), 3);
+    },
+    "finds the insertion point of a non-exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 0.5), 0);
+      assert.equal(bisect(array, 1.5), 1);
+      assert.equal(bisect(array, 2.5), 2);
+      assert.equal(bisect(array, 3.5), 3);
+    },
+    "has undefined behavior if the search value is unorderable": function(bisect) {
+      var array = [1, 2, 3];
+      bisect(array, new Date(NaN)); // who knows what this will return!
+      bisect(array, undefined);
+      bisect(array, NaN);
+    },
+    "observes the optional lower bound": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2), 2);
+      assert.equal(bisect(array, 1, 2), 2);
+      assert.equal(bisect(array, 2, 2), 2);
+      assert.equal(bisect(array, 3, 2), 2);
+      assert.equal(bisect(array, 4, 2), 3);
+      assert.equal(bisect(array, 5, 2), 4);
+      assert.equal(bisect(array, 6, 2), 5);
+    },
+    "observes the optional bounds": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2, 3), 2);
+      assert.equal(bisect(array, 1, 2, 3), 2);
+      assert.equal(bisect(array, 2, 2, 3), 2);
+      assert.equal(bisect(array, 3, 2, 3), 2);
+      assert.equal(bisect(array, 4, 2, 3), 3);
+      assert.equal(bisect(array, 5, 2, 3), 3);
+      assert.equal(bisect(array, 6, 2, 3), 3);
+    },
+    "large arrays": function(bisect) {
+      var array = [],
+          i = i30;
+      array[i++] = 1;
+      array[i++] = 2;
+      array[i++] = 3;
+      array[i++] = 4;
+      array[i++] = 5;
+      assert.equal(bisect(array, 0, i - 5, i), i - 5);
+      assert.equal(bisect(array, 1, i - 5, i), i - 5);
+      assert.equal(bisect(array, 2, i - 5, i), i - 4);
+      assert.equal(bisect(array, 3, i - 5, i), i - 3);
+      assert.equal(bisect(array, 4, i - 5, i), i - 2);
+      assert.equal(bisect(array, 5, i - 5, i), i - 1);
+      assert.equal(bisect(array, 6, i - 5, i), i - 0);
+    }
+  },
+  "bisectRight": {
+    topic: load("arrays/bisect").expression("d3.bisectRight"),
+    "finds the index after an exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 1), 1);
+      assert.equal(bisect(array, 2), 2);
+      assert.equal(bisect(array, 3), 3);
+    },
+    "finds the index after the last match": function(bisect) {
+      var array = [1, 2, 2, 3];
+      assert.equal(bisect(array, 1), 1);
+      assert.equal(bisect(array, 2), 3);
+      assert.equal(bisect(array, 3), 4);
+    },
+    "finds the insertion point of a non-exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 0.5), 0);
+      assert.equal(bisect(array, 1.5), 1);
+      assert.equal(bisect(array, 2.5), 2);
+      assert.equal(bisect(array, 3.5), 3);
+    },
+    "observes the optional lower bound": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2), 2);
+      assert.equal(bisect(array, 1, 2), 2);
+      assert.equal(bisect(array, 2, 2), 2);
+      assert.equal(bisect(array, 3, 2), 3);
+      assert.equal(bisect(array, 4, 2), 4);
+      assert.equal(bisect(array, 5, 2), 5);
+      assert.equal(bisect(array, 6, 2), 5);
+    },
+    "observes the optional bounds": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2, 3), 2);
+      assert.equal(bisect(array, 1, 2, 3), 2);
+      assert.equal(bisect(array, 2, 2, 3), 2);
+      assert.equal(bisect(array, 3, 2, 3), 3);
+      assert.equal(bisect(array, 4, 2, 3), 3);
+      assert.equal(bisect(array, 5, 2, 3), 3);
+      assert.equal(bisect(array, 6, 2, 3), 3);
+    },
+    "large arrays": function(bisect) {
+      var array = [],
+          i = i30;
+      array[i++] = 1;
+      array[i++] = 2;
+      array[i++] = 3;
+      array[i++] = 4;
+      array[i++] = 5;
+      assert.equal(bisect(array, 0, i - 5, i), i - 5);
+      assert.equal(bisect(array, 1, i - 5, i), i - 4);
+      assert.equal(bisect(array, 2, i - 5, i), i - 3);
+      assert.equal(bisect(array, 3, i - 5, i), i - 2);
+      assert.equal(bisect(array, 4, i - 5, i), i - 1);
+      assert.equal(bisect(array, 5, i - 5, i), i - 0);
+      assert.equal(bisect(array, 6, i - 5, i), i - 0);
+    }
+  },
+  "bisector(key)": {
+    topic: load("arrays/bisect").expression("d3.bisector"),
+    "left": {
+      topic: function(bisector) {
+        return bisector(function(d) { return d.key; }).left;
+      },
+      "finds the index of an exact match": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}];
+        assert.equal(bisect(array, 1), 0);
+        assert.equal(bisect(array, 2), 1);
+        assert.equal(bisect(array, 3), 2);
+      },
+      "finds the index of the first match": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 2}, {key: 3}];
+        assert.equal(bisect(array, 1), 0);
+        assert.equal(bisect(array, 2), 1);
+        assert.equal(bisect(array, 3), 3);
+      },
+      "finds the insertion point of a non-exact match": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}];
+        assert.equal(bisect(array, 0.5), 0);
+        assert.equal(bisect(array, 1.5), 1);
+        assert.equal(bisect(array, 2.5), 2);
+        assert.equal(bisect(array, 3.5), 3);
+      },
+      "observes the optional lower bound": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}, {key: 4}, {key: 5}];
+        assert.equal(bisect(array, 0, 2), 2);
+        assert.equal(bisect(array, 1, 2), 2);
+        assert.equal(bisect(array, 2, 2), 2);
+        assert.equal(bisect(array, 3, 2), 2);
+        assert.equal(bisect(array, 4, 2), 3);
+        assert.equal(bisect(array, 5, 2), 4);
+        assert.equal(bisect(array, 6, 2), 5);
+      },
+      "observes the optional bounds": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}, {key: 4}, {key: 5}];
+        assert.equal(bisect(array, 0, 2, 3), 2);
+        assert.equal(bisect(array, 1, 2, 3), 2);
+        assert.equal(bisect(array, 2, 2, 3), 2);
+        assert.equal(bisect(array, 3, 2, 3), 2);
+        assert.equal(bisect(array, 4, 2, 3), 3);
+        assert.equal(bisect(array, 5, 2, 3), 3);
+        assert.equal(bisect(array, 6, 2, 3), 3);
+      },
+      "large arrays": function(bisect) {
+        var array = [],
+            i = i30;
+        array[i++] = {key: 1};
+        array[i++] = {key: 2};
+        array[i++] = {key: 3};
+        array[i++] = {key: 4};
+        array[i++] = {key: 5};
+        assert.equal(bisect(array, 0, i - 5, i), i - 5);
+        assert.equal(bisect(array, 1, i - 5, i), i - 5);
+        assert.equal(bisect(array, 2, i - 5, i), i - 4);
+        assert.equal(bisect(array, 3, i - 5, i), i - 3);
+        assert.equal(bisect(array, 4, i - 5, i), i - 2);
+        assert.equal(bisect(array, 5, i - 5, i), i - 1);
+        assert.equal(bisect(array, 6, i - 5, i), i - 0);
+      }
+    },
+    "right": {
+      topic: function(bisector) {
+        return bisector(function(d) { return d.key; }).right;
+      },
+      "finds the index after an exact match": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}];
+        assert.equal(bisect(array, 1), 1);
+        assert.equal(bisect(array, 2), 2);
+        assert.equal(bisect(array, 3), 3);
+      },
+      "finds the index after the last match": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 2}, {key: 3}];
+        assert.equal(bisect(array, 1), 1);
+        assert.equal(bisect(array, 2), 3);
+        assert.equal(bisect(array, 3), 4);
+      },
+      "finds the insertion point of a non-exact match": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}];
+        assert.equal(bisect(array, 0.5), 0);
+        assert.equal(bisect(array, 1.5), 1);
+        assert.equal(bisect(array, 2.5), 2);
+        assert.equal(bisect(array, 3.5), 3);
+      },
+      "observes the optional lower bound": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}, {key: 4}, {key: 5}];
+        assert.equal(bisect(array, 0, 2), 2);
+        assert.equal(bisect(array, 1, 2), 2);
+        assert.equal(bisect(array, 2, 2), 2);
+        assert.equal(bisect(array, 3, 2), 3);
+        assert.equal(bisect(array, 4, 2), 4);
+        assert.equal(bisect(array, 5, 2), 5);
+        assert.equal(bisect(array, 6, 2), 5);
+      },
+      "observes the optional bounds": function(bisect) {
+        var array = [{key: 1}, {key: 2}, {key: 3}, {key: 4}, {key: 5}];
+        assert.equal(bisect(array, 0, 2, 3), 2);
+        assert.equal(bisect(array, 1, 2, 3), 2);
+        assert.equal(bisect(array, 2, 2, 3), 2);
+        assert.equal(bisect(array, 3, 2, 3), 3);
+        assert.equal(bisect(array, 4, 2, 3), 3);
+        assert.equal(bisect(array, 5, 2, 3), 3);
+        assert.equal(bisect(array, 6, 2, 3), 3);
+      },
+      "large arrays": function(bisect) {
+        var array = [],
+            i = i30;
+        array[i++] = {key: 1};
+        array[i++] = {key: 2};
+        array[i++] = {key: 3};
+        array[i++] = {key: 4};
+        array[i++] = {key: 5};
+        assert.equal(bisect(array, 0, i - 5, i), i - 5);
+        assert.equal(bisect(array, 1, i - 5, i), i - 4);
+        assert.equal(bisect(array, 2, i - 5, i), i - 3);
+        assert.equal(bisect(array, 3, i - 5, i), i - 2);
+        assert.equal(bisect(array, 4, i - 5, i), i - 1);
+        assert.equal(bisect(array, 5, i - 5, i), i - 0);
+        assert.equal(bisect(array, 6, i - 5, i), i - 0);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/arrays/descending-test.js

@@ -0,0 +1,45 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.descending");
+
+suite.addBatch({
+  "descending": {
+    topic: load("arrays/descending").expression("d3.descending"),
+    "numbers": {
+      "returns a negative number if a > b": function(descending) {
+        assert.isTrue(descending(1, 0) < 0);
+      },
+      "returns a positive number if a < b": function(descending) {
+        assert.isTrue(descending(0, 1) > 0);
+      },
+      "returns zero if a == b": function(descending) {
+        assert.equal(descending(0, 0), 0);
+      },
+      "returns NaN if a or b is undefined": function(descending) {
+        assert.isNaN(descending(0, undefined));
+        assert.isNaN(descending(undefined, 0));
+        assert.isNaN(descending(undefined, undefined));
+      },
+      "returns NaN if a or b is NaN": function(descending) {
+        assert.isNaN(descending(0, NaN));
+        assert.isNaN(descending(NaN, 0));
+        assert.isNaN(descending(NaN, NaN));
+      }
+    },
+    "strings": {
+      "returns a negative number if a > b": function(descending) {
+        assert.isTrue(descending("b", "a") < 0);
+      },
+      "returns a positive number if a < b": function(descending) {
+        assert.isTrue(descending("a", "b") > 0);
+      },
+      "returns zero if a == b": function(descending) {
+        assert.equal(descending("a", "a"), 0);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/arrays/entries-test.js

@@ -0,0 +1,39 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.entries");
+
+suite.addBatch({
+  "entries": {
+    topic: load("arrays/entries").expression("d3.entries"),
+    "enumerates every entry": function(entries) {
+      assert.deepEqual(entries({a: 1, b: 2}), [
+        {key: "a", value: 1},
+        {key: "b", value: 2}
+      ]);
+    },
+    "includes entries defined on prototypes": function(entries) {
+      function abc() {
+        this.a = 1;
+        this.b = 2;
+      }
+      abc.prototype.c = 3;
+      assert.deepEqual(entries(new abc()), [
+        {key: "a", value: 1},
+        {key: "b", value: 2},
+        {key: "c", value: 3}
+      ]);
+    },
+    "includes null or undefined values": function(entries) {
+      var v = entries({a: undefined, b: null, c: NaN});
+      assert.equal(v.length, 3);
+      assert.deepEqual(v[0], {key: "a", value: undefined});
+      assert.deepEqual(v[1], {key: "b", value: null});
+      assert.equal(v[2].key, "c");
+      assert.isNaN(v[2].value);
+    }
+  }
+});
+
+suite.export(module);