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+1);
 134             v = (Math.round((v-0)*fact))/fact;
 135             var z = (''+fact).substring(2);
 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         /**
 161          * Format a number as US currency
 162          * @param {Number/String} value The numeric value to format
 163          * @return {String} The formatted currency string
 164          */
 165         usMoney : function(v){
 166             return '$' + this.number(v);
 167         },
 168
 169         /**
 170          * Format a number
 171          * eventually this should probably emulate php's number_format
 172          * @param {Number/String} value The numeric value to format
 173          * @param {Number} decimals number of decimal places
 174          * @return {String} The formatted currency string
 175          */
 176         number : function(v,decimals)
 177         {
 178             // multiply and round.
 179             decimals = typeof(decimals) == 'undefined' ? 2 : decimals;
 180             var mul = Math.pow(10, decimals);
 181             var zero = String(mul).substring(1);
 182             v = (Math.round((v-0)*mul))/mul;
 183
 184             // if it's '0' number.. then
 185
 186             //v = (v == Math.floor(v)) ? v + "." + zero : ((v*10 == Math.floor(v*10)) ? v + "0" : v);
 187             v = String(v);
 188             var ps = v.split('.');
 189             var whole = ps[0];
 190
 191
 192             var r = /(\d+)(\d{3})/;
 193             // add comma's
 194             while (r.test(whole)) {
 195                 whole = whole.replace(r, '$1' + ',' + '$2');
 196             }
 197
 198
 199             var sub = ps[1] ?
 200                     (decimals ?  ('.'+ zero.substring(ps[1].length) + ps[1]) : '') :
 201                     (decimals ? ('.' + zero) : '');
 202
 203
 204             return whole + sub ;
 205         },
 206
 207         /**
 208          * Parse a value into a formatted date using the specified format pattern.
 209          * @param {Mixed} value The value to format
 210          * @param {String} format (optional) Any valid date format string (defaults to 'm/d/Y')
 211          * @return {String} The formatted date string
 212          */
 213         date : function(v, format){
 214             if(!v){
 215                 return "";
 216             }
 217             if(!(v instanceof Date)){
 218                 v = new Date(Date.parse(v));
 219             }
 220             return v.dateFormat(format || "m/d/Y");
 221         },
 222
 223         /**
 224          * Returns a date rendering function that can be reused to apply a date format multiple times efficiently
 225          * @param {String} format Any valid date format string
 226          * @return {Function} The date formatting function
 227          */
 228         dateRenderer : function(format){
 229             return function(v){
 230                 return Roo.util.Format.date(v, format);
 231             };
 232         },
 233
 234         // private
 235         stripTagsRE : /<\/?[^>]+>/gi,
 236
 237         /**
 238          * Strips all HTML tags
 239          * @param {Mixed} value The text from which to strip tags
 240          * @return {String} The stripped text
 241          */
 242         stripTags : function(v){
 243             return !v ? v : String(v).replace(this.stripTagsRE, "");
 244         }
 245     };
 246 }();