stripchart 0.0.3

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

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

@@ -0,0 +1,214 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.map");
+
+suite.addBatch({
+  "map": {
+    topic: load("arrays/map").expression("d3.map"),
+    "constructor": {
+      "map() returns an empty map": function(map) {
+        var m = map();
+        assert.deepEqual(m.keys(), []);
+      },
+      "map(null) returns an empty map": function(map) {
+        var m = map(null);
+        assert.deepEqual(m.keys(), []);
+      },
+      "map(object) copies enumerable keys": function(map) {
+        var m = map({foo: 42});
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+        var m = map(Object.create(null, {foo: {value: 42, enumerable: true}}));
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+      },
+      "map(object) copies inherited keys": function(map) {
+        function Foo() {}
+        Foo.prototype.foo = 42;
+        var m = map(Object.create({foo: 42}));
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+        var m = map(new Foo());
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+      },
+      "map(object) does not copy non-enumerable keys": function(map) {
+        var m = map({__proto__: 42}); // because __proto__ isn't enumerable
+        assert.isFalse(m.has("__proto__"));
+        assert.isUndefined(m.get("__proto__"));
+        var m = map(Object.create(null, {foo: {value: 42, enumerable: false}}));
+        assert.isFalse(m.has("foo"));
+        assert.isUndefined(m.get("foo"));
+      }
+    },
+    "forEach": {
+      "empty maps have an empty keys array": function(map) {
+        var m = map();
+        assert.deepEqual(m.entries(), []);
+        m.set("foo", "bar");
+        assert.deepEqual(m.entries(), [{key: "foo", value: "bar"}]);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), []);
+      },
+      "keys are returned in arbitrary order": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+        var m = map({bar: "42", foo: 1});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+      },
+      "observes changes via set and remove": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), [{key: "bar", value: "42"}]);
+        m.set("bar", "bar");
+        assert.deepEqual(m.entries(), [{key: "bar", value: "bar"}]);
+        m.set("foo", "foo");
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "bar"}, {key: "foo", value: "foo"}]);
+        m.remove("bar");
+        assert.deepEqual(m.entries(), [{key: "foo", value: "foo"}]);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), []);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), []);
+      }
+    },
+    "keys": {
+      "returns an array of string keys": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.keys().sort(), ["bar", "foo"]);
+      }
+    },
+    "values": {
+      "returns an array of arbitrary values": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.values().sort(), [1, "42"]);
+      }
+    },
+    "entries": {
+      "returns an array of key-value objects": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+      }
+    },
+    "has": {
+      "empty maps do not have object built-ins": function(map) {
+        var m = map();
+        assert.isFalse(m.has("__proto__"));
+        assert.isFalse(m.has("hasOwnProperty"));
+      },
+      "can has keys using built-in names": function(map) {
+        var m = map();
+        m.set("__proto__", 42);
+        assert.isTrue(m.has("__proto__"));
+      },
+      "can has keys with null or undefined properties": function(map) {
+        var m = map();
+        m.set("", "");
+        m.set("null", null);
+        m.set("undefined", undefined);
+        assert.isTrue(m.has(""));
+        assert.isTrue(m.has("null"));
+        assert.isTrue(m.has("undefined"));
+      },
+      "coerces keys to strings": function(map) {
+        var m = map({"42": "foo", "null": 1, "undefined": 2});
+        assert.isTrue(m.has(42));
+        assert.isTrue(m.has(null));
+        assert.isTrue(m.has(undefined));
+      },
+      "returns the latest value": function(map) {
+        var m = map({foo: 42});
+        assert.isTrue(m.has("foo"));
+        m.set("foo", 43);
+        assert.isTrue(m.has("foo"));
+        m.remove("foo");
+        assert.isFalse(m.has("foo"));
+        m.set("foo", "bar");
+        assert.isTrue(m.has("foo"));
+      },
+      "returns undefined for missing keys": function(map) {
+        var m = map({foo: 42});
+        assert.isFalse(m.has("bar"));
+      }
+    },
+    "get": {
+      "empty maps do not have object built-ins": function(map) {
+        var m = map();
+        assert.isUndefined(m.get("__proto__"));
+        assert.isUndefined(m.get("hasOwnProperty"));
+      },
+      "can get keys using built-in names": function(map) {
+        var m = map();
+        m.set("__proto__", 42);
+        assert.equal(m.get("__proto__"), 42);
+      },
+      "coerces keys to strings": function(map) {
+        var m = map({"42": 1, "null": 2, "undefined": 3});
+        assert.equal(m.get(42), 1);
+        assert.equal(m.get(null), 2);
+        assert.equal(m.get(undefined), 3);
+      },
+      "returns the latest value": function(map) {
+        var m = map({foo: 42});
+        assert.equal(m.get("foo"), 42);
+        m.set("foo", 43);
+        assert.equal(m.get("foo"), 43);
+        m.remove("foo");
+        assert.isUndefined(m.get("foo"));
+        m.set("foo", "bar");
+        assert.equal(m.get("foo"), "bar");
+      },
+      "returns undefined for missing keys": function(map) {
+        var m = map({foo: 42});
+        assert.isUndefined(m.get("bar"));
+      }
+    },
+    "set": {
+      "returns the set value": function(map) {
+        var m = map();
+        assert.equal(m.set("foo", 42), 42);
+      },
+      "can set keys using built-in names": function(map) {
+        var m = map();
+        m.set("__proto__", 42);
+        assert.equal(m.get("__proto__"), 42);
+      },
+      "coerces keys to strings": function(map) {
+        var m = map();
+        m.set(42, 1);
+        assert.equal(m.get(42), 1);
+        m.set(null, 2);
+        assert.equal(m.get(null), 2);
+        m.set(undefined, 3);
+        assert.equal(m.get(undefined), 3);
+        assert.deepEqual(m.keys().sort(), ["42", "null", "undefined"]);
+      },
+      "can replace values": function(map) {
+        var m = map({foo: 42});
+        assert.equal(m.get("foo"), 42);
+        m.set("foo", 43);
+        assert.equal(m.get("foo"), 43);
+        m.set("foo", "bar");
+        assert.equal(m.get("foo"), "bar");
+      },
+      "can set null, undefined or empty string values": function(map) {
+        var m = map();
+        m.set("", "");
+        m.set("null", null);
+        m.set("undefined", undefined);
+        assert.equal(m.get(""), "");
+        assert.isNull(m.get("null"));
+        assert.isUndefined(m.get("undefined"));
+      }
+    }
+  }
+});
+
+function ascendingByKey(a, b) {
+  return a.key.localeCompare(b.key);
+}
+
+suite.export(module);

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

