RubyGems - stripmem - Versions diffs - 0.0.1 - Mend

stripmem 0.0.1

Files changed (508) hide show

data/lib/stripmem/public/components/d3/test/event/touch-test.html ADDED Viewed

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<meta name="viewport" content="initial-scale=1,maximum-scale=1"/>
+<style>
+html, body {
+  height: 100%;
+}
+body {
+  margin: 0;
+}
+svg {
+  display: block;
+  overflow: hidden;
+  width: 100%;
+  height: 100%;
+}
+</style>
+<body>
+<script src="../../d3.js"></script>
+<script>
+var color = d3.scale.category10();
+var svg = d3.select("body").append("svg");
+d3.select("body")
+    .on("touchstart", touch)
+    .on("touchmove", touch)
+    .on("touchend", touch);
+function touch() {
+  d3.event.preventDefault();
+  var circle = svg.selectAll("circle.touch")
+      .data(d3.touches(svg.node()), function(d) { return d.identifier; })
+      .attr("cx", function(d) { return d[0]; })
+      .attr("cy", function(d) { return d[1]; });
+  circle.enter().append("circle")
+      .attr("class", "touch")
+      .attr("cx", function(d) { return d[0]; })
+      .attr("cy", function(d) { return d[1]; })
+      .style("fill", function(d) { return color(d.identifier); })
+      .attr("r", 1e-6)
+    .transition()
+      .duration(500)
+      .ease("elastic")
+      .attr("r", 48);
+  circle.exit()
+      .attr("class", null)
+    .transition()
+      .attr("r", 1e-6)
+      .remove();
+}
+</script>

data/lib/stripmem/public/components/d3/test/format/format-test.js ADDED Viewed

