rubyvis 0.1.0 → 0.1.1

data/vendor/src/text/Format.js

@@ -0,0 +1,78 @@
+/**
+ * Abstract; see an implementing class.
+ *
+ * @class Represents an abstract text formatter and parser. A <i>format</i> is a
+ * function that converts an object of a given type, such as a <tt>Date</tt>, to
+ * a human-readable string representation. The format may also have a
+ * {@link #parse} method for converting a string representation back to the
+ * given object type.
+ *
+ * <p>Because formats are themselves functions, they can be used directly as
+ * mark properties. For example, if the data associated with a label are dates,
+ * a date format can be used as label text:
+ *
+ * <pre>    .text(pv.Format.date("%m/%d/%y"))</pre>
+ *
+ * And as with scales, if the format is used in multiple places, it can be
+ * convenient to declare it as a global variable and then reference it from the
+ * appropriate property functions. For example, if the data has a <tt>date</tt>
+ * attribute, and <tt>format</tt> references a given date format:
+ *
+ * <pre>    .text(function(d) format(d.date))</pre>
+ *
+ * Similarly, to parse a string into a date:
+ *
+ * <pre>var date = format.parse("4/30/2010");</pre>
+ *
+ * Not all format implementations support parsing. See the implementing class
+ * for details.
+ *
+ * @see pv.Format.date
+ * @see pv.Format.number
+ * @see pv.Format.time
+ */
+pv.Format = {};
+
+/**
+ * Formats the specified object, returning the string representation.
+ *
+ * @function
+ * @name pv.Format.prototype.format
+ * @param {object} x the object to format.
+ * @returns {string} the formatted string.
+ */
+
+/**
+ * Parses the specified string, returning the object representation.
+ *
+ * @function
+ * @name pv.Format.prototype.parse
+ * @param {string} x the string to parse.
+ * @returns {object} the parsed object.
+ */
+
+/**
+ * @private Given a string that may be used as part of a regular expression,
+ * this methods returns an appropriately quoted version of the specified string,
+ * with any special characters escaped.
+ *
+ * @param {string} s a string to quote.
+ * @returns {string} the quoted string.
+ */
+pv.Format.re = function(s) {
+  return s.replace(/[\\\^\$\*\+\?\[\]\(\)\.\{\}]/g, "\\$&");
+};
+
+/**
+ * @private Optionally pads the specified string <i>s</i> so that it is at least
+ * <i>n</i> characters long, using the padding character <i>c</i>.
+ *
+ * @param {string} c the padding character.
+ * @param {number} n the minimum string length.
+ * @param {string} s the string to pad.
+ * @returns {string} the padded string.
+ */
+pv.Format.pad = function(c, n, s) {
+  var m = n - String(s).length;
+  return (m < 1) ? s : new Array(m + 1).join(c) + s;
+};

data/vendor/src/text/NumberFormat.js

