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          * Format a number as US currency
 122          * @param {Number/String} value The numeric value to format
 123          * @return {String} The formatted currency string
 124          */
 125         usMoney : function(v){
 126             v = (Math.round((v-0)*100))/100;
 127             v = (v == Math.floor(v)) ? v + ".00" : ((v*10 == Math.floor(v*10)) ? v + "0" : v);
 128             v = String(v);
 129             var ps = v.split('.');
 130             var whole = ps[0];
 131             var sub = ps[1] ? '.'+ ps[1] : '.00';
 132             var r = /(\d+)(\d{3})/;
 133             while (r.test(whole)) {
 134                 whole = whole.replace(r, '$1' + ',' + '$2');
 135             }
 136             return "$" + whole + sub ;
 137         },
 138
 139         /**
 140          * Parse a value into a formatted date using the specified format pattern.
 141          * @param {Mixed} value The value to format
 142          * @param {String} format (optional) Any valid date format string (defaults to 'm/d/Y')
 143          * @return {String} The formatted date string
 144          */
 145         date : function(v, format){
 146             if(!v){
 147                 return "";
 148             }
 149             if(!(v instanceof Date)){
 150                 v = new Date(Date.parse(v));
 151             }
 152             return v.dateFormat(format || "m/d/Y");
 153         },
 154
 155         /**
 156          * Returns a date rendering function that can be reused to apply a date format multiple times efficiently
 157          * @param {String} format Any valid date format string
 158          * @return {Function} The date formatting function
 159          */
 160         dateRenderer : function(format){
 161             return function(v){
 162                 return Roo.util.Format.date(v, format);
 163             };
 164         },
 165
 166         // private
 167         stripTagsRE : /<\/?[^>]+>/gi,
 168
 169         /**
 170          * Strips all HTML tags
 171          * @param {Mixed} value The text from which to strip tags
 172          * @return {String} The stripped text
 173          */
 174         stripTags : function(v){
 175             return !v ? v : String(v).replace(this.stripTagsRE, "");
 176         }
 177     };
 178 }();