@@ -0,0 +1,360 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+var suite = vows.describe("d3.format");
+suite.addBatch({
+  "format": {
+    topic: load("format/format").expression("d3.format"),
+    "returns a string": function(format) {
+      assert.isString(format("d")(0));
+    },
+    "can zero fill": function(format) {
+      var f = format("08d");
+      assert.strictEqual(f(0), "00000000");
+      assert.strictEqual(f(42), "00000042");
+      assert.strictEqual(f(42000000), "42000000");
+      assert.strictEqual(f(420000000), "420000000");
+      assert.strictEqual(f(-4), "-0000004");
+      assert.strictEqual(f(-42), "-0000042");
+      assert.strictEqual(f(-4200000), "-4200000");
+      assert.strictEqual(f(-42000000), "-42000000");
+    },
+    "can space fill": function(format) {
+      var f = format("8d");
+      assert.strictEqual(f(0), "       0");
+      assert.strictEqual(f(42), "      42");
+      assert.strictEqual(f(42000000), "42000000");
+      assert.strictEqual(f(420000000), "420000000");
+      assert.strictEqual(f(-4), "      -4");
+      assert.strictEqual(f(-42), "     -42");
+      assert.strictEqual(f(-4200000), "-4200000");
+      assert.strictEqual(f(-42000000), "-42000000");
+    },
+    "can output fixed-point notation": function(format) {
+      assert.strictEqual(format(".1f")(0.49), "0.5");
+      assert.strictEqual(format(".2f")(0.449), "0.45");
+      assert.strictEqual(format(".3f")(0.4449), "0.445");
+      assert.strictEqual(format(".5f")(0.444449), "0.44445");
+      assert.strictEqual(format(".1f")(100), "100.0");
+      assert.strictEqual(format(".2f")(100), "100.00");
+      assert.strictEqual(format(".3f")(100), "100.000");
+      assert.strictEqual(format(".5f")(100), "100.00000");
+    },
+    "can output general notation": function(format) {
+      assert.strictEqual(format(".1g")(0.049), "0.05");
+      assert.strictEqual(format(".1g")(0.49), "0.5");
+      assert.strictEqual(format(".2g")(0.449), "0.45");
+      assert.strictEqual(format(".3g")(0.4449), "0.445");
+      assert.strictEqual(format(".5g")(0.444449), "0.44445");
+      assert.strictEqual(format(".1g")(100), "1e+2");
+      assert.strictEqual(format(".2g")(100), "1.0e+2");
+      assert.strictEqual(format(".3g")(100), "100");
+      assert.strictEqual(format(".5g")(100), "100.00");
+      assert.strictEqual(format(".5g")(100.2), "100.20");
+      assert.strictEqual(format(".2g")(0.002), "0.0020");
+    },
+    "can output exponent notation ": function(format) {
+      var f = format("e");
+      assert.strictEqual(f(0), "0e+0");
+      assert.strictEqual(f(42), "4.2e+1");
+      assert.strictEqual(f(42000000), "4.2e+7");
+      assert.strictEqual(f(420000000), "4.2e+8");
+      assert.strictEqual(f(-4), "-4e+0");
+      assert.strictEqual(f(-42), "-4.2e+1");
+      assert.strictEqual(f(-4200000), "-4.2e+6");
+      assert.strictEqual(f(-42000000), "-4.2e+7");
+    },
+    "can output SI prefix notation": function(format) {
+      var f = format("s");
+      assert.strictEqual(f(0), "0");
+      assert.strictEqual(f(1), "1");
+      assert.strictEqual(f(10), "10");
+      assert.strictEqual(f(100), "100");
+      assert.strictEqual(f(999.5), "999.5");
+      assert.strictEqual(f(999500), "999.5k");
+      assert.strictEqual(f(1000), "1k");
+      assert.strictEqual(f(1400), "1.4k");
+      assert.strictEqual(f(1500.5), "1.5005k");
+      assert.strictEqual(f(.000001), "1µ");
+    },
+    "can output SI prefix notation with appropriate rounding": function(format) {
+      var f = format(".3s");
+      assert.strictEqual(f(0), "0.00");
+      assert.strictEqual(f(1), "1.00");
+      assert.strictEqual(f(10), "10.0");
+      assert.strictEqual(f(100), "100");
+      assert.strictEqual(f(999.5), "1.00k");
+      assert.strictEqual(f(999500), "1.00M");
+      assert.strictEqual(f(1000), "1.00k");
+      assert.strictEqual(f(1500.5), "1.50k");
+      assert.strictEqual(f(145500000), "146M");
+      assert.strictEqual(f(145999999.999999347), "146M");
+      assert.strictEqual(f(1e26), "100Y");
+      assert.strictEqual(f(.000001), "1.00µ");
+      assert.strictEqual(f(.009995), "0.0100");
+      var f = format(".4s");
+      assert.strictEqual(f(999.5), "999.5");
+      assert.strictEqual(f(999500), "999.5k");
+      assert.strictEqual(f(.009995), "9.995m");
+    },
+    "can output a currency": function(format) {
+      var f = format("$");
+      assert.strictEqual(f(0), "$0");
+      assert.strictEqual(f(.042), "$0.042");
+      assert.strictEqual(f(.42), "$0.42");
+      assert.strictEqual(f(4.2), "$4.2");
+      assert.strictEqual(f(-.042), "-$0.042");
+      assert.strictEqual(f(-.42), "-$0.42");
+      assert.strictEqual(f(-4.2), "-$4.2");
+    },
+    "can output a currency with comma-grouping and sign": function(format) {
+      var f = format("+$,.2f");
+      assert.strictEqual(f(0), "+$0.00");
+      assert.strictEqual(f(0.429), "+$0.43");
+      assert.strictEqual(f(-0.429), "-$0.43");
+      assert.strictEqual(f(-1), "-$1.00");
+      assert.strictEqual(f(1e4), "+$10,000.00");
+    },
+    "can output a currency with si-prefix notation": function(format) {
+      var f = format("$.2s");
+      assert.strictEqual(f(0), "$0.0");
+      assert.strictEqual(f(2.5e5), "$250k");
+      assert.strictEqual(f(-2.5e8), "-$250M");
+      assert.strictEqual(f(2.5e11), "$250G");
+    },
+    "can output a percentage": function(format) {
+      var f = format("%");
+      assert.strictEqual(f(0), "0%");
+      assert.strictEqual(f(.042), "4%");
+      assert.strictEqual(f(.42), "42%");
+      assert.strictEqual(f(4.2), "420%");
+      assert.strictEqual(f(-.042), "-4%");
+      assert.strictEqual(f(-.42), "-42%");
+      assert.strictEqual(f(-4.2), "-420%");
+    },
+    "can output a percentage with rounding and sign": function(format) {
+      var f = format("+.2p");
+      assert.strictEqual(f(.00123), "+0.12%");
+      assert.strictEqual(f(.0123), "+1.2%");
+      assert.strictEqual(f(.123), "+12%");
+      assert.strictEqual(f(1.23), "+120%");
+      assert.strictEqual(f(-.00123), "-0.12%");
+      assert.strictEqual(f(-.0123), "-1.2%");
+      assert.strictEqual(f(-.123), "-12%");
+      assert.strictEqual(f(-1.23), "-120%");
+    },
+    "can round to significant digits": function(format) {
+      assert.strictEqual(format(".2r")(0), "0.0");
+      assert.strictEqual(format(".1r")(0.049), "0.05");
+      assert.strictEqual(format(".1r")(-0.049), "-0.05");
+      assert.strictEqual(format(".1r")(0.49), "0.5");
+      assert.strictEqual(format(".1r")(-0.49), "-0.5");
+      assert.strictEqual(format(".2r")(0.449), "0.45");
+      assert.strictEqual(format(".3r")(0.4449), "0.445");
+      assert.strictEqual(format(".3r")(1.00), "1.00");
+      assert.strictEqual(format(".3r")(0.9995), "1.00");
+      assert.strictEqual(format(".5r")(0.444449), "0.44445");
+      assert.strictEqual(format("r")(123.45), "123.45");
+      assert.strictEqual(format(".1r")(123.45), "100");
+      assert.strictEqual(format(".2r")(123.45), "120");
+      assert.strictEqual(format(".3r")(123.45), "123");
+      assert.strictEqual(format(".4r")(123.45), "123.5");
+      assert.strictEqual(format(".5r")(123.45), "123.45");
+      assert.strictEqual(format(".6r")(123.45), "123.450");
+      assert.strictEqual(format(".1r")(.9), "0.9");
+      assert.strictEqual(format(".1r")(.09), "0.09");
+      assert.strictEqual(format(".1r")(.949), "0.9");
+      assert.strictEqual(format(".1r")(.0949), "0.09");
+      assert.strictEqual(format(".10r")(.9999999999), "0.9999999999");
+      assert.strictEqual(format(".15r")(.999999999999999), "0.999999999999999");
+    },
+    "can round very small numbers": function(format) {
+      var f = format(".2r");
+      assert.strictEqual(f(1e-22), "0.00000000000000000000");
+    },
+    "can group thousands": function(format) {
+      var f = format(",d");
+      assert.strictEqual(f(0), "0");
+      assert.strictEqual(f(42), "42");
+      assert.strictEqual(f(42000000), "42,000,000");
+      assert.strictEqual(f(420000000), "420,000,000");
+      assert.strictEqual(f(-4), "-4");
+      assert.strictEqual(f(-42), "-42");
+      assert.strictEqual(f(-4200000), "-4,200,000");
+      assert.strictEqual(f(-42000000), "-42,000,000");
+    },
+    "can group thousands and zero fill": function(format) {
+      assert.strictEqual(format("01,d")(0), "0");
+      assert.strictEqual(format("01,d")(0), "0");
+      assert.strictEqual(format("02,d")(0), "00");
+      assert.strictEqual(format("03,d")(0), "000");
+      assert.strictEqual(format("05,d")(0), "0,000");
+      assert.strictEqual(format("08,d")(0), "0,000,000");
+      assert.strictEqual(format("013,d")(0), "0,000,000,000");
+      assert.strictEqual(format("021,d")(0), "0,000,000,000,000,000");
+      assert.strictEqual(format("013,d")(-42000000), "-0,042,000,000");
+    },
+    "can group thousands and zero fill with overflow": function(format) {
+      assert.strictEqual(format("01,d")(1), "1");
+      assert.strictEqual(format("01,d")(1), "1");
+      assert.strictEqual(format("02,d")(12), "12");
+      assert.strictEqual(format("03,d")(123), "123");
+      assert.strictEqual(format("05,d")(12345), "12,345");
+      assert.strictEqual(format("08,d")(12345678), "12,345,678");
+      assert.strictEqual(format("013,d")(1234567890123), "1,234,567,890,123");
+    },
+    "can group thousands and space fill": function(format) {
+      assert.strictEqual(format("1,d")(0), "0");
+      assert.strictEqual(format("1,d")(0), "0");
+      assert.strictEqual(format("2,d")(0), " 0");
+      assert.strictEqual(format("3,d")(0), "  0");
+      assert.strictEqual(format("5,d")(0), "    0");
+      assert.strictEqual(format("8,d")(0), "       0");
+      assert.strictEqual(format("13,d")(0), "            0");
+      assert.strictEqual(format("21,d")(0), "                    0");
+    },
+    "can group thousands and space fill with overflow": function(format) {
+      assert.strictEqual(format("1,d")(1), "1");
+      assert.strictEqual(format("1,d")(1), "1");
+      assert.strictEqual(format("2,d")(12), "12");
+      assert.strictEqual(format("3,d")(123), "123");
+      assert.strictEqual(format("5,d")(12345), "12,345");
+      assert.strictEqual(format("8,d")(12345678), "12,345,678");
+      assert.strictEqual(format("13,d")(1234567890123), "1,234,567,890,123");
+    },
+    "can group thousands with general notation": function(format) {
+      var f = format(",g");
+      assert.strictEqual(f(0), "0");
+      assert.strictEqual(f(42), "42");
+      assert.strictEqual(f(42000000), "42,000,000");
+      assert.strictEqual(f(420000000), "420,000,000");
+      assert.strictEqual(f(-4), "-4");
+      assert.strictEqual(f(-42), "-42");
+      assert.strictEqual(f(-4200000), "-4,200,000");
+      assert.strictEqual(f(-42000000), "-42,000,000");
+    },
+    "can group thousands, space fill, and round to significant digits": function(format) {
+      assert.strictEqual(format("10,.1f")(123456.49), " 123,456.5");
+      assert.strictEqual(format("10,.2f")(1234567.449), "1,234,567.45");
+      assert.strictEqual(format("10,.3f")(12345678.4449), "12,345,678.445");
+      assert.strictEqual(format("10,.5f")(123456789.444449), "123,456,789.44445");
+      assert.strictEqual(format("10,.1f")(123456), " 123,456.0");
+      assert.strictEqual(format("10,.2f")(1234567), "1,234,567.00");
+      assert.strictEqual(format("10,.3f")(12345678), "12,345,678.000");
+      assert.strictEqual(format("10,.5f")(123456789), "123,456,789.00000");
+    },
+    "can display integers in fixed-point notation": function(format) {
+      assert.strictEqual(format("f")(42), "42");
+    },
+    "will not display non-integers in integer format": function(format) {
+      assert.strictEqual(format("d")(4.2), "");
+    },
+    "unicode character": function(format) {
+      assert.strictEqual(format("c")(9731), "☃");
+    },
+    "binary": function(format) {
+      assert.strictEqual(format("b")(10), "1010");
+    },
+    "binary with prefix": function(format) {
+      assert.strictEqual(format("#b")(10), "0b1010");
+    },
+    "octal": function(format) {
+      assert.strictEqual(format("o")(10), "12");
+    },
+    "octal with prefix": function(format) {
+      assert.strictEqual(format("#o")(10), "0o12");
+    },
+    "hexadecimal (lowercase)": function(format) {
+      assert.strictEqual(format("x")(3735928559), "deadbeef");
+    },
+    "hexadecimal (lowercase) with prefix": function(format) {
+      assert.strictEqual(format("#x")(3735928559), "0xdeadbeef");
+    },
+    "hexadecimal (uppercase)": function(format) {
+      assert.strictEqual(format("X")(3735928559), "DEADBEEF");
+    },
+    "hexadecimal (uppercase) with prefix": function(format) {
+      assert.strictEqual(format("#X")(3735928559), "0xDEADBEEF");
+    },
+    "fill respects prefix": function(format) {
+      assert.strictEqual(format("#20x")(3735928559), "          0xdeadbeef");
+    },
+    "align left": function(format) {
+      assert.strictEqual(format("<1,d")(0), "0");
+      assert.strictEqual(format("<1,d")(0), "0");
+      assert.strictEqual(format("<2,d")(0), "0 ");
+      assert.strictEqual(format("<3,d")(0), "0  ");
+      assert.strictEqual(format("<5,d")(0), "0    ");
+      assert.strictEqual(format("<8,d")(0), "0       ");
+      assert.strictEqual(format("<13,d")(0), "0            ");
+      assert.strictEqual(format("<21,d")(0), "0                    ");
+    },
+    "align right": function(format) {
+      assert.strictEqual(format(">1,d")(0), "0");
+      assert.strictEqual(format(">1,d")(0), "0");
+      assert.strictEqual(format(">2,d")(0), " 0");
+      assert.strictEqual(format(">3,d")(0), "  0");
+      assert.strictEqual(format(">5,d")(0), "    0");
+      assert.strictEqual(format(">8,d")(0), "       0");
+      assert.strictEqual(format(">13,d")(0), "            0");
+      assert.strictEqual(format(">21,d")(0), "                    0");
+    },
+    "align center": function(format) {
+      assert.strictEqual(format("^1,d")(0), "0");
+      assert.strictEqual(format("^1,d")(0), "0");
+      assert.strictEqual(format("^2,d")(0), " 0");
+      assert.strictEqual(format("^3,d")(0), " 0 ");
+      assert.strictEqual(format("^5,d")(0), "  0  ");
+      assert.strictEqual(format("^8,d")(0), "    0   ");
+      assert.strictEqual(format("^13,d")(0), "      0      ");
+      assert.strictEqual(format("^21,d")(0), "          0          ");
+    },
+    "pad after sign": function(format) {
+      assert.strictEqual(format("=+1,d")(0), "+0");
+      assert.strictEqual(format("=+1,d")(0), "+0");
+      assert.strictEqual(format("=+2,d")(0), "+0");
+      assert.strictEqual(format("=+3,d")(0), "+ 0");
+      assert.strictEqual(format("=+5,d")(0), "+   0");
+      assert.strictEqual(format("=+8,d")(0), "+      0");
+      assert.strictEqual(format("=+13,d")(0), "+           0");
+      assert.strictEqual(format("=+21,d")(0), "+                   0");
+    },
+    "a space can denote positive numbers": function(format) {
+      assert.strictEqual(format(" 1,d")(-1), "-1");
+      assert.strictEqual(format(" 1,d")(0), " 0");
+      assert.strictEqual(format(" 2,d")(0), " 0");
+      assert.strictEqual(format(" 3,d")(0), "  0");
+      assert.strictEqual(format(" 5,d")(0), "    0");
+      assert.strictEqual(format(" 8,d")(0), "       0");
+      assert.strictEqual(format(" 13,d")(0), "            0");
+      assert.strictEqual(format(" 21,d")(0), "                    0");
+    },
+    "can format negative zero": function(format) {
+      assert.strictEqual(format("1d")(-0), "-0");
+      assert.strictEqual(format("1f")(-0), "-0");
+    },
+    "supports \"n\" as an alias for \",g\"": function(format) {
+      var f = format("n");
+      assert.strictEqual(f(.0042), "0.0042");
+      assert.strictEqual(f(.42), "0.42");
+      assert.strictEqual(f(0), "0");
+      assert.strictEqual(f(42), "42");
+      assert.strictEqual(f(42000000), "42,000,000");
+      assert.strictEqual(f(420000000), "420,000,000");
+      assert.strictEqual(f(-4), "-4");
+      assert.strictEqual(f(-42), "-42");
+      assert.strictEqual(f(-4200000), "-4,200,000");
+      assert.strictEqual(f(-42000000), "-42,000,000");
+    },
+    "unreasonable precision values are clamped to reasonable values": function(format) {
+      assert.strictEqual(format(".30f")(0), "0.00000000000000000000");
+      assert.strictEqual(format(".0g")(1), "1");
+      assert.strictEqual(format(",.-1f")(12345), "12,345");
+      assert.strictEqual(format("+,.-1%")(123.45), "+12,345%");
+    }
+  }
+});
+suite.export(module);

