d3js-plugins-rails 0.0.1

data/vendor/assets/javascripts/d3/plugins/interpolate-zoom/README.md

@@ -0,0 +1,11 @@
+# Interpolate Zoom
+
+An interpolator for zooming and panning between two views of a two-dimensional plane, based on [“Smooth and efficient zooming and panning”](https://www.google.com/search?q=Smooth+and+efficient+zooming+and+panning) by Jarke J. van Wijk and Wim A.A. Nuij.
+
+Demo: <http://bl.ocks.org/3828981>
+
+<a name="interpolateZoom" href="#interpolateZoom">#</a> d3.**interpolateZoom**(*start*, *end*)
+
+Returns an [interpolator](https://github.com/mbostock/d3/wiki/Transitions#wiki-_interpolate) between the two points *start* and *end*. Each point should be defined as an array of three numbers in world coordinates: *ux*, *uy* and *w*. The first two coordinates *ux*, *uy* are the center of the viewport. The last coordinate *w* is the size of the viewport.
+
+The returned interpolator also has a *duration* property which encodes the recommended transition duration in milliseconds. This duration is based on the path length of the curved trajectory through *u,w* space. If you want to a slower or faster transition, feel free to multiply this by an arbitrary scale factor (*V* as described in the original paper).

data/vendor/assets/javascripts/d3/plugins/interpolate-zoom/interpolate-zoom.js

@@ -0,0 +1,75 @@
+(function() {
+
+var ρ = Math.SQRT2,
+    ρ2 = 2,
+    ρ4 = 4;
+
+// p0 = [ux0, uy0, w0]
+// p1 = [ux1, uy1, w1]
+d3.interpolateZoom = function(p0, p1) {
+  var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],
+      ux1 = p1[0], uy1 = p1[1], w1 = p1[2];
+  return ux0 === ux1 && uy0 === uy1
+      ? interpolate1(ux0, uy0, w0, w1)
+      : interpolate2(ux0, uy0, ux1, uy1, w0, w1);
+};
+
+// Special case for u0 = u1.
+function interpolate1(ux0, uy0, w0, w1) {
+  var S = Math.abs(Math.log(w1 / w0)) / ρ,
+      k = w1 < w0 ? -1 : 1;
+
+  function interpolate(t) {
+    var s = t * S;
+    return [
+      ux0,
+      uy0,
+      w0 * Math.exp(k * ρ * s)
+    ];
+  }
+
+  interpolate.duration = S * 1000;
+
+  return interpolate;
+};
+
+// General case.
+function interpolate2(ux0, uy0, ux1, uy1, w0, w1) {
+  var dx = ux1 - ux0,
+      dy = uy1 - uy0,
+      d2 = dx * dx + dy * dy,
+      d1 = Math.sqrt(d2),
+      b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1),
+      b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1),
+      r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),
+      r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1),
+      S = (r1 - r0) / ρ;
+
+  function interpolate(t) {
+    var s = t * S,
+        u = w0 / (ρ2 * d1) * (cosh(r0) * tanh(ρ * s + r0) - sinh(r0));
+    return [
+      ux0 + u * dx,
+      uy0 + u * dy,
+      w0 * cosh(r0) / cosh(ρ * s + r0)
+    ];
+  };
+
+  interpolate.duration = S * 1000;
+
+  return interpolate;
+};
+
+function cosh(x) {
+  return (Math.exp(x) + Math.exp(-x)) / 2;
+}
+
+function sinh(x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2;
+}
+
+function tanh(x) {
+  return sinh(x) / cosh(x);
+}
+
+})();

data/vendor/assets/javascripts/d3/plugins/jsonp/README.md

