stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/interpolate/hcl-test.js

@@ -0,0 +1,47 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateHcl");
+
+suite.addBatch({
+  "interpolateHcl": {
+    topic: load("interpolate/hcl"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.2), -69.78, 46.87, 52.62);
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.6), -14.89, 75.71, 52.93);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.hclEqual(d3.interpolateHcl(d3.hsl("steelblue"), "#f00")(.2), -69.78, 46.87, 52.62);
+      assert.hclEqual(d3.interpolateHcl("steelblue", d3.hsl(0, 1, .5))(.6), -14.89, 75.71, 52.93);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.hclEqual(d3.interpolateHcl(d3.rgb("steelblue"), "#f00")(.2), -69.78, 46.87, 52.62);
+      assert.hclEqual(d3.interpolateHcl("steelblue", d3.rgb(255, 0, 0))(.6), -14.89, 75.71, 52.93);
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.2), -69.78, 46.87, 52.62);
+    },
+    "uses source hue when destination hue is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#f60", "#000")(.5), 52.36, 90.07, 31.16);
+      assert.hclEqual(d3.interpolateHcl("#6f0", "#000")(.5), 131.26, 112.84, 44.54);
+    },
+    "uses destination hue when source hue is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#000", "#f60")(.5), 52.36, 90.07, 31.16);
+      assert.hclEqual(d3.interpolateHcl("#000", "#6f0")(.5), 131.26, 112.84, 44.54);
+    },
+    "uses source chroma when destination chroma is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#ccc", "#000")(.5), 158.20, 0.00, 41.02);
+      assert.hclEqual(d3.interpolateHcl("#f00", "#000")(.5), 40.00, 104.55, 26.62);
+    },
+    "uses destination chroma when source chroma is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#000", "#ccc")(.5), 158.20, 0.00, 41.02);
+      assert.hclEqual(d3.interpolateHcl("#000", "#f00")(.5), 40.00, 104.55, 26.62);
+    },
+    "returns an instanceof d3.hcl": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.2), -69.78, 46.87, 52.62);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/hsl-test.js

@@ -0,0 +1,47 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateHsl");
+
+suite.addBatch({
+  "interpolateHsl": {
+    topic: load("interpolate/hsl"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.2), 237.82, 0.5538, 0.4922);
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.6), 298.91, 0.7787, 0.4961);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.hslEqual(d3.interpolateHsl(d3.hsl("steelblue"), "#f00")(.2), 237.82, 0.5538, 0.4922);
+      assert.hslEqual(d3.interpolateHsl("steelblue", d3.hsl(0, 1, .5))(.6), 298.91, 0.7787, 0.4961);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.hslEqual(d3.interpolateHsl(d3.rgb("steelblue"), "#f00")(.2), 237.82, 0.5538, 0.4922);
+      assert.hslEqual(d3.interpolateHsl("steelblue", d3.rgb(255, 0, 0))(.6), 298.91, 0.7787, 0.4961);
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.2), 237.82, 0.5538, 0.4922);
+    },
+    "uses source hue when destination hue is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#f60", "#000")(.5), 24, 1, 0.2510);
+      assert.hslEqual(d3.interpolateHsl("#6f0", "#fff")(.5), 96, 1, 0.7510);
+    },
+    "uses destination hue when source hue is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#000", "#f60")(.5), 24, 1, 0.2510);
+      assert.hslEqual(d3.interpolateHsl("#fff", "#6f0")(.5), 96, 1, 0.7510);
+    },
+    "uses source saturation when destination saturation is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#ccc", "#000")(.5), NaN, 0, 0.4);
+      assert.hslEqual(d3.interpolateHsl("#f00", "#000")(.5), 0, 1, 0.2510);
+    },
+    "uses destination saturation when source saturation is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#000", "#ccc")(.5), NaN, 0, 0.4);
+      assert.hslEqual(d3.interpolateHsl("#000", "#f00")(.5), 0, 1, 0.2510);
+    },
+    "returns an instanceof d3.hsl": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.6), 298.91, 0.7787, 0.4961);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/interpolate-test.js

