RubyGems - stripmem - Versions diffs - 0.0.1 - Mend

stripmem 0.0.1

Files changed (508) hide show

data/lib/stripmem/public/components/d3/test/math/transform-rotate-origin-test.html ADDED Viewed

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<body>
+<script src="../../d3.js"></script>
+<script>
+var width = 960,
+    height = 500;
+var cross = d3.svg.symbol()
+    .type("cross")
+    .size(10000);
+var svg = d3.select("body").append("svg")
+    .attr("width", width)
+    .attr("height", height)
+  .append("g")
+    .attr("transform", "translate(" + (width / 2) + "," + (height / 2) + ")");
+svg.append("path")
+    .style("fill", "steelblue")
+    .attr("d", cross);
+svg.append("path")
+    .style("fill", "darkgreen")
+    .attr("d", cross)
+    .attr("transform", "rotate(45 200,200)");
+svg.append("path")
+    .style("fill", "white")
+    .style("fill-opacity", .2)
+    .style("stroke", "steelblue")
+    .style("stroke-width", "4px")
+    .attr("d", cross)
+  .transition()
+    .duration(1000)
+    .style("stroke", "darkgreen")
+    .attr("transform", "rotate(45 200,200)");
+</script>

data/lib/stripmem/public/components/d3/test/math/transform-rotate-test.html ADDED Viewed

@@ -0,0 +1,138 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<style>
+table {
+  width: 960px;
+  border-spacing: 0;
+  border-collapse: collapse;
+}
+th, td {
+  padding: 4px;
+}
+th {
+  text-align: left;
+}
+td {
+  border: solid 1px #ccc;
+  text-align: right;
+}
+td.fail {
+  background: lightcoral;
+}
+td.success {
+  background: lightgreen;
+}
+</style>
+<table>
+  <thead>
+    <th>start</th>
+    <th>end</th>
+    <th colspan=5>actual intermediate values</th>
+    <th>exp.</th>
+    <th>act.</th>
+  </thead>
+  <tbody>
+  </tbody>
+</table>
+<script src="../../d3.js"></script>
+<script>
+var format = d3.format(",.2f");
+var tests = [
+  {start:  170, end:  225, expected: [ 170.00, -176.25, -162.50, -148.75, -135.00]},
+  {start:  225, end:  170, expected: [-135.00, -148.75, -162.50, -176.25,  170.00]},
+  {start: -170, end: -225, expected: [-170.00,  176.25,  162.50,  148.75,  135.00]},
+  {start: -225, end: -170, expected: [ 135.00,  148.75,  162.50,  176.25, -170.00]},
+  {start: -170, end:  170, expected: [-170.00, -175.00,  180.00,  175.00,  170.00]},
+  {start: -170, end:    0, expected: [-170.00, -127.50,  -85.00,  -42.50,    0.00]},
+  {start:  170, end:    0, expected: [ 170.00,  127.50,   85.00,   42.50,    0.00]},
+  {start: -180, end:   90, expected: [ 180.00,  157.50,  135.00,  112.50,   90.00]},
+  {start:  180, end:   90, expected: [ 180.00,  157.50,  135.00,  112.50,   90.00]},
+  {start: -180, end:  -90, expected: [-180.00, -157.50, -135.00, -112.50,  -90.00]},
+  {start:  180, end:  -90, expected: [ 180.00, -157.50, -135.00, -112.50,  -90.00]},
+  {start:  780, end:  -90, expected: [  60.00,  22.50,  -15.00,   -52.50,  -90.00]}
+];
+var tr = d3.select("tbody").selectAll("tr")
+    .data(tests)
+  .enter().append("tr");
+tr.append("td")
+    .text(function(d) { return format(d.start); });
+tr.append("td")
+    .text(function(d) { return format(d.end); });
+tr.selectAll(".actual")
+    .data(function(d) {
+      var interpolate = d3.interpolateTransform("rotate(" + d.start + ")", "rotate(" + d.end + ")");
+      return d.expected.map(function(expected, i) {
+        return {
+          expected: expected,
+          actual: d3.transform(interpolate(i / 4)).rotate
+        };
+      });
+    })
+  .enter().append("td")
+    .text(function(d, i) { return format(d.actual); })
+    .attr("class", function(d) { return Math.abs(d.actual - d.expected) < .01 ? "success" : "fail"; });
+var ga = tr.append("td").attr("width", 40).append("svg")
+    .attr("width", 40)
+    .attr("height", 20)
+  .append("g")
+    .attr("transform", "translate(20,10)")
+  .append("g")
+    .each(animateExpected);
+ga.append("path")
+    .attr("d", d3.svg.symbol().type("cross").size(120));
+ga.append("circle")
+    .attr("cx", 8)
+    .attr("r", 4);
+var gb = tr.append("td").attr("width", 40).append("svg")
+    .attr("width", 40)
+    .attr("height", 20)
+  .append("g")
+    .attr("transform", "translate(20,10)")
+  .append("g")
+    .each(animateActual);
+gb.append("path")
+    .attr("d", d3.svg.symbol().type("cross").size(120));
+gb.append("circle")
+    .attr("cx", 8)
+    .attr("r", 4);
+function animateExpected(d) {
+  d3.select(this).transition()
+      .duration(2500)
+      .attrTween("transform", function(d) {
+        var a = d.start % 360, b = d.end % 360;
+        if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path
+        return d3.interpolateString("rotate(" + a + ")", "rotate(" + b + ")");
+      })
+      .each("end", animateExpected);
+}
+function animateActual(d) {
+  d3.select(this)
+      .attr("transform", "rotate(" + d.start + ")")
+    .transition()
+      .duration(2500)
+      .attr("transform", "rotate(" + d.end + ")")
+      .each("end", animateActual);
+}
+</script>