data/lib/stripmem/public/components/d3/test/format/formatPrefix-test.js ADDED Viewed

@@ -0,0 +1,112 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+var suite = vows.describe("d3.formatPrefix");
+suite.addBatch({
+  "formatPrefix": {
+    topic: load("format/formatPrefix").expression("d3.formatPrefix"),
+    "determines the appropriate prefix for small numbers": function(prefix) {
+      assert.equal(prefix(0).symbol, "");
+      assert.equal(prefix(1e-00).symbol, "");
+      assert.equal(prefix(1e-01).symbol, "");
+      assert.equal(prefix(1e-02).symbol, "");
+      assert.equal(prefix(1e-03).symbol, "m");
+      assert.equal(prefix(1e-04).symbol, "m");
+      assert.equal(prefix(1e-05).symbol, "m");
+      assert.equal(prefix(1e-06).symbol, "µ");
+      assert.equal(prefix(1e-07).symbol, "µ");
+      assert.equal(prefix(1e-08).symbol, "µ");
+      assert.equal(prefix(1e-09).symbol, "n");
+      assert.equal(prefix(1e-10).symbol, "n");
+      assert.equal(prefix(1e-11).symbol, "n");
+      assert.equal(prefix(1e-12).symbol, "p");
+      assert.equal(prefix(1e-13).symbol, "p");
+      assert.equal(prefix(1e-14).symbol, "p");
+      assert.equal(prefix(1e-15).symbol, "f");
+      assert.equal(prefix(1e-16).symbol, "f");
+      assert.equal(prefix(1e-17).symbol, "f");
+      assert.equal(prefix(1e-18).symbol, "a");
+      assert.equal(prefix(1e-19).symbol, "a");
+      assert.equal(prefix(1e-20).symbol, "a");
+      assert.equal(prefix(1e-21).symbol, "z");
+      assert.equal(prefix(1e-22).symbol, "z");
+      assert.equal(prefix(1e-23).symbol, "z");
+      assert.equal(prefix(1e-24).symbol, "y");
+      assert.equal(prefix(1e-25).symbol, "y");
+      assert.equal(prefix(1e-26).symbol, "y");
+      assert.equal(prefix(1e-27).symbol, "y");
+    },
+    "determines the appropriate prefix for large numbers": function(prefix) {
+      assert.equal(prefix(0).symbol, "");
+      assert.equal(prefix(1e00).symbol, "");
+      assert.equal(prefix(1e01).symbol, "");
+      assert.equal(prefix(1e02).symbol, "");
+      assert.equal(prefix(1e03).symbol, "k");
+      assert.equal(prefix(1e04).symbol, "k");
+      assert.equal(prefix(1e05).symbol, "k");
+      assert.equal(prefix(1e06).symbol, "M");
+      assert.equal(prefix(1e07).symbol, "M");
+      assert.equal(prefix(1e08).symbol, "M");
+      assert.equal(prefix(1e09).symbol, "G");
+      assert.equal(prefix(1e10).symbol, "G");
+      assert.equal(prefix(1e11).symbol, "G");
+      assert.equal(prefix(1e12).symbol, "T");
+      assert.equal(prefix(1e13).symbol, "T");
+      assert.equal(prefix(1e14).symbol, "T");
+      assert.equal(prefix(1e15).symbol, "P");
+      assert.equal(prefix(1e16).symbol, "P");
+      assert.equal(prefix(1e17).symbol, "P");
+      assert.equal(prefix(1e18).symbol, "E");
+      assert.equal(prefix(1e19).symbol, "E");
+      assert.equal(prefix(1e20).symbol, "E");
+      assert.equal(prefix(1e21).symbol, "Z");
+      assert.equal(prefix(1e22).symbol, "Z");
+      assert.equal(prefix(1e23).symbol, "Z");
+      assert.equal(prefix(1e24).symbol, "Y");
+      assert.equal(prefix(1e25).symbol, "Y");
+      assert.equal(prefix(1e26).symbol, "Y");
+      assert.equal(prefix(1e27).symbol, "Y");
+    },
+    "determines the appropriate prefix for negative numbers": function(prefix) {
+      assert.equal(prefix(-0).symbol, "");
+      assert.equal(prefix(-1e-00).symbol, "");
+      assert.equal(prefix(-1e-03).symbol, "m");
+      assert.equal(prefix(-1e-06).symbol, "µ");
+      assert.equal(prefix(-1e-09).symbol, "n");
+      assert.equal(prefix(-1e-12).symbol, "p");
+      assert.equal(prefix(-1e-15).symbol, "f");
+      assert.equal(prefix(-1e-18).symbol, "a");
+      assert.equal(prefix(-1e-21).symbol, "z");
+      assert.equal(prefix(-1e-24).symbol, "y");
+      assert.equal(prefix(-1e-27).symbol, "y");
+      assert.equal(prefix(-1e00).symbol, "");
+      assert.equal(prefix(-1e03).symbol, "k");
+      assert.equal(prefix(-1e06).symbol, "M");
+      assert.equal(prefix(-1e09).symbol, "G");
+      assert.equal(prefix(-1e12).symbol, "T");
+      assert.equal(prefix(-1e15).symbol, "P");
+      assert.equal(prefix(-1e18).symbol, "E");
+      assert.equal(prefix(-1e21).symbol, "Z");
+      assert.equal(prefix(-1e24).symbol, "Y");
+      assert.equal(prefix(-1e27).symbol, "Y");
+    },
+    "considers the effect of rounding based on precision": function(prefix) {
+      assert.equal(prefix(999.5000000, 4).symbol, "");
+      assert.equal(prefix(999.5000000, 3).symbol, "k");
+      assert.equal(prefix(995.0000000, 3).symbol, "");
+      assert.equal(prefix(995.0000000, 2).symbol, "k");
+      assert.equal(prefix(950.0000000, 2).symbol, "");
+      assert.equal(prefix(950.0000000, 1).symbol, "k");
+      assert.equal(prefix(0.000009995, 4).symbol, "µ");
+      assert.equal(prefix(0.000009995, 3).symbol, "m");
+      assert.equal(prefix(0.000009950, 3).symbol, "µ");
+      assert.equal(prefix(0.000009950, 2).symbol, "m");
+      assert.equal(prefix(0.000009500, 2).symbol, "µ");
+      assert.equal(prefix(0.000009500, 1).symbol, "m");
+    }
+  }
+});
+suite.export(module);