@@ -0,0 +1,157 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolate");
+
+suite.addBatch({
+  "interpolate": {
+    topic: load("interpolate/interpolate"),
+
+    "when b is a number": {
+      "interpolates numbers": function(d3) {
+        assert.strictEqual(d3.interpolate(2, 12)(.4), 6);
+      },
+      "coerces a to a number": function(d3) {
+        assert.strictEqual(d3.interpolate("", 1)(.5), .5);
+        assert.strictEqual(d3.interpolate("2", 12)(.4), 6);
+        assert.strictEqual(d3.interpolate([2], 12)(.4), 6);
+      }
+    },
+
+    "when b is a color string": {
+      "interpolates RGB values": function(d3) {
+        assert.rgbEqual(d3.interpolate("#ff0000", "#008000")(.4), 153, 51, 0);
+      },
+      "interpolates named colors in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate("red", "green")(.4), 153, 51, 0);
+      },
+      "interpolates decimal RGB colors in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate("rgb(255,0,0)", "rgb(0,128,0)")(.4), 153, 51, 0);
+      },
+      "interpolates decimal HSL colors in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate("hsl(0,100%,50%)", "hsl(120,100%,25%)")(.4), 153, 51, 0);
+      },
+      "coerces a to a color": function(d3) {
+        assert.rgbEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), 153, 51, 0);
+      },
+      "returns an instanceof d3.rgb": function(d3) {
+        assert.rgbEqual(d3.interpolate("steelblue", "#f00")(.2), 107, 104, 144);
+      }
+    },
+
+    "when b is a color object": {
+      "interpolates RGB values and returns a hexadecimal string": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.rgb(255, 0, 0), d3.rgb(0, 128, 0))(.4), 153, 51, 0);
+      },
+      "interpolates d3.hsl in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.hsl("red"), d3.hsl("green"))(.4), 153, 51, 0);
+      },
+      "interpolates d3.lab in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.lab("red"), d3.lab("green"))(.4), 153, 51, 0);
+      },
+      "interpolates d3.hcl in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.hcl("red"), d3.hcl("green"))(.4), 153, 51, 0);
+      },
+      "coerces a to a color": function(d3) {
+        assert.rgbEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), 153, 51, 0);
+      },
+      "returns an instanceof d3.rgb": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.rgb("steelblue"), d3.rgb("#f00"))(.2), 107, 104, 144);
+      }
+    },
+
+    "when b is a string": {
+      "interpolates matching numbers in both strings": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 ");
+      },
+      "if b is coercible to a number, still returns a string": function(d3) {
+        assert.strictEqual(d3.interpolate("1.", "2.")(.5), "1.5");
+        assert.strictEqual(d3.interpolate("1e+3", "1e+4")(.5), "5500");
+      },
+      "preserves non-numbers in string b": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo ");
+      },
+      "preserves non-matching numbers in string b": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 ");
+      },
+      "preserves equal-value numbers in both strings": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 ");
+      },
+      "coerces a to a string": function(d3) {
+        assert.strictEqual(d3.interpolate({toString: function() { return "1."; }}, "2.")(.5), "1.5");
+      }
+    },
+
+    "when b is an array": {
+      "interpolates each element in b": function(d3) {
+        assert.strictEqual(JSON.stringify(d3.interpolate([2, 4], [12, 24])(.4)), "[6,12]");
+      },
+      "interpolates arrays, even when both a and b are coercible to numbers": function(d3) {
+        assert.strictEqual(JSON.stringify(d3.interpolate([2], [12])(.4)), "[6]");
+        assert.strictEqual(JSON.stringify(d3.interpolate([[2]], [[12]])(.4)), "[[6]]");
+      },
+      "reuses the returned array during interpolation": function(d3) {
+        var i = d3.interpolate([2], [12]);
+        assert.strictEqual(i(.2), i(.4));
+      }
+    },
+
+    "when b is an object": {
+      "interpolates each property in b": function(d3) {
+        assert.deepEqual(d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24})(.4), {foo: 6, bar: 12});
+      },
+      "interpolates arrays, even when both a and b are coercible to numbers": function(d3) {
+        var two = new Number(2), twelve = new Number(12);
+        two.foo = "2px";
+        twelve.foo = "12px";
+        assert.deepEqual(d3.interpolate(two, twelve)(.4), {foo: "6px"});
+      },
+      "reuses the returned object during interpolation": function(d3) {
+        var i = d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24});
+        assert.strictEqual(i(.2), i(.4));
+      }
+    },
+
+    "may or may not interpolate between enumerable and non-enumerable properties": function(d3) {
+      var a = Object.create({}, {foo: {value: 1, enumerable: true}}),
+          b = Object.create({}, {foo: {value: 2, enumerable: false}});
+      try {
+        assert.deepEqual(d3.interpolate(a, b)(1), {});
+      } catch (e) {
+        assert.deepEqual(d3.interpolate(a, b)(1), {foo: 2});
+      }
+      try {
+        assert.deepEqual(d3.interpolate(b, a)(1), {});
+      } catch (e) {
+        assert.deepEqual(d3.interpolate(b, a)(1), {foo: 1});
+      }
+    },
+    "interpolates inherited properties of objects": function(d3) {
+      var a = Object.create({foo: 0}),
+          b = Object.create({foo: 2});
+      assert.deepEqual(d3.interpolate(a, b)(.5), {foo: 1});
+    },
+    "doesn't interpret properties in the default object's prototype chain as RGB": function(d3) {
+      assert.equal(d3.interpolate("hasOwnProperty", "hasOwnProperty")(0), "hasOwnProperty");
+    }
+  },
+
+  "interpolators": {
+    topic: load("interpolate/interpolate").document(),
+    "can register a custom interpolator": function(d3) {
+      d3.interpolators.push(function(a, b) { return a == "one" && b == "two" && d3.interpolateNumber(1, 2); });
+      try {
+        assert.equal(d3.interpolate("one", "two")(-.5), .5);
+        assert.equal(d3.interpolate("one", "two")(0), 1);
+        assert.equal(d3.interpolate("one", "two")(.5), 1.5);
+        assert.equal(d3.interpolate("one", "two")(1), 2);
+        assert.equal(d3.interpolate("one", "two")(1.5), 2.5);
+      } finally {
+        d3.interpolators.pop();
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/interpolate-transform-test.js

@@ -0,0 +1,60 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateTransform");
+
+suite.addBatch({
+  "interpolateTransform": {
+    topic: load("interpolate/transform").document(),
+    "interpolation of a decomposed transform": {
+      topic: function(d3) {
+        // Use a custom d3.transform to parse a decomposed transform, since
+        // JSDOM doesn't support consolidating SVG transform strings.
+        d3.transform = function(s) {
+          var m = s.split(/,/g).map(Number);
+          return {
+            translate: [m[0], m[1]],
+            rotate: m[2],
+            skew: m[3],
+            scale: [m[4], m[5]]
+          };
+        };
+        return d3;
+      },
+      "identity": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 0, 1, 1] + "")(.4), "");
+      },
+      "translate": {
+        "x": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [10, 0, 0, 0, 1, 1] + "")(.4), "translate(4,0)");
+        },
+        "y": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 10, 0, 0, 1, 1] + "")(.4), "translate(0,4)");
+        },
+        "x and y": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [1, 10, 0, 0, 1, 1] + "")(.4), "translate(0.4,4)");
+        }
+      },
+      "rotate": {
+        "simple": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([0, 0, -10, 0, 1, 1] + "", [0, 0, 30, 0, 1, 1] + "")(.4), "rotate(6)");
+        },
+        "with constant translate": function(d3) {
+          assert.strictEqual(d3.interpolateTransform([5, 6, -10, 0, 1, 1] + "", [5, 6, 30, 0, 1, 1] + "")(.4), "translate(5,6)rotate(6)");
+        }
+      },
+      "skew": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 40, 1, 1] + "")(.4), "skewX(16)");
+      },
+      "scale": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 0, 10, 1] + "")(.5), "scale(5.5,1)");
+      },
+      "translate and rotate": function(d3) {
+        assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [100, 0, 90, 0, 1, 1] + "")(.5), "translate(50,0)rotate(45)");
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/lab-test.js

