[Summary view] [Print] [Text view]

   1  /*
   2   * Number-related utilities for mediawiki.language.
   3   */
   4  ( function ( mw, $ ) {
   5      /**
   6       * @class mw.language
   7       */
   8  
   9      /**
  10       * Pad a string to guarantee that it is at least `size` length by
  11       * filling with the character `ch` at either the start or end of the
  12       * string. Pads at the start, by default.
  13       *
  14       * Example: Fill the string to length 10 with '+' characters on the right.
  15       *
  16       *     pad( 'blah', 10, '+', true ); // => 'blah++++++'
  17       *
  18       * @private
  19       * @param {string} text The string to pad
  20       * @param {number} size The length to pad to
  21       * @param {string} [ch='0'] Character to pad with
  22       * @param {boolean} [end=false] Adds padding at the end if true, otherwise pads at start
  23       * @return {string}
  24       */
  25  	function pad( text, size, ch, end ) {
  26          if ( !ch ) {
  27              ch = '0';
  28          }
  29  
  30          var out = String( text ),
  31              padStr = replicate( ch, Math.ceil( ( size - out.length ) / ch.length ) );
  32  
  33          return end ? out + padStr : padStr + out;
  34      }
  35  
  36      /**
  37       * Replicate a string 'n' times.
  38       *
  39       * @private
  40       * @param {string} str The string to replicate
  41       * @param {number} num Number of times to replicate the string
  42       * @return {string}
  43       */
  44  	function replicate( str, num ) {
  45          if ( num <= 0 || !str ) {
  46              return '';
  47          }
  48  
  49          var buf = [];
  50          while ( num-- ) {
  51              buf.push( str );
  52          }
  53          return buf.join( '' );
  54      }
  55  
  56      /**
  57       * Apply numeric pattern to absolute value using options. Gives no
  58       * consideration to local customs.
  59       *
  60       * Adapted from dojo/number library with thanks
  61       * <http://dojotoolkit.org/reference-guide/1.8/dojo/number.html>
  62       *
  63       * @private
  64       * @param {number} value the number to be formatted, ignores sign
  65       * @param {string} pattern the number portion of a pattern (e.g. `#,##0.00`)
  66       * @param {Object} [options] If provided, both option keys must be present:
  67       * @param {string} options.decimal The decimal separator. Defaults to: `'.'`.
  68       * @param {string} options.group The group separator. Defaults to: `','`.
  69       * @return {string}
  70       */
  71  	function commafyNumber( value, pattern, options ) {
  72          options = options || {
  73              group: ',',
  74              decimal: '.'
  75          };
  76  
  77          if ( isNaN( value) ) {
  78              return value;
  79          }
  80  
  81          var padLength,
  82              patternDigits,
  83              index,
  84              whole,
  85              off,
  86              remainder,
  87              patternParts = pattern.split( '.' ),
  88              maxPlaces = ( patternParts[1] || [] ).length,
  89              valueParts = String( Math.abs( value ) ).split( '.' ),
  90              fractional = valueParts[1] || '',
  91              groupSize = 0,
  92              groupSize2 = 0,
  93              pieces = [];
  94  
  95          if ( patternParts[1] ) {
  96              // Pad fractional with trailing zeros
  97              padLength = ( patternParts[1] && patternParts[1].lastIndexOf( '0' ) + 1 );
  98  
  99              if ( padLength > fractional.length ) {
 100                  valueParts[1] = pad( fractional, padLength, '0', true );
 101              }
 102  
 103              // Truncate fractional
 104              if ( maxPlaces < fractional.length ) {
 105                  valueParts[1] = fractional.slice( 0, maxPlaces );
 106              }
 107          } else {
 108              if ( valueParts[1] ) {
 109                  valueParts.pop();
 110              }
 111          }
 112  
 113          // Pad whole with leading zeros
 114          patternDigits = patternParts[0].replace( ',', '' );
 115  
 116          padLength = patternDigits.indexOf( '0' );
 117  
 118          if ( padLength !== -1 ) {
 119              padLength = patternDigits.length - padLength;
 120  
 121              if ( padLength > valueParts[0].length ) {
 122                  valueParts[0] = pad( valueParts[0], padLength );
 123              }
 124  
 125              // Truncate whole
 126              if ( patternDigits.indexOf( '#' ) === -1 ) {
 127                  valueParts[0] = valueParts[0].slice( valueParts[0].length - padLength );
 128              }
 129          }
 130  
 131          // Add group separators
 132          index = patternParts[0].lastIndexOf( ',' );
 133  
 134          if ( index !== -1 ) {
 135              groupSize = patternParts[0].length - index - 1;
 136              remainder = patternParts[0].slice( 0, index );
 137              index = remainder.lastIndexOf( ',' );
 138              if ( index !== -1 ) {
 139                  groupSize2 = remainder.length - index - 1;
 140              }
 141          }
 142  
 143          for ( whole = valueParts[0]; whole; ) {
 144              off = groupSize ? whole.length - groupSize : 0;
 145              pieces.push( ( off > 0 ) ? whole.slice( off ) : whole );
 146              whole = ( off > 0 ) ? whole.slice( 0, off ) : '';
 147  
 148              if ( groupSize2 ) {
 149                  groupSize = groupSize2;
 150                  groupSize2 = null;
 151              }
 152          }
 153          valueParts[0] = pieces.reverse().join( options.group );
 154  
 155          return valueParts.join( options.decimal );
 156      }
 157  
 158      $.extend( mw.language, {
 159  
 160          /**
 161           * Converts a number using #getDigitTransformTable.
 162           *
 163           * @param {number} num Value to be converted
 164           * @param {boolean} [integer=false] Whether to convert the return value to an integer
 165           * @return {number|string} Formatted number
 166           */
 167          convertNumber: function ( num, integer ) {
 168              var i, tmp, transformTable, numberString, convertedNumber, pattern;
 169  
 170              pattern = mw.language.getData( mw.config.get( 'wgUserLanguage' ),
 171                  'digitGroupingPattern' ) || '#,##0.###';
 172  
 173              // Set the target transform table:
 174              transformTable = mw.language.getDigitTransformTable();
 175  
 176              if ( !transformTable ) {
 177                  return num;
 178              }
 179  
 180              // Check if the 'restore' to Latin number flag is set:
 181              if ( integer ) {
 182                  if ( parseInt( num, 10 ) === num ) {
 183                      return num;
 184                  }
 185                  tmp = [];
 186                  for ( i in transformTable ) {
 187                      tmp[ transformTable[ i ] ] = i;
 188                  }
 189                  transformTable = tmp;
 190                  numberString = num + '';
 191              } else {
 192                  numberString = mw.language.commafy( num, pattern );
 193              }
 194  
 195              convertedNumber = '';
 196              for ( i = 0; i < numberString.length; i++ ) {
 197                  if ( transformTable[ numberString[i] ] ) {
 198                      convertedNumber += transformTable[numberString[i]];
 199                  } else {
 200                      convertedNumber += numberString[i];
 201                  }
 202              }
 203              return integer ? parseInt( convertedNumber, 10 ) : convertedNumber;
 204          },
 205  
 206          /**
 207           * Get the  digit transform table for current UI language.
 208           * @return {Object|Array}
 209           */
 210          getDigitTransformTable: function () {
 211              return mw.language.getData( mw.config.get( 'wgUserLanguage' ),
 212                  'digitTransformTable' ) || [];
 213          },
 214  
 215          /**
 216           * Get the  separator transform table for current UI language.
 217           * @return {Object|Array}
 218           */
 219          getSeparatorTransformTable: function () {
 220              return mw.language.getData( mw.config.get( 'wgUserLanguage' ),
 221                  'separatorTransformTable' ) || [];
 222          },
 223  
 224          /**
 225           * Apply pattern to format value as a string.
 226           *
 227           * Using patterns from [Unicode TR35](http://www.unicode.org/reports/tr35/#Number_Format_Patterns).
 228           *
 229           * @param {number} value
 230           * @param {string} pattern Pattern string as described by Unicode TR35
 231           * @throws {Error} If unable to find a number expression in `pattern`.
 232           * @return {string}
 233           */
 234          commafy: function ( value, pattern ) {
 235              var numberPattern,
 236                  transformTable = mw.language.getSeparatorTransformTable(),
 237                  group = transformTable[','] || ',',
 238                  numberPatternRE = /[#0,]*[#0](?:\.0*#*)?/, // not precise, but good enough
 239                  decimal = transformTable['.'] || '.',
 240                  patternList = pattern.split( ';' ),
 241                  positivePattern = patternList[0];
 242  
 243              pattern = patternList[ ( value < 0 ) ? 1 : 0] || ( '-' + positivePattern );
 244              numberPattern = positivePattern.match( numberPatternRE );
 245  
 246              if ( !numberPattern ) {
 247                  throw new Error( 'unable to find a number expression in pattern: ' + pattern );
 248              }
 249  
 250              return pattern.replace( numberPatternRE, commafyNumber( value, numberPattern[0], {
 251                  decimal: decimal,
 252                  group: group
 253              } ) );
 254          }
 255  
 256      } );
 257  
 258  }( mediaWiki, jQuery ) );