data/lib/stripmem/public/components/d3/test/format/requote-test.js ADDED Viewed

@@ -0,0 +1,49 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+var suite = vows.describe("d3.requote");
+suite.addBatch({
+  "requote": {
+    topic: load("format/requote").expression("d3.requote"),
+    "quotes backslashes": function(requote) {
+      assert.equal(requote("\\"), "\\\\");
+    },
+    "quotes carets": function(requote) {
+      assert.equal(requote("^"), "\\^");
+    },
+    "quotes dollar signs": function(requote) {
+      assert.equal(requote("$"), "\\$");
+    },
+    "quotes stars": function(requote) {
+      assert.equal(requote("*"), "\\*");
+    },
+    "quotes plusses": function(requote) {
+      assert.equal(requote("+"), "\\+");
+    },
+    "quotes question marks": function(requote) {
+      assert.equal(requote("?"), "\\?");
+    },
+    "quotes periods": function(requote) {
+      assert.equal(requote("."), "\\.");
+    },
+    "quotes parentheses": function(requote) {
+      assert.equal(requote("("), "\\(");
+      assert.equal(requote(")"), "\\)");
+    },
+    "quotes pipes": function(requote) {
+      assert.equal(requote("|"), "\\|");
+    },
+    "quotes curly braces": function(requote) {
+      assert.equal(requote("{"), "\\{");
+      assert.equal(requote("}"), "\\}");
+    },
+    "quotes square brackets": function(requote) {
+      assert.equal(requote("["), "\\[");
+      assert.equal(requote("]"), "\\]");
+    }
+  }
+});
+suite.export(module);