@@ -0,0 +1,51 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.max");
+
+suite.addBatch({
+  "max": {
+    topic: load("arrays/max").expression("d3.max"),
+    "returns the greatest numeric value for numbers": function(max) {
+      assert.equal(max([1]), 1);
+      assert.equal(max([5, 1, 2, 3, 4]), 5);
+      assert.equal(max([20, 3]), 20);
+      assert.equal(max([3, 20]), 20);
+    },
+    "returns the greatest lexicographic value for strings": function(max) {
+      assert.equal(max(["c", "a", "b"]), "c");
+      assert.equal(max(["20", "3"]), "3");
+      assert.equal(max(["3", "20"]), "3");
+    },
+    "ignores null, undefined and NaN": function(max) {
+      var o = {valueOf: function() { return NaN; }};
+      assert.equal(max([NaN, 1, 2, 3, 4, 5]), 5);
+      assert.equal(max([o, 1, 2, 3, 4, 5]), 5);
+      assert.equal(max([1, 2, 3, 4, 5, NaN]), 5);
+      assert.equal(max([1, 2, 3, 4, 5, o]), 5);
+      assert.equal(max([10, null, 3, undefined, 5, NaN]), 10);
+      assert.equal(max([-1, null, -3, undefined, -5, NaN]), -1);
+    },
+    "compares heterogenous types as numbers": function(max) {
+      assert.strictEqual(max([20, "3"]), 20);
+      assert.strictEqual(max(["20", 3]), "20");
+      assert.strictEqual(max([3, "20"]), "20");
+      assert.strictEqual(max(["3", 20]), 20);
+    },
+    "returns undefined for empty array": function(max) {
+      assert.isUndefined(max([]));
+      assert.isUndefined(max([null]));
+      assert.isUndefined(max([undefined]));
+      assert.isUndefined(max([NaN]));
+      assert.isUndefined(max([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(max) {
+      assert.equal(max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.min(d); }), 2);
+      assert.equal(max([1, 2, 3, 4, 5], function(d, i) { return i; }), 4);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,39 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.mean");
+
+suite.addBatch({
+  "mean": {
+    topic: load("arrays/mean").expression("d3.mean"),
+    "returns the mean value for numbers": function(mean) {
+      assert.equal(mean([1]), 1);
+      assert.equal(mean([5, 1, 2, 3, 4]), 3);
+      assert.equal(mean([20, 3]), 11.5);
+      assert.equal(mean([3, 20]), 11.5);
+    },
+    "ignores null, undefined and NaN": function(mean) {
+      assert.equal(mean([NaN, 1, 2, 3, 4, 5]), 3);
+      assert.equal(mean([1, 2, 3, 4, 5, NaN]), 3);
+      assert.equal(mean([10, null, 3, undefined, 5, NaN]), 6);
+    },
+    "can handle large numbers without overflowing": function(mean) {
+      assert.equal(mean([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
+      assert.equal(mean([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE);
+    },
+    "returns undefined for empty array": function(mean) {
+      assert.isUndefined(mean([]));
+      assert.isUndefined(mean([null]));
+      assert.isUndefined(mean([undefined]));
+      assert.isUndefined(mean([NaN]));
+      assert.isUndefined(mean([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(mean) {
+      assert.equal(mean([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return mean(d); }), 4.5);
+      assert.equal(mean([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,39 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.median");
+
+suite.addBatch({
+  "median": {
+    topic: load("arrays/median").expression("d3.median"),
+    "returns the median value for numbers": function(median) {
+      assert.equal(median([1]), 1);
+      assert.equal(median([5, 1, 2, 3, 4]), 3);
+      assert.equal(median([20, 3]), 11.5);
+      assert.equal(median([3, 20]), 11.5);
+    },
+    "ignores null, undefined and NaN": function(median) {
+      assert.equal(median([NaN, 1, 2, 3, 4, 5]), 3);
+      assert.equal(median([1, 2, 3, 4, 5, NaN]), 3);
+      assert.equal(median([10, null, 3, undefined, 5, NaN]), 5);
+    },
+    "can handle large numbers without overflowing": function(median) {
+      assert.equal(median([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
+      assert.equal(median([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE);
+    },
+    "returns undefined for empty array": function(median) {
+      assert.isUndefined(median([]));
+      assert.isUndefined(median([null]));
+      assert.isUndefined(median([undefined]));
+      assert.isUndefined(median([NaN]));
+      assert.isUndefined(median([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(median) {
+      assert.equal(median([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return median(d); }), 4.5);
+      assert.equal(median([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.merge");
+
+suite.addBatch({
+  "merge": {
+    topic: load("arrays/merge").expression("d3.merge"),
+    "merges an array of arrays": function(merge) {
+      var a = {}, b = {}, c = {}, d = {}, e = {}, f = {};
+      assert.deepEqual(merge([[a], [b, c], [d, e, f]]), [a, b, c, d, e, f]);
+    },
+    "returns a new array": function(merge) {
+      var input = [[1, 2, 3], [4, 5], [6]];
+      assert.isFalse(merge(input) === input);
+    },
+    "does not modify the input arrays": function(merge) {
+      var input = [[1, 2, 3], [4, 5], [6]];
+      merge(input);
+      assert.deepEqual(input, [[1, 2, 3], [4, 5], [6]]);
+    }
+  }
+});
+
+suite.export(module);