@@ -0,0 +1,227 @@
+/**
+ * Returns a default number format.
+ *
+ * @class Represents a number format, converting between a <tt>number</tt> and a
+ * <tt>string</tt>. This class allows numbers to be formatted with variable
+ * precision (both for the integral and fractional part of the number), optional
+ * thousands grouping, and optional padding. The thousands (",") and decimal
+ * (".") separator can be customized.
+ *
+ * @returns {pv.Format.number} a number format.
+ */
+pv.Format.number = function() {
+  var mini = 0, // default minimum integer digits
+      maxi = Infinity, // default maximum integer digits
+      mins = 0, // mini, including group separators
+      minf = 0, // default minimum fraction digits
+      maxf = 0, // default maximum fraction digits
+      maxk = 1, // 10^maxf
+      padi = "0", // default integer pad
+      padf = "0", // default fraction pad
+      padg = true, // whether group separator affects integer padding
+      decimal = ".", // default decimal separator
+      group = ",", // default group separator
+      np = "\u2212", // default negative prefix
+      ns = ""; // default negative suffix
+
+  /** @private */
+  function format(x) {
+    /* Round the fractional part, and split on decimal separator. */
+    if (Infinity > maxf) x = Math.round(x * maxk) / maxk;
+    var s = String(Math.abs(x)).split(".");
+
+    /* Pad, truncate and group the integral part. */
+    var i = s[0];
+    if (i.length > maxi) i = i.substring(i.length - maxi);
+    if (padg && (i.length < mini)) i = new Array(mini - i.length + 1).join(padi) + i;
+    if (i.length > 3) i = i.replace(/\B(?=(?:\d{3})+(?!\d))/g, group);
+    if (!padg && (i.length < mins)) i = new Array(mins - i.length + 1).join(padi) + i;
+    s[0] = x < 0 ? np + i + ns : i;
+
+    /* Pad the fractional part. */
+    var f = s[1] || "";
+    if (f.length < minf) s[1] = f + new Array(minf - f.length + 1).join(padf);
+
+    return s.join(decimal);
+  }
+
+  /**
+   * @function
+   * @name pv.Format.number.prototype.format
+   * @param {number} x
+   * @returns {string}
+   */
+  format.format = format;
+
+  /**
+   * Parses the specified string as a number. Before parsing, leading and
+   * trailing padding is removed. Group separators are also removed, and the
+   * decimal separator is replaced with the standard point ("."). The integer
+   * part is truncated per the maximum integer digits, and the fraction part is
+   * rounded per the maximum fraction digits.
+   *
+   * @function
+   * @name pv.Format.number.prototype.parse
+   * @param {string} x the string to parse.
+   * @returns {number} the parsed number.
+   */
+  format.parse = function(x) {
+    var re = pv.Format.re;
+
+    /* Remove leading and trailing padding. Split on the decimal separator. */
+    var s = String(x)
+        .replace(new RegExp("^(" + re(padi) + ")*"), "")
+        .replace(new RegExp("(" + re(padf) + ")*$"), "")
+        .split(decimal);
+
+    /* Remove grouping and truncate the integral part. */
+    var i = s[0].replace(new RegExp(re(group), "g"), "");
+    if (i.length > maxi) i = i.substring(i.length - maxi);
+
+    /* Round the fractional part. */
+    var f = s[1] ? Number("0." + s[1]) : 0;
+    if (Infinity > maxf) f = Math.round(f * maxk) / maxk;
+
+    return Math.round(i) + f;
+  };
+
+  /**
+   * Sets or gets the minimum and maximum number of integer digits. This
+   * controls the number of decimal digits to display before the decimal
+   * separator for the integral part of the number. If the number of digits is
+   * smaller than the minimum, the digits are padded; if the number of digits is
+   * larger, the digits are truncated, showing only the lower-order digits. The
+   * default range is [0, Infinity].
+   *
+   * <p>If only one argument is specified to this method, this value is used as
+   * both the minimum and maximum number. If no arguments are specified, a
+   * two-element array is returned containing the minimum and the maximum.
+   *
+   * @function
+   * @name pv.Format.number.prototype.integerDigits
+   * @param {number} [min] the minimum integer digits.
+   * @param {number} [max] the maximum integer digits.
+   * @returns {pv.Format.number} <tt>this</tt>, or the current integer digits.
+   */
+  format.integerDigits = function(min, max) {
+    if (arguments.length) {
+      mini = Number(min);
+      maxi = (arguments.length > 1) ? Number(max) : mini;
+      mins = mini + Math.floor(mini / 3) * group.length;
+      return this;
+    }
+    return [mini, maxi];
+  };
+
+  /**
+   * Sets or gets the minimum and maximum number of fraction digits. The
+   * controls the number of decimal digits to display after the decimal
+   * separator for the fractional part of the number. If the number of digits is
+   * smaller than the minimum, the digits are padded; if the number of digits is
+   * larger, the fractional part is rounded, showing only the higher-order
+   * digits. The default range is [0, 0].
+   *
+   * <p>If only one argument is specified to this method, this value is used as
+   * both the minimum and maximum number. If no arguments are specified, a
+   * two-element array is returned containing the minimum and the maximum.
+   *
+   * @function
+   * @name pv.Format.number.prototype.fractionDigits
+   * @param {number} [min] the minimum fraction digits.
+   * @param {number} [max] the maximum fraction digits.
+   * @returns {pv.Format.number} <tt>this</tt>, or the current fraction digits.
+   */
+  format.fractionDigits = function(min, max) {
+    if (arguments.length) {
+      minf = Number(min);
+      maxf = (arguments.length > 1) ? Number(max) : minf;
+      maxk = Math.pow(10, maxf);
+      return this;
+    }
+    return [minf, maxf];
+  };
+
+  /**
+   * Sets or gets the character used to pad the integer part. The integer pad is
+   * used when the number of integer digits is smaller than the minimum. The
+   * default pad character is "0" (zero).
+   *
+   * @param {string} [x] the new pad character.
+   * @returns {pv.Format.number} <tt>this</tt> or the current pad character.
+   */
+  format.integerPad = function(x) {
+    if (arguments.length) {
+      padi = String(x);
+      padg = /\d/.test(padi);
+      return this;
+    }
+    return padi;
+  };
+
+  /**
+   * Sets or gets the character used to pad the fration part. The fraction pad
+   * is used when the number of fraction digits is smaller than the minimum. The
+   * default pad character is "0" (zero).
+   *
+   * @param {string} [x] the new pad character.
+   * @returns {pv.Format.number} <tt>this</tt> or the current pad character.
+   */
+  format.fractionPad = function(x) {
+    if (arguments.length) {
+      padf = String(x);
+      return this;
+    }
+    return padf;
+  };
+
+  /**
+   * Sets or gets the character used as the decimal point, separating the
+   * integer and fraction parts of the number. The default decimal point is ".".
+   *
+   * @param {string} [x] the new decimal separator.
+   * @returns {pv.Format.number} <tt>this</tt> or the current decimal separator.
+   */
+  format.decimal = function(x) {
+    if (arguments.length) {
+      decimal = String(x);
+      return this;
+    }
+    return decimal;
+  };
+
+  /**
+   * Sets or gets the character used as the group separator, grouping integer
+   * digits by thousands. The default decimal point is ",". Grouping can be
+   * disabled by using "" for the separator.
+   *
+   * @param {string} [x] the new group separator.
+   * @returns {pv.Format.number} <tt>this</tt> or the current group separator.
+   */
+  format.group = function(x) {
+    if (arguments.length) {
+      group = x ? String(x) : "";
+      mins = mini + Math.floor(mini / 3) * group.length;
+      return this;
+    }
+    return group;
+  };
+
+  /**
+   * Sets or gets the negative prefix and suffix. The default negative prefix is
+   * "&minus;", and the default negative suffix is the empty string.
+   *
+   * @param {string} [x] the negative prefix.
+   * @param {string} [y] the negative suffix.
+   * @returns {pv.Format.number} <tt>this</tt> or the current negative format.
+   */
+  format.negativeAffix = function(x, y) {
+    if (arguments.length) {
+      np = String(x || "");
+      ns = String(y || "");
+      return this;
+    }
+    return [np, ns];
+  };
+
+  return format;
+};

