rubyvis 0.6.0 → 0.6.1

data/vendor/protovis/src/geo/LatLng.js

@@ -1,23 +0,0 @@
-/**
- * Abstract; not implemented. There is no explicit constructor; this class
- * merely serves to document the representation used by {@link pv.Geo.scale}.
- *
- * @class Represents a pair of geographic coordinates.
- *
- * @name pv.Geo.LatLng
- * @see pv.Geo.scale
- */
-
-/**
- * The <i>latitude</i> coordinate in degrees; positive is North.
- *
- * @type number
- * @name pv.Geo.LatLng.prototype.lat
- */
-
-/**
- * The <i>longitude</i> coordinate in degrees; positive is East.
- *
- * @type number
- * @name pv.Geo.LatLng.prototype.lng
- */

data/vendor/protovis/src/geo/Projection.js

@@ -1,43 +0,0 @@
-/**
- * Abstract; not implemented. There is no explicit constructor; this class
- * merely serves to document the representation used by {@link pv.Geo.scale}.
- *
- * @class Represents a geographic projection. This class provides the core
- * implementation for {@link pv.Geo.scale}s, mapping between geographic
- * coordinates (latitude and longitude) and normalized screen space in the range
- * [-1,1]. The remaining mapping between normalized screen space and actual
- * pixels is performed by <tt>pv.Geo.scale</tt>.
- *
- * <p>Many geographic projections have a point around which the projection is
- * centered. Rather than have each implementation add support for a
- * user-specified center point, the <tt>pv.Geo.scale</tt> translates the
- * geographic coordinates relative to the center point for both the forward and
- * inverse projection.
- *
- * <p>In general, this class should not be used directly, unless the desire is
- * to implement a new geographic projection. Instead, use <tt>pv.Geo.scale</tt>.
- * Implementations are not required to implement inverse projections, but are
- * needed for some forms of interactivity. Also note that some inverse
- * projections are ambiguous, such as the connecting points in Dymaxian maps.
- *
- * @name pv.Geo.Projection
- * @see pv.Geo.scale
- */
-
-/**
- * The <i>forward</i> projection.
- *
- * @function
- * @name pv.Geo.Projection.prototype.project
- * @param {pv.Geo.LatLng} latlng the latitude and longitude to project.
- * @returns {pv.Vector} the xy-coordinates of the given point.
- */
-
-/**
- * The <i>inverse</i> projection; optional.
- *
- * @function
- * @name pv.Geo.Projection.prototype.invert
- * @param {pv.Vector} xy the x- and y-coordinates to invert.
- * @returns {pv.Geo.LatLng} the latitude and longitude of the given point.
- */

data/vendor/protovis/src/geo/Projections.js