@@ -0,0 +1,26 @@
+# d3.jsonp
+
+Demo: <http://bl.ocks.org/4494715>
+
+A plugin for supporting the [JSONP](http://json-p.org/) technique of requesting
+cross-domain JSON data. This plugin is unstable and in development.
+
+Whenever possible, _use [CORS](http://en.wikipedia.org/wiki/Cross-origin_resource_sharing)
+instead of JSONP_. CORS handles errors properly, has better security, and
+supports formats besides JSON. See [enable-cors.org](http://enable-cors.org/) for more
+information.
+
+```js
+// autogenerate a callback in the form d3.jsonp.foo
+d3.jsonp('foo.jsonp?callback={callback}', function() {
+  console.log(arguments);
+});
+
+// specify a callback
+d3.jsonp('foo.jsonp?callback=d3.jsonp.foo', function() {
+  console.log(arguments);
+});
+```
+
+This plugin requires servers to accept callbacks with numeric and `.`
+characters. Unlike `d3.xhr` functions, there is no error handling.

data/vendor/assets/javascripts/d3/plugins/jsonp/jsonp.js

@@ -0,0 +1,25 @@
+d3.jsonp = function (url, callback) {
+  function rand() {
+    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+      c = '', i = -1;
+    while (++i < 15) c += chars.charAt(Math.floor(Math.random() * 52));
+    return c;
+  }
+
+  function create(url) {
+    var e = url.match(/callback=d3.jsonp.(\w+)/),
+      c = e ? e[1] : rand();
+    d3.jsonp[c] = function(data) {
+      callback(data);
+      delete d3.jsonp[c];
+      script.remove();
+    };
+    return 'd3.jsonp.' + c;
+  }
+
+  var cb = create(url),
+    script = d3.select('head')
+    .append('script')
+    .attr('type', 'text/javascript')
+    .attr('src', url.replace(/(\{|%7B)callback(\{|%7D)/, cb));
+};

data/vendor/assets/javascripts/d3/plugins/keybinding/README.md

@@ -0,0 +1,17 @@
+# keybinding
+
+Keybindings for d3
+
+Demo: <http://bl.ocks.org/4444952>
+
+<a name="keybinding" href="#keybinding">#</a> d3.**keybinding**()
+
+Returns a keybinding object that can be used with `.call` to provide
+bindings on selections.
+
+The keybinding object exposes `.on()` for common keycodes and dispatches events
+with arguments `[d3.event, modifiers]` in which modifiers is a string which
+can include `⇧`, `⌃`, `⌥`, `⌘'`.
+
+Keystroke events on input areas (`<input>`, `<select>`, and `<textarea>`)
+are not caught.

data/vendor/assets/javascripts/d3/plugins/keybinding/keybinding.js

@@ -0,0 +1,120 @@
+d3.keybinding = function() {
+    // via https://github.com/keithamus/jwerty/
+    // and https://github.com/madrobby/keymaster
+    var _keys = {
+        // MOD aka toggleable keys
+        mods: {
+            // Shift key, ⇧
+            '⇧': 16,
+            // CTRL key, on Mac: ⌃
+            '⌃': 17,
+            // ALT key, on Mac: ⌥ (Alt)
+            '⌥': 18,
+            // META, on Mac: ⌘ (CMD), on Windows (Win), on Linux (Super)
+            '⌘': 91
+        },
+        // Normal keys
+        keys: {
+            // Backspace key, on Mac: ⌫ (Backspace)
+            '⌫': 8, backspace: 8,
+            // Tab Key, on Mac: ⇥ (Tab), on Windows ⇥⇥
+            '⇥': 9, '⇆': 9, tab: 9,
+            // Return key, ↩
+            '↩': 13, 'return': 13, enter: 13, '⌅': 13,
+            // Pause/Break key
+            'pause': 19, 'pause-break': 19,
+            // Caps Lock key, ⇪
+            '⇪': 20, caps: 20, 'caps-lock': 20,
+            // Escape key, on Mac: ⎋, on Windows: Esc
+            '⎋': 27, escape: 27, esc: 27,
+            // Space key
+            space: 32,
+            // Page-Up key, or pgup, on Mac: ↖
+            '↖': 33, pgup: 33, 'page-up': 33,
+            // Page-Down key, or pgdown, on Mac: ↘
+            '↘': 34, pgdown: 34, 'page-down': 34,
+            // END key, on Mac: ⇟
+            '⇟': 35, end: 35,
+            // HOME key, on Mac: ⇞
+            '⇞': 36, home: 36,
+            // Insert key, or ins
+            ins: 45, insert: 45,
+            // Delete key, on Mac: ⌦ (Delete)
+            '⌦': 46, del: 46, 'delete': 46,
+            // Left Arrow Key, or ←
+            '←': 37, left: 37, 'arrow-left': 37,
+            // Up Arrow Key, or ↑
+            '↑': 38, up: 38, 'arrow-up': 38,
+            // Right Arrow Key, or →
+            '→': 39, right: 39, 'arrow-right': 39,
+            // Up Arrow Key, or ↓
+            '↓': 40, down: 40, 'arrow-down': 40,
+            // odities, printing characters that come out wrong:
+            // Num-Multiply, or *
+            '*': 106, star: 106, asterisk: 106, multiply: 106,
+            // Num-Plus or +
+            '+': 107, 'plus': 107,
+            // Num-Subtract, or -
+            '-': 109, subtract: 109,
+            // Semicolon
+            ';': 186, semicolon:186,
+            // = or equals
+            '=': 187, 'equals': 187,
+            // Comma, or ,
+            ',': 188, comma: 188,
+            //'-': 189, //???
+            // Period, or ., or full-stop
+            '.': 190, period: 190, 'full-stop': 190,
+            // Slash, or /, or forward-slash
+            '/': 191, slash: 191, 'forward-slash': 191,
+            // Tick, or `, or back-quote
+            '`': 192, tick: 192, 'back-quote': 192,
+            // Open bracket, or [
+            '[': 219, 'open-bracket': 219,
+            // Back slash, or \
+            '\\': 220, 'back-slash': 220,
+            // Close backet, or ]
+            ']': 221, 'close-bracket': 221,
+            // Apostraphe, or Quote, or '
+            '\'': 222, quote: 222, apostraphe: 222
+        }
+    };
+    // To minimise code bloat, add all of the NUMPAD 0-9 keys in a loop
+    var i = 95, n = 0;
+    while (++i < 106) _keys.keys['num-' + n] = i; ++n;
+    // To minimise code bloat, add all of the top row 0-9 keys in a loop
+    i = 47, n = 0;
+    while (++i < 58) _keys.keys[n] = i; ++n;
+    // To minimise code bloat, add all of the F1-F25 keys in a loop
+    i = 111, n = 1;
+    while (++i < 136) _keys.keys['f' + n] = i; ++n;
+    // To minimise code bloat, add all of the letters of the alphabet in a loop
+    i = 64;
+    while(++i < 91) _keys.keys[String.fromCharCode(i).toLowerCase()] = i;
+
+    var pairs = d3.entries(_keys.keys),
+        event = d3.dispatch.apply(d3, d3.keys(_keys.keys));
+
+    function keys(selection) {
+        selection.on('keydown', function () {
+            var tagName = d3.select(d3.event.target).node().tagName;
+            if (tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA') {
+                return;
+            }
+
+            var modifiers = '';
+            if (d3.event.shiftKey) modifiers += '⇧';
+            if (d3.event.ctrlKey) modifiers += '⌃';
+            if (d3.event.altKey) modifiers += '⌥';
+            if (d3.event.metaKey) modifiers += '⌘';
+
+            pairs.filter(function(d) {
+                return d.value === d3.event.keyCode;
+            }).forEach(function(d) {
+                event[d.key](d3.event, modifiers);
+            });
+        });
+    }
+
+    return d3.rebind(keys, event, 'on');
+};

data/vendor/assets/javascripts/d3/plugins/longscroll/README.md

@@ -0,0 +1,10 @@
+# d3.longscroll
+
+Scroll large numbers of rows using virtual rendering: <http://bl.ocks.org/3689677>
+
+## Limitations
+
+Currently, only up to around 1e7px of vertical space is supported in current
+browsers. A fix for this is [in the works][1].
+
+[1]: https://groups.google.com/d/msg/d3-js/vNOvn2YUcaI/mz7m1igScUUJ

data/vendor/assets/javascripts/d3/plugins/longscroll/longscroll.js

@@ -0,0 +1,75 @@
+(function() {
+
+// Virtual rendering for rows taking up to 1e7px of vertical space.
+// By Jason Davies, http://www.jasondavies.com/
+d3.longscroll = function() {
+  var render = null,
+      size = 0,
+      position = 0,
+      rowHeight = 20;
+
+  function longscroll(g) {
+    g.selectAll("div.before").data([0]).enter().append("div").attr("class", "before");
+    var current = g.selectAll("div.current").data([0]);
+    current.enter().append("div").attr("class", "current");
+    g.selectAll("div.after").data([0]).enter().append("div").attr("class", "after");
+
+    g.on("scroll.longscroll", function() {
+      position = Math.floor(this.scrollTop / rowHeight);
+      scroll(this.scrollTop);
+    });
+
+    scroll(0);
+    current.each(function() {
+      this.scrollIntoView();
+    });
+
+    function scroll(scrollTop) {
+      g.each(function() {
+        this.scrollTop = scrollTop;
+        var g = d3.select(this),
+            rows = 1 + Math.ceil(this.clientHeight / rowHeight),
+            position0 = Math.max(0, Math.min(size - rows, position)),
+            position1 = position0 + rows;
+
+        g.select(".before").style("height", position0 * rowHeight + "px");
+        g.select(".after").style("height", (size - position1) * rowHeight + "px");
+
+        var div = g.select(".current").selectAll("div.row")
+            .data(d3.range(position0, Math.min(position1, size)), String);
+        div.enter().append("div")
+            .attr("class", "row");
+        div.exit().remove();
+        div.order().call(render);
+      });
+    }
+  }
+
+  longscroll.render = function(_) {
+    if (!arguments.length) return render;
+    render = _;
+    return longscroll;
+  };
+
+  longscroll.rowHeight = function(_) {
+    if (!arguments.length) return rowHeight;
+    rowHeight = +_;
+    return longscroll;
+  };
+
+  longscroll.position = function(_) {
+    if (!arguments.length) return position;
+    position = +_;
+    return longscroll;
+  };
+
+  longscroll.size = function(_) {
+    if (!arguments.length) return size;
+    size = +_;
+    return longscroll;
+  };
+
+  return longscroll;
+};
+
+})();

data/vendor/assets/javascripts/d3/plugins/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "d3-plugins",
+  "version": "0.0.1",
+  "description": "Plugins for D3.js.",
+  "keywords": ["visualization"],
+  "homepage": "http://github.com/d3/d3-plugins",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/d3/d3-plugins.git"
+  },
+  "dependencies": {
+    "d3": "3.0.x"
+  },
+  "devDependencies": {
+    "vows": "0.6.x"
+  },
+  "scripts": {
+    "test": "./node_modules/vows/bin/vows `find . -name \"*-test.js\" \\! -path \"./node_modules/*\"`"
+  }
+}

data/vendor/assets/javascripts/d3/plugins/qq/README.md

@@ -0,0 +1,3 @@
+# Q-Q Plots
+
+Example: <http://bl.ocks.org/4349187>

data/vendor/assets/javascripts/d3/plugins/qq/qq.js

@@ -0,0 +1,249 @@
+(function() {
+
+// Based on http://vis.stanford.edu/protovis/ex/qqplot.html
+d3.qq = function() {
+  var width = 1,
+      height = 1,
+      duration = 0,
+      domain = null,
+      tickFormat = null,
+      n = 100,
+      x = qqX,
+      y = qqY;
+
+  // For each small multiple…
+  function qq(g) {
+    g.each(function(d, i) {
+      var g = d3.select(this),
+          qx = qqQuantiles(n, x.call(this, d, i)),
+          qy = qqQuantiles(n, y.call(this, d, i)),
+          xd = domain && domain.call(this, d, i) || [d3.min(qx), d3.max(qx)], // new x-domain
+          yd = domain && domain.call(this, d, i) || [d3.min(qy), d3.max(qy)], // new y-domain
+          x0, // old x-scale
+          y0; // old y-scale
+
+      // Compute the new x-scale.
+      var x1 = d3.scale.linear()
+          .domain(xd)
+          .range([0, width]);
+
+      // Compute the new y-scale.
+      var y1 = d3.scale.linear()
+          .domain(yd)
+          .range([height, 0]);
+
+      // Retrieve the old scales, if this is an update.
+      if (this.__chart__) {
+        x0 = this.__chart__.x;
+        y0 = this.__chart__.y;
+      } else {
+        x0 = d3.scale.linear().domain([0, Infinity]).range(x1.range());
+        y0 = d3.scale.linear().domain([0, Infinity]).range(y1.range());
+      }
+
+      // Stash the new scales.
+      this.__chart__ = {x: x1, y: y1};
+
+      // Update diagonal line.
+      var diagonal = g.selectAll("line.diagonal")
+          .data([null]);
+
+      diagonal.enter().append("svg:line")
+          .attr("class", "diagonal")
+          .attr("x1", x1(yd[0]))
+          .attr("y1", y1(xd[0]))
+          .attr("x2", x1(yd[1]))
+          .attr("y2", y1(xd[1]));
+
+      diagonal.transition()
+          .duration(duration)
+          .attr("x1", x1(yd[0]))
+          .attr("y1", y1(xd[0]))
+          .attr("x2", x1(yd[1]))
+          .attr("y2", y1(xd[1]));
+
+      // Update quantile plots.
+      var circle = g.selectAll("circle")
+          .data(d3.range(n).map(function(i) {
+            return {x: qx[i], y: qy[i]};
+          }));
+
+      circle.enter().append("svg:circle")
+          .attr("class", "quantile")
+          .attr("r", 4.5)
+          .attr("cx", function(d) { return x0(d.x); })
+          .attr("cy", function(d) { return y0(d.y); })
+          .style("opacity", 1e-6)
+        .transition()
+          .duration(duration)
+          .attr("cx", function(d) { return x1(d.x); })
+          .attr("cy", function(d) { return y1(d.y); })
+          .style("opacity", 1);
+
+      circle.transition()
+          .duration(duration)
+          .attr("cx", function(d) { return x1(d.x); })
+          .attr("cy", function(d) { return y1(d.y); })
+          .style("opacity", 1);
+
+      circle.exit().transition()
+          .duration(duration)
+          .attr("cx", function(d) { return x1(d.x); })
+          .attr("cy", function(d) { return y1(d.y); })
+          .style("opacity", 1e-6)
+          .remove();
+
+      var xformat = tickFormat || x1.tickFormat(4),
+          yformat = tickFormat || y1.tickFormat(4),
+          tx = function(d) { return "translate(" + x1(d) + "," + height + ")"; },
+          ty = function(d) { return "translate(0," + y1(d) + ")"; };
+
+      // Update x-ticks.
+      var xtick = g.selectAll("g.x.tick")
+          .data(x1.ticks(4), function(d) {
+            return this.textContent || xformat(d);
+          });
+
+      var xtickEnter = xtick.enter().append("svg:g")
+          .attr("class", "x tick")
+          .attr("transform", function(d) { return "translate(" + x0(d) + "," + height + ")"; })
+          .style("opacity", 1e-6);
+
+      xtickEnter.append("svg:line")
+          .attr("y1", 0)
+          .attr("y2", -6);
+
+      xtickEnter.append("svg:text")
+          .attr("text-anchor", "middle")
+          .attr("dy", "1em")
+          .text(xformat);
+
+      // Transition the entering ticks to the new scale, x1.
+      xtickEnter.transition()
+          .duration(duration)
+          .attr("transform", tx)
+          .style("opacity", 1);
+
+      // Transition the updating ticks to the new scale, x1.
+      xtick.transition()
+          .duration(duration)
+          .attr("transform", tx)
+          .style("opacity", 1);
+
+      // Transition the exiting ticks to the new scale, x1.
+      xtick.exit().transition()
+          .duration(duration)
+          .attr("transform", tx)
+          .style("opacity", 1e-6)
+          .remove();
+
+      // Update ticks.
+      var ytick = g.selectAll("g.y.tick")
+          .data(y1.ticks(4), function(d) {
+            return this.textContent || yformat(d);
+          });
+
+      var ytickEnter = ytick.enter().append("svg:g")
+          .attr("class", "y tick")
+          .attr("transform", function(d) { return "translate(0," + y0(d) + ")"; })
+          .style("opacity", 1e-6);
+
+      ytickEnter.append("svg:line")
+          .attr("x1", 0)
+          .attr("x2", 6);
+
+      ytickEnter.append("svg:text")
+          .attr("text-anchor", "end")
+          .attr("dx", "-.5em")
+          .attr("dy", ".3em")
+          .text(yformat);
+
+      // Transition the entering ticks to the new scale, y1.
+      ytickEnter.transition()
+          .duration(duration)
+          .attr("transform", ty)
+          .style("opacity", 1);
+
+      // Transition the updating ticks to the new scale, y1.
+      ytick.transition()
+          .duration(duration)
+          .attr("transform", ty)
+          .style("opacity", 1);
+
+      // Transition the exiting ticks to the new scale, y1.
+      ytick.exit().transition()
+          .duration(duration)
+          .attr("transform", ty)
+          .style("opacity", 1e-6)
+          .remove();
+    });
+  }
+
+  qq.width = function(x) {
+    if (!arguments.length) return width;
+    width = x;
+    return qq;
+  };
+
+  qq.height = function(x) {
+    if (!arguments.length) return height;
+    height = x;
+    return qq;
+  };
+
+  qq.duration = function(x) {
+    if (!arguments.length) return duration;
+    duration = x;
+    return qq;
+  };
+
+  qq.domain = function(x) {
+    if (!arguments.length) return domain;
+    domain = x == null ? x : d3.functor(x);
+    return qq;
+  };
+
+  qq.count = function(z) {
+    if (!arguments.length) return n;
+    n = z;
+    return qq;
+  };
+
+  qq.x = function(z) {
+    if (!arguments.length) return x;
+    x = z;
+    return qq;
+  };
+
+  qq.y = function(z) {
+    if (!arguments.length) return y;
+    y = z;
+    return qq;
+  };
+
+  qq.tickFormat = function(x) {
+    if (!arguments.length) return tickFormat;
+    tickFormat = x;
+    return qq;
+  };
+
+  return qq;
+};
+
+function qqQuantiles(n, values) {
+  var m = values.length - 1;
+  values = values.slice().sort(d3.ascending);
+  return d3.range(n).map(function(i) {
+    return values[~~(i * m / n)];
+  });
+}
+
+function qqX(d) {
+  return d.x;
+}
+
+function qqY(d) {
+  return d.y;
+}
+
+})();