stripmem 0.0.1

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

data/lib/stripmem/public/components/d3/test/arrays/extent-test.js

@@ -0,0 +1,50 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.extent");
+
+suite.addBatch({
+  "extent": {
+    topic: load("arrays/extent").expression("d3.extent"),
+    "returns the numeric extent for numbers": function(extent) {
+      assert.deepEqual(extent([1]), [1, 1]);
+      assert.deepEqual(extent([5, 1, 2, 3, 4]), [1, 5]);
+      assert.deepEqual(extent([20, 3]), [3, 20]);
+      assert.deepEqual(extent([3, 20]), [3, 20]);
+    },
+    "returns the lexicographic extent for strings": function(extent) {
+      assert.deepEqual(extent(["c", "a", "b"]), ["a", "c"]);
+      assert.deepEqual(extent(["20", "3"]), ["20", "3"]);
+      assert.deepEqual(extent(["3", "20"]), ["20", "3"]);
+    },
+    "ignores null, undefined and NaN": function(extent) {
+      var o = {valueOf: function() { return NaN; }};
+      assert.deepEqual(extent([NaN, 1, 2, 3, 4, 5]), [1, 5]);
+      assert.deepEqual(extent([o, 1, 2, 3, 4, 5]), [1, 5]);
+      assert.deepEqual(extent([1, 2, 3, 4, 5, NaN]), [1, 5]);
+      assert.deepEqual(extent([1, 2, 3, 4, 5, o]), [1, 5]);
+      assert.deepEqual(extent([10, null, 3, undefined, 5, NaN]), [3, 10]);
+      assert.deepEqual(extent([-1, null, -3, undefined, -5, NaN]), [-5, -1]);
+    },
+    "compares heterogenous types as numbers": function(extent) {
+      assert.deepEqual(extent([20, "3"]), ["3", 20]);
+      assert.deepEqual(extent(["20", 3]), [3, "20"]);
+      assert.deepEqual(extent([3, "20"]), [3, "20"]);
+      assert.deepEqual(extent(["3", 20]), ["3", 20]);
+    },
+    "returns undefined for empty array": function(extent) {
+      assert.deepEqual(extent([]), [undefined, undefined]);
+      assert.deepEqual(extent([null]), [undefined, undefined]);
+      assert.deepEqual(extent([undefined]), [undefined, undefined]);
+      assert.deepEqual(extent([NaN]), [undefined, undefined]);
+      assert.deepEqual(extent([NaN, NaN]), [undefined, undefined]);
+    },
+    "applies the optional accessor function exactly once": function(extent) {
+      var i = 10;
+      assert.deepEqual(extent([0,1,2,3], function() { return ++i; }), [11, 14]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/keys-test.js

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