data/lib/stripmem/public/components/d3/test/format/round-test.js ADDED Viewed

@@ -0,0 +1,66 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+var suite = vows.describe("d3.round");
+suite.addBatch({
+  "round": {
+    topic: load("format/round").expression("d3.round"),
+    "returns a number": function(round) {
+      assert.isNumber(round(42));
+    },
+    "returns zero for zero": function(round) {
+      assert.equal(round(0), 0);
+    },
+    "ignores degenerate input": function(round) {
+      assert.isNaN(round(NaN));
+      assert.equal(round(Infinity), Infinity);
+      assert.equal(round(-Infinity), -Infinity);
+    },
+    "returns integers by default": function(round) {
+      assert.equal(round(10.6), 11);
+      assert.equal(round(10.4), 10);
+      assert.equal(round(0.6), 1);
+      assert.equal(round(0.4), 0);
+      assert.equal(round(-0.6), -1);
+      assert.equal(round(-0.4), 0);
+      assert.equal(round(-10.6), -11);
+      assert.equal(round(-10.4), -10);
+    },
+    "rounds to the specified decimal place": function(round) {
+      assert.inDelta(round(10.56, 1), 10.6, 1e-6);
+      assert.inDelta(round(10.54, 1), 10.5, 1e-6);
+      assert.inDelta(round(0.56, 1), 0.6, 1e-6);
+      assert.inDelta(round(0.54, 1), 0.5, 1e-6);
+      assert.inDelta(round(-0.56, 1), -0.6, 1e-6);
+      assert.inDelta(round(-0.54, 1), -0.5, 1e-6);
+      assert.inDelta(round(-10.56, 1), -10.6, 1e-6);
+      assert.inDelta(round(-10.54, 1), -10.5, 1e-6);
+      assert.inDelta(round(10.556, 2), 10.56, 1e-6);
+      assert.inDelta(round(10.554, 2), 10.55, 1e-6);
+      assert.inDelta(round(0.556, 2), 0.56, 1e-6);
+      assert.inDelta(round(0.554, 2), 0.55, 1e-6);
+      assert.inDelta(round(-0.556, 2), -0.56, 1e-6);
+      assert.inDelta(round(-0.554, 2), -0.55, 1e-6);
+      assert.inDelta(round(-10.556, 2), -10.56, 1e-6);
+      assert.inDelta(round(-10.554, 2), -10.55, 1e-6);
+    },
+    "rounds to the specified significant digits": function(round) {
+      assert.equal(round(123.45, -1), 120);
+      assert.equal(round(345.67, -1), 350);
+      assert.equal(round(-123.45, -1), -120);
+      assert.equal(round(-345.67, -1), -350);
+      assert.equal(round(123.45, -2), 100);
+      assert.equal(round(456.78, -2), 500);
+      assert.equal(round(-123.45, -2), -100);
+      assert.equal(round(-456.78, -2), -500);
+      assert.equal(round(123.45, -3), 0);
+      assert.equal(round(567.89, -3), 1000);
+      assert.equal(round(-123.45, -3), 0);
+      assert.equal(round(-567.89, -3), -1000);
+    }
+  }
+});
+suite.export(module);