data/vendor/src/text/TimeFormat.js

@@ -0,0 +1,115 @@
+/**
+ * Returns a time format of the given type, either "short" or "long".
+ *
+ * @class Represents a time format, converting between a <tt>number</tt>
+ * representing a duration in milliseconds, and a <tt>string</tt>. Two types of
+ * time formats are supported: "short" and "long". The <i>short</i> format type
+ * returns a string such as "3.3 days" or "12.1 minutes", while the <i>long</i>
+ * format returns "13:04:12" or similar.
+ *
+ * @extends pv.Format
+ * @param {string} type the type; "short" or "long".
+ */
+pv.Format.time = function(type) {
+  var pad = pv.Format.pad;
+
+  /*
+   * MILLISECONDS = 1
+   * SECONDS = 1e3
+   * MINUTES = 6e4
+   * HOURS = 36e5
+   * DAYS = 864e5
+   * WEEKS = 6048e5
+   * MONTHS = 2592e6
+   * YEARS = 31536e6
+   */
+
+  /** @private */
+  function format(t) {
+    t = Number(t); // force conversion from Date
+    switch (type) {
+      case "short": {
+        if (t >= 31536e6) {
+          return (t / 31536e6).toFixed(1) + " years";
+        } else if (t >= 6048e5) {
+          return (t / 6048e5).toFixed(1) + " weeks";
+        } else if (t >= 864e5) {
+          return (t / 864e5).toFixed(1) + " days";
+        } else if (t >= 36e5) {
+          return (t / 36e5).toFixed(1) + " hours";
+        } else if (t >= 6e4) {
+          return (t / 6e4).toFixed(1) + " minutes";
+        }
+        return (t / 1e3).toFixed(1) + " seconds";
+      }
+      case "long": {
+        var a = [],
+            s = ((t % 6e4) / 1e3) >> 0,
+            m = ((t % 36e5) / 6e4) >> 0;
+        a.push(pad("0", 2, s));
+        if (t >= 36e5) {
+          var h = ((t % 864e5) / 36e5) >> 0;
+          a.push(pad("0", 2, m));
+          if (t >= 864e5) {
+            a.push(pad("0", 2, h));
+            a.push(Math.floor(t / 864e5).toFixed());
+          } else {
+            a.push(h.toFixed());
+          }
+        } else {
+          a.push(m.toFixed());
+        }
+        return a.reverse().join(":");
+      }
+    }
+  }
+
+  /**
+   * Formats the specified time, returning the string representation.
+   *
+   * @function
+   * @name pv.Format.time.prototype.format
+   * @param {number} t the duration in milliseconds. May also be a <tt>Date</tt>.
+   * @returns {string} the formatted string.
+   */
+  format.format = format;
+
+  /**
+   * Parses the specified string, returning the time in milliseconds.
+   *
+   * @function
+   * @name pv.Format.time.prototype.parse
+   * @param {string} s a formatted string.
+   * @returns {number} the parsed duration in milliseconds.
+   */
+  format.parse = function(s) {
+    switch (type) {
+      case "short": {
+        var re = /([0-9,.]+)\s*([a-z]+)/g, a, t = 0;
+        while (a = re.exec(s)) {
+          var f = parseFloat(a[0].replace(",", "")), u = 0;
+          switch (a[2].toLowerCase()) {
+            case "year": case "years": u = 31536e6; break;
+            case "week": case "weeks": u = 6048e5; break;
+            case "day": case "days": u = 864e5; break;
+            case "hour": case "hours": u = 36e5; break;
+            case "minute": case "minutes": u = 6e4; break;
+            case "second": case "seconds": u = 1e3; break;
+          }
+          t += f * u;
+        }
+        return t;
+      }
+      case "long": {
+        var a = s.replace(",", "").split(":").reverse(), t = 0;
+        if (a.length) t += parseFloat(a[0]) * 1e3;
+        if (a.length > 1) t += parseFloat(a[1]) * 6e4;
+        if (a.length > 2) t += parseFloat(a[2]) * 36e5;
+        if (a.length > 3) t += parseFloat(a[3]) * 864e5;
+        return t;
+      }
+    }
+  }
+
+  return format;
+};

data/vendor/test1.html

@@ -0,0 +1,30 @@
+<html>
+<head>
+<script type="text/javascript" src="protovis-d3.3.js"></script>
+
+</head>
+<body>
+<script>
+var vis = new pv.Panel()
+    .width(150)
+    .height(150);
+
+vis.add(pv.Rule)
+    .data(pv.range(0, 2, .5))
+    .bottom(function(d) d * 80 + .5)
+  .add(pv.Label)
+     .left(0);
+
+
+vis.add(pv.Bar)
+    .data([1, 1.2, 1.7, 1.5, .7])
+    .width(20)
+    .height(function(d) d * 80)
+    .bottom(0)
+    .left(function() this.index * 25 + 25)
+  .anchor("top").add(pv.Label);
+
+vis.render();
+</script>
+</body>
+</html>