git.roojs.org Git - roojs1/blob - Roo/util/Format.js

   1 /*
   2  * Based on:
   3  * Ext JS Library 1.1.1
   4  * Copyright(c) 2006-2007, Ext JS, LLC.
   5  *
   6  * Originally Released Under LGPL - original licence link has changed is not relivant.
   7  *
   8  * Fork - LGPL
   9  * <script type="text/javascript">
  10  */
  11
  12 /**
  13  * @class Roo.util.Format
  14  * Reusable data formatting functions
  15  * @singleton
  16  */
  17 Roo.util.Format = function(){
  18     var trimRe = /^\s+|\s+$/g;
  19     return {
  20         /**
  21          * Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length
  22          * @param {String} value The string to truncate
  23          * @param {Number} length The maximum length to allow before truncating
  24          * @return {String} The converted text
  25          */
  26         ellipsis : function(value, len){
  27             if(value && value.length > len){
  28                 return value.substr(0, len-3)+"...";
  29             }
  30             return value;
  31         },
  32
  33         /**
  34          * Checks a reference and converts it to empty string if it is undefined
  35          * @param {Mixed} value Reference to check
  36          * @return {Mixed} Empty string if converted, otherwise the original value
  37          */
  38         undef : function(value){
  39             return typeof value != "undefined" ? value : "";
  40         },
  41
  42         /**
  43          * Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
  44          * @param {String} value The string to encode
  45          * @return {String} The encoded text
  46          */
  47         htmlEncode : function(value){
  48             return !value ? value : String(value).replace(/&/g, "&amp;").replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
  49         },
  50
  51         /**
  52          * Convert certain characters (&, <, >, and ') from their HTML character equivalents.
  53          * @param {String} value The string to decode
  54          * @return {String} The decoded text
  55          */
  56         htmlDecode : function(value){
  57             return !value ? value : String(value).replace(/&amp;/g, "&").replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&quot;/g, '"');
  58         },
  59
  60         /**
  61          * Trims any whitespace from either side of a string
  62          * @param {String} value The text to trim
  63          * @return {String} The trimmed text
  64          */
  65         trim : function(value){
  66             return String(value).replace(trimRe, "");
  67         },
  68
  69         /**
  70          * Returns a substring from within an original string
  71          * @param {String} value The original text
  72          * @param {Number} start The start index of the substring
  73          * @param {Number} length The length of the substring
  74          * @return {String} The substring
  75          */
  76         substr : function(value, start, length){
  77             return String(value).substr(start, length);
  78         },
  79
  80         /**
  81          * Converts a string to all lower case letters
  82          * @param {String} value The text to convert
  83          * @return {String} The converted text
  84          */
  85         lowercase : function(value){
  86             return String(value).toLowerCase();
  87         },
  88
  89         /**
  90          * Converts a string to all upper case letters
  91          * @param {String} value The text to convert
  92          * @return {String} The converted text
  93          */
  94         uppercase : function(value){
  95             return String(value).toUpperCase();
  96         },
  97
  98         /**
  99          * Converts the first character only of a string to upper case
 100          * @param {String} value The text to convert
 101          * @return {String} The converted text
 102          */
 103         capitalize : function(value){
 104             return !value ? value : value.charAt(0).toUpperCase() + value.substr(1).toLowerCase();
 105         },
 106
 107         // private
 108         call : function(value, fn){
 109             if(arguments.length > 2){
 110                 var args = Array.prototype.slice.call(arguments, 2);
 111                 args.unshift(value);
 112
 113                 return /** eval:var:value */  eval(fn).apply(window, args);
 114             }else{
 115                 /** eval:var:value */
 116                 return /** eval:var:value */ eval(fn).call(window, value);
 117             }
 118         },
 119
 120
 121         /**
 122          * safer version of Math.toFixed..??/
 123          * @param {Number/String} value The numeric value to format
 124          * @param {Number/String} value Decimal places
 125          * @return {String} The formatted currency string
 126          */
 127         toFixed : function(v, n)
 128         {
 129             // why not use to fixed - precision is buggered???
 130             if (!n) {
 131                 return Math.round(v-0);
 132             }
 133             var fact = Math.pow(10,n);
 134             v = (Math.round((v-0)*fact))/fact;
 135             var z = (''+fact).substring(1);
 136             if (v == Math.floor(v)) {
 137                 return Math.floor(v) + '.' + z;
 138             }
 139
 140             // now just padd decimals..
 141             var ps = String(v).split('.');
 142             var fd = (ps[1] + z);
 143             var r = fd.substring(0,n);
 144             var rm = fd.substring(n);
 145             if (rm < 5) {
 146                 return ps[0] + '.' + r;
 147             }
 148             r*=1; // turn it into a number;
 149             r++;
 150             if (String(r).length != n) {
 151                 ps[0]*=1;
 152                 ps[0]++;
 153                 r = String(r).substring(1); // chop the end off.
 154             }
 155
 156             return ps[0] + '.' + r;
 157
 158         },
 159         /**
 160          * Parse a value into a formatted date using the specified format pattern.
 161          * @param {Mixed} value The value to format
 162          * @param {String} format (optional) Any valid date format string (defaults to 'm/d/Y')
 163          * @return {String} The formatted date string
 164          */
 165         date : function(v, format){
 166             if(!v){
 167                 return "";
 168             }
 169             if(!(v instanceof Date)){
 170                 v = new Date(Date.parse(v));
 171             }
 172             return v.dateFormat(format || "m/d/Y");
 173         },
 174
 175         /**
 176          * Returns a date rendering function that can be reused to apply a date format multiple times efficiently
 177          * @param {String} format Any valid date format string
 178          * @return {Function} The date formatting function
 179          */
 180         dateRenderer : function(format){
 181             return function(v){
 182                 return Roo.util.Format.date(v, format);
 183             };
 184         },
 185
 186         // private
 187         stripTagsRE : /<\/?[^>]+>/gi,
 188
 189         /**
 190          * Strips all HTML tags
 191          * @param {Mixed} value The text from which to strip tags
 192          * @return {String} The stripped text
 193          */
 194         stripTags : function(v){
 195             return !v ? v : String(v).replace(this.stripTagsRE, "");
 196         }
 197     };
 198 }();