rubyvis 0.6.0 → 0.6.1

data/vendor/protovis/src/text/Format.js

@@ -1,78 +0,0 @@
-/**
- * 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/protovis/src/text/NumberFormat.js

@@ -1,227 +0,0 @@
-/**
- * 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/protovis/src/text/TimeFormat.js

@@ -1,115 +0,0 @@
-/**
- * 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;
-};