@@ -1,117 +0,0 @@
-/**
- * The built-in projections.
- *
- * @see pv.Geo.Projection
- * @namespace
- */
-pv.Geo.projections = {
-
-  /** @see http://en.wikipedia.org/wiki/Mercator_projection */
-  mercator: {
-    project: function(latlng) {
-      return {
-          x: latlng.lng / 180,
-          y: latlng.lat > 85 ? 1 : latlng.lat < -85 ? -1
-              : Math.log(Math.tan(Math.PI / 4
-              + pv.radians(latlng.lat) / 2)) / Math.PI
-        };
-    },
-    invert: function(xy) {
-      return {
-          lng: xy.x * 180,
-          lat: pv.degrees(2 * Math.atan(Math.exp(xy.y * Math.PI)) - Math.PI / 2)
-        };
-    }
-  },
-
-  /** @see http://en.wikipedia.org/wiki/Gall-Peters_projection */
-  "gall-peters": {
-    project: function(latlng) {
-      return {
-          x: latlng.lng / 180,
-          y: Math.sin(pv.radians(latlng.lat))
-        };
-    },
-    invert: function(xy) {
-      return {
-          lng: xy.x * 180,
-          lat: pv.degrees(Math.asin(xy.y))
-        };
-    }
-  },
-
-  /** @see http://en.wikipedia.org/wiki/Sinusoidal_projection */
-  sinusoidal: {
-    project: function(latlng) {
-      return {
-          x: pv.radians(latlng.lng) * Math.cos(pv.radians(latlng.lat)) / Math.PI,
-          y: latlng.lat / 90
-        };
-    },
-    invert: function(xy) {
-      return {
-          lng: pv.degrees((xy.x * Math.PI) / Math.cos(xy.y * Math.PI / 2)),
-          lat: xy.y * 90
-        };
-    }
-  },
-
-  /** @see http://en.wikipedia.org/wiki/Aitoff_projection */
-  aitoff: {
-    project: function(latlng) {
-      var l = pv.radians(latlng.lng),
-          f = pv.radians(latlng.lat),
-          a = Math.acos(Math.cos(f) * Math.cos(l / 2));
-      return {
-          x: 2 * (a ? (Math.cos(f) * Math.sin(l / 2) * a / Math.sin(a)) : 0) / Math.PI,
-          y: 2 * (a ? (Math.sin(f) * a / Math.sin(a)) : 0) / Math.PI
-        };
-    },
-    invert: function(xy) {
-      var x = xy.x * Math.PI / 2,
-          y = xy.y * Math.PI / 2;
-      return {
-          lng: pv.degrees(x / Math.cos(y)),
-          lat: pv.degrees(y)
-        };
-    }
-  },
-
-  /** @see http://en.wikipedia.org/wiki/Hammer_projection */
-  hammer: {
-    project: function(latlng) {
-      var l = pv.radians(latlng.lng),
-          f = pv.radians(latlng.lat),
-          c = Math.sqrt(1 + Math.cos(f) * Math.cos(l / 2));
-      return {
-          x: 2 * Math.SQRT2 * Math.cos(f) * Math.sin(l / 2) / c / 3,
-          y: Math.SQRT2 * Math.sin(f) / c / 1.5
-        };
-    },
-    invert: function(xy) {
-      var x = xy.x * 3,
-          y = xy.y * 1.5,
-          z = Math.sqrt(1 - x * x / 16 - y * y / 4);
-      return {
-          lng: pv.degrees(2 * Math.atan2(z * x, 2 * (2 * z * z - 1))),
-          lat: pv.degrees(Math.asin(z * y))
-        };
-    }
-  },
-
-  /** The identity or "none" projection. */
-  identity: {
-    project: function(latlng) {
-      return {
-          x: latlng.lng / 180,
-          y: latlng.lat / 90
-        };
-    },
-    invert: function(xy) {
-      return {
-          lng: xy.x * 180,
-          lat: xy.y * 90
-        };
-    }
-  }
-};

data/vendor/protovis/src/lang/Array.js

@@ -1,112 +0,0 @@
-/**
- * @class The built-in Array class.
- * @name Array
- */
-
-/**
- * Creates a new array with the results of calling a provided function on every
- * element in this array. Implemented in Javascript 1.6.
- *
- * @function
- * @name Array.prototype.map
- * @see <a
- * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/Map">map</a>
- * documentation.
- * @param {function} f function that produces an element of the new Array from
- * an element of the current one.
- * @param [o] object to use as <tt>this</tt> when executing <tt>f</tt>.
- */
-if (!Array.prototype.map) Array.prototype.map = function(f, o) {
-  var n = this.length;
-  var result = new Array(n);
-  for (var i = 0; i < n; i++) {
-    if (i in this) {
-      result[i] = f.call(o, this[i], i, this);
-    }
-  }
-  return result;
-};
-
-/**
- * Creates a new array with all elements that pass the test implemented by the
- * provided function. Implemented in Javascript 1.6.
- *
- * @function
- * @name Array.prototype.filter
- * @see <a
- * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/filter">filter</a>
- * documentation.
- * @param {function} f function to test each element of the array.
- * @param [o] object to use as <tt>this</tt> when executing <tt>f</tt>.
- */
-if (!Array.prototype.filter) Array.prototype.filter = function(f, o) {
-  var n = this.length;
-  var result = new Array();
-  for (var i = 0; i < n; i++) {
-    if (i in this) {
-      var v = this[i];
-      if (f.call(o, v, i, this)) result.push(v);
-    }
-  }
-  return result;
-};
-
-/**
- * Executes a provided function once per array element. Implemented in
- * Javascript 1.6.
- *
- * @function
- * @name Array.prototype.forEach
- * @see <a
- * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/ForEach">forEach</a>
- * documentation.
- * @param {function} f function to execute for each element.
- * @param [o] object to use as <tt>this</tt> when executing <tt>f</tt>.
- */
-if (!Array.prototype.forEach) Array.prototype.forEach = function(f, o) {
-  var n = this.length >>> 0;
-  for (var i = 0; i < n; i++) {
-    if (i in this) f.call(o, this[i], i, this);
-  }
-};
-
-/**
- * Apply a function against an accumulator and each value of the array (from
- * left-to-right) as to reduce it to a single value. Implemented in Javascript
- * 1.8.
- *
- * @function
- * @name Array.prototype.reduce
- * @see <a
- * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/Reduce">reduce</a>
- * documentation.
- * @param {function} f function to execute on each value in the array.
- * @param [v] object to use as the first argument to the first call of
- * <tt>t</tt>.
- */
-if (!Array.prototype.reduce) Array.prototype.reduce = function(f, v) {
-  var len = this.length;
-  if (!len && (arguments.length == 1)) {
-    throw new Error("reduce: empty array, no initial value");
-  }
-
-  var i = 0;
-  if (arguments.length < 2) {
-    while (true) {
-      if (i in this) {
-        v = this[i++];
-        break;
-      }
-      if (++i >= len) {
-        throw new Error("reduce: no values, no initial value");
-      }
-    }
-  }
-
-  for (; i < len; i++) {
-    if (i in this) {
-      v = f(v, this[i], i, this);
-    }
-  }
-  return v;
-};