data/lib/stripmem/public/components/d3/test/math/transform-test.html ADDED Viewed

@@ -0,0 +1,88 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Transform Test</title>
+<style>
+th,
+td {
+  border: solid #ccc 1px;
+}
+</style>
+<body>
+<script src="../../d3.js"></script>
+<script>
+var outcome = d3.select("body").append("p");
+var g = d3.select("body").append("svg")
+    .attr("width", 10)
+    .attr("height", 10)
+  .append("g");
+var results = d3.select("body").append("table")
+    .style("display", "none");
+results.append("tr").selectAll("th")
+    .data(["Expected", "Actual", "Expected matrix", "Actual matrix"])
+  .enter().append("th")
+    .text(function(d) { return d; });
+var el = g[0][0],
+    v,
+    m,
+    a,
+    b,
+    failures = 0;
+for (var tx = -10; tx <= 10; tx += 5) {
+  for (var ty = -10; ty <= 10; ty += 5) {
+    for (var r = -180; r <= 180; r += 15) {
+      for (var skx = -45; skx <= 45; skx += 45) {
+        for (var sx = -2; sx <= 2; sx++) {
+          for (var sy = -2; sy <= 2; sy++) {
+            v = "translate(" + tx + "," + ty + ")rotate(" + r + ")skewX(" + skx + ")scale(" + sx + "," + sy + ")";
+            g.attr("transform", v);
+            a = matrix(el);
+            g.attr("transform", d3.transform(v));
+            b = matrix(el);
+            if (!deepEqual(a, b, 1e-6)) {
+              failures++;
+              results
+                  .style("display", null)
+                .append("tr").selectAll("td")
+                  .data([v, d3.transform(v), a, b])
+                .enter().append("td")
+                  .text(function(d) { return d; });
+            }
+          }
+        }
+      }
+    }
+  }
+}
+outcome.text(failures ? failures + " failures" : "Success!");
+function matrix(el) {
+  var t = el.transform.baseVal.consolidate();
+  if (t) {
+    var m = t.matrix;
+    return [m.a, m.b, m.c, m.d, m.e, m.f];
+  }
+  return null;
+}
+function deepEqual(actual, expected, epsilon) {
+  epsilon = epsilon || 0;
+  if (actual === expected) return true;
+  if (actual == null || expected == null) return false;
+  if (actual.length !== expected.length) return false;
+  for (var i = 0; i < actual.length; i++) {
+    if (Math.abs(actual[i] - expected[i]) > epsilon) return false;
+  }
+  return true;
+}
+</script>

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

