* @return {string}
*/
function replicate( str, num ) {
+ var buf = [];
+
if ( num <= 0 || !str ) {
return '';
}
- var buf = [];
while ( num-- ) {
buf.push( str );
}
* @return {string}
*/
function pad( text, size, ch, end ) {
+ var out, padStr;
+
if ( !ch ) {
ch = '0';
}
- var out = String( text ),
- padStr = replicate( ch, Math.ceil( ( size - out.length ) / ch.length ) );
+ out = String( text );
+ padStr = replicate( ch, Math.ceil( ( size - out.length ) / ch.length ) );
return end ? out + padStr : padStr + out;
}
* @private
* @param {number} value the number to be formatted, ignores sign
* @param {string} pattern the number portion of a pattern (e.g. `#,##0.00`)
- * @param {Object} [options] If provided, both option keys must be present:
+ * @param {Object} [options] If provided, all option keys must be present:
* @param {string} options.decimal The decimal separator. Defaults to: `'.'`.
* @param {string} options.group The group separator. Defaults to: `','`.
+ * @param {number|null} options.minimumGroupingDigits
* @return {string}
*/
function commafyNumber( value, pattern, options ) {
- options = options || {
- group: ',',
- decimal: '.'
- };
-
- if ( isNaN( value ) ) {
- return value;
- }
-
var padLength,
patternDigits,
index,
groupSize2 = 0,
pieces = [];
+ options = options || {
+ group: ',',
+ decimal: '.'
+ };
+
+ if ( isNaN( value ) ) {
+ return value;
+ }
+
if ( patternParts[ 1 ] ) {
// Pad fractional with trailing zeros
padLength = ( patternParts[ 1 ] && patternParts[ 1 ].lastIndexOf( '0' ) + 1 );
}
}
- for ( whole = valueParts[ 0 ]; whole; ) {
- off = groupSize ? whole.length - groupSize : 0;
- pieces.push( ( off > 0 ) ? whole.slice( off ) : whole );
- whole = ( off > 0 ) ? whole.slice( 0, off ) : '';
-
- if ( groupSize2 ) {
- groupSize = groupSize2;
- groupSize2 = null;
+ if (
+ options.minimumGroupingDigits === null ||
+ valueParts[ 0 ].length >= groupSize + options.minimumGroupingDigits
+ ) {
+ for ( whole = valueParts[ 0 ]; whole; ) {
+ off = groupSize ? whole.length - groupSize : 0;
+ pieces.push( ( off > 0 ) ? whole.slice( off ) : whole );
+ whole = ( off > 0 ) ? whole.slice( 0, off ) : '';
+
+ if ( groupSize2 ) {
+ groupSize = groupSize2;
+ groupSize2 = null;
+ }
}
+ valueParts[ 0 ] = pieces.reverse().join( options.group );
}
- valueParts[ 0 ] = pieces.reverse().join( options.group );
return valueParts.join( options.decimal );
}
+ /**
+ * Helper function to flip transformation tables.
+ *
+ * @param {...Object} Transformation tables
+ * @return {Object}
+ */
+ function flipTransform() {
+ var i, key, table, flipped = {};
+
+ // Ensure we strip thousand separators. This might be overwritten.
+ flipped[ ',' ] = '';
+
+ for ( i = 0; i < arguments.length; i++ ) {
+ table = arguments[ i ];
+ for ( key in table ) {
+ if ( table.hasOwnProperty( key ) ) {
+ // The thousand separator should be deleted
+ flipped[ table[ key ] ] = key === ',' ? '' : key;
+ }
+ }
+ }
+
+ return flipped;
+ }
+
$.extend( mw.language, {
/**
* @return {number|string} Formatted number
*/
convertNumber: function ( num, integer ) {
- var i, tmp, transformTable, numberString, convertedNumber, pattern;
+ var transformTable, digitTransformTable, separatorTransformTable,
+ i, numberString, convertedNumber, pattern, minimumGroupingDigits;
- pattern = mw.language.getData( mw.config.get( 'wgUserLanguage' ),
- 'digitGroupingPattern' ) || '#,##0.###';
-
- // Set the target transform table:
- transformTable = mw.language.getDigitTransformTable();
-
- if ( !transformTable ) {
+ // Quick shortcut for plain numbers
+ if ( integer && parseInt( num, 10 ) === num ) {
return num;
}
- // Check if the 'restore' to Latin number flag is set:
+ // Load the transformation tables (can be empty)
+ digitTransformTable = mw.language.getDigitTransformTable();
+ separatorTransformTable = mw.language.getSeparatorTransformTable();
+
if ( integer ) {
- if ( parseInt( num, 10 ) === num ) {
- return num;
- }
- tmp = [];
- for ( i in transformTable ) {
- tmp[ transformTable[ i ] ] = i;
- }
- transformTable = tmp;
+ // Reverse the digit transformation tables if we are doing unformatting
+ transformTable = flipTransform( separatorTransformTable, digitTransformTable );
numberString = String( num );
} else {
- // Ignore transform table if wgTranslateNumerals is false
- if ( !mw.config.get( 'wgTranslateNumerals' ) ) {
- transformTable = [];
+ // This check being here means that digits can still be unformatted
+ // even if we do not produce them. This seems sane behavior.
+ if ( mw.config.get( 'wgTranslateNumerals' ) ) {
+ transformTable = digitTransformTable;
}
- numberString = mw.language.commafy( num, pattern );
+
+ // Commaying is more complex, so we handle it here separately.
+ // When unformatting, we just use separatorTransformTable.
+ pattern = mw.language.getData( mw.config.get( 'wgUserLanguage' ),
+ 'digitGroupingPattern' ) || '#,##0.###';
+ minimumGroupingDigits = mw.language.getData( mw.config.get( 'wgUserLanguage' ),
+ 'minimumGroupingDigits' ) || null;
+ numberString = mw.language.commafy( num, pattern, minimumGroupingDigits );
}
- convertedNumber = '';
- for ( i = 0; i < numberString.length; i++ ) {
- if ( transformTable[ numberString[ i ] ] ) {
- convertedNumber += transformTable[ numberString[ i ] ];
- } else {
- convertedNumber += numberString[ i ];
+ if ( transformTable ) {
+ convertedNumber = '';
+ for ( i = 0; i < numberString.length; i++ ) {
+ if ( transformTable.hasOwnProperty( numberString[ i ] ) ) {
+ convertedNumber += transformTable[ numberString[ i ] ];
+ } else {
+ convertedNumber += numberString[ i ];
+ }
}
+ } else {
+ convertedNumber = numberString;
}
- return integer ? parseInt( convertedNumber, 10 ) : convertedNumber;
+
+ if ( integer ) {
+ // Parse string to integer. This loses decimals!
+ convertedNumber = parseInt( convertedNumber, 10 );
+ }
+
+ return convertedNumber;
},
/**
*
* @param {number} value
* @param {string} pattern Pattern string as described by Unicode TR35
+ * @param {number|null} [minimumGroupingDigits=null]
* @throws {Error} If unable to find a number expression in `pattern`.
* @return {string}
*/
- commafy: function ( value, pattern ) {
+ commafy: function ( value, pattern, minimumGroupingDigits ) {
var numberPattern,
transformTable = mw.language.getSeparatorTransformTable(),
group = transformTable[ ',' ] || ',',
pattern = patternList[ ( value < 0 ) ? 1 : 0 ] || ( '-' + positivePattern );
numberPattern = positivePattern.match( numberPatternRE );
+ minimumGroupingDigits = minimumGroupingDigits !== undefined ? minimumGroupingDigits : null;
if ( !numberPattern ) {
throw new Error( 'unable to find a number expression in pattern: ' + pattern );
}
return pattern.replace( numberPatternRE, commafyNumber( value, numberPattern[ 0 ], {
+ minimumGroupingDigits: minimumGroupingDigits,
decimal: decimal,
group: group
} ) );
dépôts / lhc / web / wiklou.git / blobdiff