data/vendor/protovis/src/lang/init.js

@@ -1,26 +0,0 @@
-/*
- * Parses the Protovis specifications on load, allowing the use of JavaScript
- * 1.8 function expressions on browsers that only support JavaScript 1.6.
- *
- * @see pv.parse
- */
-pv.listen(window, "load", function() {
-   /*
-    * Note: in Firefox any variables declared here are visible to the eval'd
-    * script below. Even worse, any global variables declared by the script
-    * could overwrite local variables here (such as the index, `i`)!  To protect
-    * against this, all variables are explicitly scoped on a pv.$ object.
-    */
-    pv.$ = {i:0, x:document.getElementsByTagName("script")};
-    for (; pv.$.i < pv.$.x.length; pv.$.i++) {
-      pv.$.s = pv.$.x[pv.$.i];
-      if (pv.$.s.type == "text/javascript+protovis") {
-        try {
-          window.eval(pv.parse(pv.$.s.text));
-        } catch (e) {
-          pv.error(e);
-        }
-      }
-    }
-    delete pv.$;
-  });

data/vendor/protovis/src/layout/Arc.js

@@ -1,178 +0,0 @@
-/**
- * Constructs a new, empty arc layout. Layouts are not typically constructed
- * directly; instead, they are added to an existing panel via
- * {@link pv.Mark#add}.
- *
- * @class Implements a layout for arc diagrams. An arc diagram is a network
- * visualization with a one-dimensional layout of nodes, using circular arcs to
- * render links between nodes. For undirected networks, arcs are rendering on a
- * single side; this makes arc diagrams useful as annotations to other
- * two-dimensional network layouts, such as rollup, matrix or table layouts. For
- * directed networks, links in opposite directions can be rendered on opposite
- * sides using <tt>directed(true)</tt>.
- *
- * <p>Arc layouts are particularly sensitive to node ordering; for best results,
- * order the nodes such that related nodes are close to each other. A poor
- * (e.g., random) order may result in large arcs with crossovers that impede
- * visual processing. A future improvement to this layout may include automatic
- * reordering using, e.g., spectral graph layout or simulated annealing.
- *
- * <p>This visualization technique is related to that developed by
- * M. Wattenberg, <a
- * href="http://www.research.ibm.com/visual/papers/arc-diagrams.pdf">"Arc
- * Diagrams: Visualizing Structure in Strings"</a> in <i>IEEE InfoVis</i>, 2002.
- * However, this implementation is limited to simple node-link networks, as
- * opposed to structures with hierarchical self-similarity (such as strings).
- *
- * <p>As with other network layouts, three mark prototypes are provided:<ul>
- *
- * <li><tt>node</tt> - for rendering nodes; typically a {@link pv.Dot}.
- * <li><tt>link</tt> - for rendering links; typically a {@link pv.Line}.
- * <li><tt>label</tt> - for rendering node labels; typically a {@link pv.Label}.
- *
- * </ul>For more details on how this layout is structured and can be customized,
- * see {@link pv.Layout.Network}.
- *
- * @extends pv.Layout.Network
- **/
-pv.Layout.Arc = function() {
-  pv.Layout.Network.call(this);
-  var interpolate, // cached interpolate
-      directed, // cached directed
-      reverse, // cached reverse
-      buildImplied = this.buildImplied;
-
-  /** @private Cache layout state to optimize properties. */
-  this.buildImplied = function(s) {
-    buildImplied.call(this, s);
-    directed = s.directed;
-    interpolate = s.orient == "radial" ? "linear" : "polar";
-    reverse = s.orient == "right" || s.orient == "top";
-  };
-
-  /* Override link properties to handle directedness and orientation. */
-  this.link
-      .data(function(p) {
-          var s = p.sourceNode, t = p.targetNode;
-          return reverse != (directed || (s.breadth < t.breadth)) ? [s, t] : [t, s];
-        })
-      .interpolate(function() { return interpolate; });
-};
-
-pv.Layout.Arc.prototype = pv.extend(pv.Layout.Network)
-    .property("orient", String)
-    .property("directed", Boolean);
-
-/**
- * Default properties for arc layouts. By default, the orientation is "bottom".
- *
- * @type pv.Layout.Arc
- */
-pv.Layout.Arc.prototype.defaults = new pv.Layout.Arc()
-    .extend(pv.Layout.Network.prototype.defaults)
-    .orient("bottom");
-
-/**
- * Specifies an optional sort function. The sort function follows the same
- * comparator contract required by {@link pv.Dom.Node#sort}. Specifying a sort
- * function provides an alternative to sort the nodes as they are specified by
- * the <tt>nodes</tt> property; the main advantage of doing this is that the
- * comparator function can access implicit fields populated by the network
- * layout, such as the <tt>linkDegree</tt>.
- *
- * <p>Note that arc diagrams are particularly sensitive to order. This is
- * referred to as the seriation problem, and many different techniques exist to
- * find good node orders that emphasize clusters, such as spectral layout and
- * simulated annealing.
- *
- * @param {function} f comparator function for nodes.
- * @returns {pv.Layout.Arc} this.
- */
-pv.Layout.Arc.prototype.sort = function(f) {
-  this.$sort = f;
-  return this;
-};
-
-/** @private Populates the x, y and angle attributes on the nodes. */
-pv.Layout.Arc.prototype.buildImplied = function(s) {
-  if (pv.Layout.Network.prototype.buildImplied.call(this, s)) return;
-
-  var nodes = s.nodes,
-      orient = s.orient,
-      sort = this.$sort,
-      index = pv.range(nodes.length),
-      w = s.width,
-      h = s.height,
-      r = Math.min(w, h) / 2;
-
-  /* Sort the nodes. */
-  if (sort) index.sort(function(a, b) { return sort(nodes[a], nodes[b]); });
-
-  /** @private Returns the mid-angle, given the breadth. */
-  function midAngle(b) {
-    switch (orient) {
-      case "top": return -Math.PI / 2;
-      case "bottom": return Math.PI / 2;
-      case "left": return Math.PI;
-      case "right": return 0;
-      case "radial": return (b - .25) * 2 * Math.PI;
-    }
-  }
-
-  /** @private Returns the x-position, given the breadth. */
-  function x(b) {
-    switch (orient) {
-      case "top":
-      case "bottom": return b * w;
-      case "left": return 0;
-      case "right": return w;
-      case "radial": return w / 2 + r * Math.cos(midAngle(b));
-    }
-  }
-
-  /** @private Returns the y-position, given the breadth. */
-  function y(b) {
-    switch (orient) {
-      case "top": return 0;
-      case "bottom": return h;
-      case "left":
-      case "right": return b * h;
-      case "radial": return h / 2 + r * Math.sin(midAngle(b));
-    }
-  }
-
-  /* Populate the x, y and mid-angle attributes. */
-  for (var i = 0; i < nodes.length; i++) {
-    var n = nodes[index[i]], b = n.breadth = (i + .5) / nodes.length;
-    n.x = x(b);
-    n.y = y(b);
-    n.midAngle = midAngle(b);
-  }
-};
-
-/**
- * The orientation. The default orientation is "left", which means that nodes
- * will be positioned from left-to-right in the order they are specified in the
- * <tt>nodes</tt> property. The following orientations are supported:<ul>
- *
- * <li>left - left-to-right.
- * <li>right - right-to-left.
- * <li>top - top-to-bottom.
- * <li>bottom - bottom-to-top.
- * <li>radial - radially, starting at 12 o'clock and proceeding clockwise.</ul>
- *
- * @type string
- * @name pv.Layout.Arc.prototype.orient
- */
-
-/**
- * Whether this arc digram is directed (bidirectional); only applies to
- * non-radial orientations. By default, arc digrams are undirected, such that
- * all arcs appear on one side. If the arc digram is directed, then forward
- * links are drawn on the conventional side (the same as as undirected
- * links--right, left, bottom and top for left, right, top and bottom,
- * respectively), while reverse links are drawn on the opposite side.
- *
- * @type boolean
- * @name pv.Layout.Arc.prototype.directed
- */