@@ -0,0 +1,76 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+var suite = vows.describe("d3.scale.category");
+suite.addBatch({
+  "category": {
+    topic: load("scale/category").expression("d3.scale"),
+    "category10": category("category10", 10),
+    "category20": category("category20", 20),
+    "category20b": category("category20b", 20),
+    "category20c": category("category20c", 20)
+  }
+});
+function category(category, n) {
+  return {
+    "is an ordinal scale": function(scale) {
+      var x = scale[category](), colors = x.range();
+      assert.lengthOf(x.domain(), 0);
+      assert.lengthOf(x.range(), n);
+      assert.equal(x(1), colors[0]);
+      assert.equal(x(2), colors[1]);
+      assert.equal(x(1), colors[0]);
+      var y = x.copy();
+      assert.deepEqual(y.domain(), x.domain());
+      assert.deepEqual(y.range(), x.range());
+      x.domain(_.range(n));
+      for (var i = 0; i < n; ++i) assert.equal(x(i + n), x(i));
+      assert.equal(y(1), colors[0]);
+      assert.equal(y(2), colors[1]);
+    },
+    "each instance is isolated": function(scale) {
+      var a = scale[category](), b = scale[category](), colors = a.range();
+      assert.equal(a(1), colors[0]);
+      assert.equal(b(2), colors[0]);
+      assert.equal(b(1), colors[1]);
+      assert.equal(a(1), colors[0]);
+    },
+    "contains the expected number of values in the range": function(scale) {
+      var x = scale[category]();
+      assert.lengthOf(x.range(), n);
+    },
+    "each range value is distinct": function(scale) {
+      var map = {}, count = 0, x = scale[category]();
+      x.range().forEach(function(v) {
+        if (!(v in map)) {
+          map[v] = ++count;
+        }
+      });
+      assert.equal(count, x.range().length);
+    },
+    "each range value is a hexadecimal color": function(scale) {
+      var x = scale[category]();
+      x.range().forEach(function(v) {
+        assert.match(v, /#[0-9a-f]{6}/);
+        v = _.rgb(v);
+        assert.isFalse(isNaN(v.r));
+        assert.isFalse(isNaN(v.g));
+        assert.isFalse(isNaN(v.b));
+      });
+    },
+    "no range values are very dark or very light": function(scale) {
+      var x = scale[category]();
+      x.range().forEach(function(v) {
+        var c = _.hsl(v);
+        assert.isTrue(c.l >= .34, "expected " + v + " to be lighter (l = " + c.l + ")");
+        assert.isTrue(c.l <= .89, "expected " + v + " to be darker (l = " + c.l + ")");
+      });
+    }
+  };
+}
+suite.export(module);

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

@@ -0,0 +1,163 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+var suite = vows.describe("d3.scale.identity");
+suite.addBatch({
+  "identity": {
+    topic: load("scale/identity").expression("d3.scale.identity"),
+    "domain and range": {
+      "are identical": function(identity) {
+        var x = identity();
+        assert.strictEqual(x.domain, x.range);
+        assert.strictEqual(x.domain(), x.range());
+        var x = identity().domain([-10, 0, 100]);
+        assert.deepEqual(x.range(), [-10, 0, 100]);
+        var x = identity().range([-10, 0, 100]);
+        assert.deepEqual(x.domain(), [-10, 0, 100]);
+      },
+      "default to [0, 1]": function(identity) {
+        var x = identity();
+        assert.deepEqual(x.domain(), [0, 1]);
+        assert.deepEqual(x.range(), [0, 1]);
+        assert.strictEqual(x(.5), .5);
+      },
+      "coerce values to numbers": function(identity) {
+        var x = identity().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]);
+        assert.typeOf(x.domain()[0], "number");
+        assert.typeOf(x.domain()[1], "number");
+        assert.strictEqual(x.domain()[0], +new Date(1990, 0, 1));
+        assert.strictEqual(x.domain()[1], +new Date(1991, 0, 1));
+        assert.typeOf(x(new Date(1989, 09, 20)), "number");
+        assert.strictEqual(x(new Date(1989, 09, 20)), +new Date(1989, 09, 20));
+        var x = identity().domain(["0", "1"]);
+        assert.typeOf(x.domain()[0], "number");
+        assert.typeOf(x.domain()[1], "number");
+        assert.strictEqual(x(.5), .5);
+        var x = identity().domain([new Number(0), new Number(1)]);
+        assert.typeOf(x.domain()[0], "number");
+        assert.typeOf(x.domain()[1], "number");
+        assert.strictEqual(x(.5), .5);
+        var x = identity().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]);
+        assert.typeOf(x.range()[0], "number");
+        assert.typeOf(x.range()[1], "number");
+        assert.strictEqual(x.range()[0], +new Date(1990, 0, 1));
+        assert.strictEqual(x.range()[1], +new Date(1991, 0, 1));
+        assert.typeOf(x(new Date(1989, 09, 20)), "number");
+        assert.strictEqual(x(new Date(1989, 09, 20)), +new Date(1989, 09, 20));
+        var x = identity().range(["0", "1"]);
+        assert.typeOf(x.range()[0], "number");
+        assert.typeOf(x.range()[1], "number");
+        assert.strictEqual(x(.5), .5);
+        var x = identity().range([new Number(0), new Number(1)]);
+        assert.typeOf(x.range()[0], "number");
+        assert.typeOf(x.range()[1], "number");
+        assert.strictEqual(x(.5), .5);
+      },
+      "can specify a polyidentity domain and range": function(identity) {
+        var x = identity().domain([-10, 0, 100]);
+        assert.deepEqual(x.domain(), [-10, 0, 100]);
+        assert.strictEqual(x(-5), -5);
+        assert.strictEqual(x(50), 50);
+        assert.strictEqual(x(75), 75);
+        var x = identity().range([-10, 0, 100]);
+        assert.deepEqual(x.range(), [-10, 0, 100]);
+        assert.strictEqual(x(-5), -5);
+        assert.strictEqual(x(50), 50);
+        assert.strictEqual(x(75), 75);
+      },
+      "do not affect the identity function": function(identity) {
+        var x = identity().domain([Infinity, NaN]);
+        assert.strictEqual(x(42), 42);
+        assert.strictEqual(x.invert(-42), -42);
+      }
+    },
+    "is the identity function": function(identity) {
+      var x = identity().domain([1, 2]);
+      assert.strictEqual(x(.5), .5);
+      assert.strictEqual(x(1), 1);
+      assert.strictEqual(x(1.5), 1.5);
+      assert.strictEqual(x(2), 2);
+      assert.strictEqual(x(2.5), 2.5);
+    },
+    "coerces input to a number": function(identity) {
+      var x = identity().domain([1, 2]);
+      assert.strictEqual(x("2"), 2);
+    },
+    "invert": {
+      "is the identity function": function(identity) {
+        var x = identity().domain([1, 2]);
+        assert.strictEqual(x.invert(.5), .5);
+        assert.strictEqual(x.invert(1), 1);
+        assert.strictEqual(x.invert(1.5), 1.5);
+        assert.strictEqual(x.invert(2), 2);
+        assert.strictEqual(x.invert(2.5), 2.5);
+      },
+      "coerces range value to numbers": function(identity) {
+        var x = identity().range(["0", "2"]);
+        assert.strictEqual(x.invert("1"), 1);
+        var x = identity().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]);
+        assert.strictEqual(x.invert(new Date(1990, 6, 2, 13)), +new Date(1990, 6, 2, 13));
+        var x = identity().range(["#000", "#fff"]);
+        assert.isNaN(x.invert("#999"));
+      },
+      "coerces input to a number": function(identity) {
+        var x = identity().domain([1, 2]);
+        assert.strictEqual(x.invert("2"), 2);
+      }
+    },
+    "ticks": {
+      "generates ticks of varying degree": function(identity) {
+        var x = identity();
+        assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);
+        assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);
+        assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);
+        assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
+        var x = identity().domain([1, 0]);
+        assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);
+        assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);
+        assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);
+        assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
+      },
+      "formats ticks with the appropriate precision": function(identity) {
+        var x = identity().domain([.123456789, 1.23456789]);
+        assert.strictEqual(x.tickFormat(1)(x.ticks(1)[0]), "1");
+        assert.strictEqual(x.tickFormat(2)(x.ticks(2)[0]), "0.5");
+        assert.strictEqual(x.tickFormat(4)(x.ticks(4)[0]), "0.2");
+        assert.strictEqual(x.tickFormat(8)(x.ticks(8)[0]), "0.2");
+        assert.strictEqual(x.tickFormat(16)(x.ticks(16)[0]), "0.2");
+        assert.strictEqual(x.tickFormat(32)(x.ticks(32)[0]), "0.15");
+        assert.strictEqual(x.tickFormat(64)(x.ticks(64)[0]), "0.14");
+        assert.strictEqual(x.tickFormat(128)(x.ticks(128)[0]), "0.13");
+        assert.strictEqual(x.tickFormat(256)(x.ticks(256)[0]), "0.125");
+      }
+    },
+    "copy": {
+      "changes to the domain or range are isolated": function(identity) {
+        var x = identity(), y = x.copy();
+        x.domain([1, 2]);
+        assert.deepEqual(y.domain(), [0, 1]);
+        y.domain([2, 3]);
+        assert.deepEqual(x.domain(), [1, 2]);
+        assert.deepEqual(y.domain(), [2, 3]);
+        var x = identity(), y = x.copy();
+        x.range([1, 2]);
+        assert.deepEqual(y.range(), [0, 1]);
+        y.range([2, 3]);
+        assert.deepEqual(x.range(), [1, 2]);
+        assert.deepEqual(y.range(), [2, 3]);
+      }
+    }
+  }
+});
+suite.export(module);