@@ -0,0 +1,31 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateLab");
+
+suite.addBatch({
+  "interpolateLab": {
+    topic: load("interpolate/lab"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.labEqual(d3.interpolateLab("steelblue", "#f00")(.2), 52.62, 12.76, -12.31);
+      assert.labEqual(d3.interpolateLab("steelblue", "#f00")(.6), 52.93, 46.42, 27.45);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.labEqual(d3.interpolateLab(d3.hsl("steelblue"), "#f00")(.2), 52.62, 12.76, -12.31);
+      assert.labEqual(d3.interpolateLab("steelblue", d3.hsl(0, 1, .5))(.6), 52.93, 46.42, 27.45);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.labEqual(d3.interpolateLab(d3.rgb("steelblue"), "#f00")(.2), 52.62, 12.76, -12.31);
+      assert.labEqual(d3.interpolateLab("steelblue", d3.rgb(255, 0, 0))(.6), 52.93, 46.42, 27.45);
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.labEqual(d3.interpolateLab("steelblue", "#f00")(.2), 52.62, 12.76, -12.31);
+    },
+    "returns an instanceof d3.lab": function(d3) {
+      assert.labEqual(d3.interpolateLab("steelblue", "#f00")(.2), 52.62, 12.76, -12.31);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/number-test.js

@@ -0,0 +1,20 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateNumber");
+
+suite.addBatch({
+  "interpolateNumber": {
+    topic: load("interpolate/number").expression("d3.interpolateNumber"),
+    "interpolates numbers": function(interpolate) {
+      assert.strictEqual(interpolate(2, 12)(.4), 6);
+      assert.strictEqual(interpolate(2, 12)(.6), 8);
+    },
+    "coerces strings to numbers": function(interpolate) {
+      assert.strictEqual(interpolate("2", "12")(.4), 6);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/object-test.js

@@ -0,0 +1,35 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateObject");
+
+suite.addBatch({
+  "interpolateObject": {
+    topic: load("interpolate/object").expression("d3.interpolateObject"),
+    "interpolates defined properties": function(interpolate) {
+      assert.deepEqual(interpolate({a: 2, b: 12}, {a: 4, b: 24})(.5), {a: 3, b: 18});
+    },
+    "interpolates inherited properties": function(interpolate) {
+      function a(a) { this.a = a; }
+      a.prototype.b = 12;
+      assert.deepEqual(interpolate(new a(2), new a(4))(.5), {a: 3, b: 12});
+    },
+    "interpolates color properties as rgb": function(interpolate) {
+      assert.deepEqual(interpolate({background: "red"}, {background: "green"})(.5), {background: d3.rgb(128, 64, 0)});
+      assert.deepEqual(interpolate({fill: "red"}, {fill: "green"})(.5), {fill: d3.rgb(128, 64, 0)});
+      assert.deepEqual(interpolate({stroke: "red"}, {stroke: "green"})(.5), {stroke: d3.rgb(128, 64, 0)});
+      assert.deepEqual(interpolate({color: "red"}, {color: "green"})(.5), {color: d3.rgb(128, 64, 0)});
+    },
+    "interpolates nested objects and arrays": function(interpolate) {
+      assert.deepEqual(interpolate({foo: [2, 12]}, {foo: [4, 24]})(.5), {foo: [3, 18]});
+      assert.deepEqual(interpolate({foo: {bar: [2, 12]}}, {foo: {bar: [4, 24]}})(.5), {foo: {bar: [3, 18]}});
+    },
+    "merges non-shared properties": function(interpolate) {
+      assert.deepEqual(interpolate({foo: 2}, {foo: 4, bar: 12})(.5), {foo: 3, bar: 12});
+      assert.deepEqual(interpolate({foo: 2, bar: 12}, {foo: 4})(.5), {foo: 3, bar: 12});
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/rgb-test.js

@@ -0,0 +1,31 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateRgb");
+
+suite.addBatch({
+  "interpolateRgb": {
+    topic: load("interpolate/rgb"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.2), 107, 104, 144);
+      assert.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.6), 181, 52, 72);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb(d3.rgb("steelblue"), "#f00")(.2), 107, 104, 144);
+      assert.rgbEqual(d3.interpolateRgb("steelblue", d3.rgb(255, 0, 0))(.6), 181, 52, 72);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb(d3.hsl("steelblue"), "#f00")(.2), 107, 104, 144);
+      assert.rgbEqual(d3.interpolateRgb("steelblue", d3.hsl(0, 1, .5))(.6), 181, 52, 72);
+    },
+    "interpolates in RGB color space": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.2), 107, 104, 144);
+    },
+    "returns an instanceof d3.rgb": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.2), 107, 104, 144);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/interpolate/round-test.js

@@ -0,0 +1,17 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateRound");
+
+suite.addBatch({
+  "interpolateRound": {
+    topic: load("interpolate/round").expression("d3.interpolateRound"),
+    "interpolates integers": function(interpolate) {
+      assert.strictEqual(interpolate(2, 12)(.456), 7);
+      assert.strictEqual(interpolate(2, 12)(.678), 9);
+    }
+  }
+});
+
+suite.export(module);