resources/mediawiki.language/mediawiki.language.js

   1 /**
   2  * Localized Language support attempts to mirror some of the functionality of
   3  * Language.php in MediaWiki.
   4  * This adds methods for transforming message text.
   5  */
   6 ( function ( mw, $ ) {
   7
   8 var language = {
   9
  10         /**
  11          * Process the PLURAL template substitution
  12          *
  13          * @param {object} template Template object
  14          * @format template
  15          *  {
  16          *      'title': [title of template],
  17          *      'parameters': [template parameters]
  18          *  }
  19          * @example {{Template:title|params}}
  20          */
  21         procPLURAL: function ( template ) {
  22                 if ( template.title && template.parameters && mw.language.convertPlural ) {
  23                         // Check if we have forms to replace
  24                         if ( template.parameters.length === 0 ) {
  25                                 return '';
  26                         }
  27                         // Restore the count into a Number ( if it got converted earlier )
  28                         var count = mw.language.convertNumber( template.title, true );
  29                         // Do convertPlural call
  30                         return mw.language.convertPlural( parseInt( count, 10 ), template.parameters );
  31                 }
  32                 // Could not process plural return first form or nothing
  33                 if ( template.parameters[0] ) {
  34                         return template.parameters[0];
  35                 }
  36                 return '';
  37         },
  38
  39         /**
  40          * Plural form transformations, needed for some languages.
  41          *
  42          * @param count integer Non-localized quantifier
  43          * @param forms array List of plural forms
  44          * @return string Correct form for quantifier in this language
  45          */
  46         convertPlural: function ( count, forms ) {
  47                 var pluralRules,
  48                         pluralFormIndex = 0;
  49
  50                 if ( !forms || forms.length === 0 ) {
  51                         return '';
  52                 }
  53                 pluralRules = mw.language.getData( mw.config.get( 'wgUserLanguage' ), 'pluralRules' );
  54                 if ( !pluralRules ) {
  55                         // default fallback.
  56                         return ( count === 1 ) ? forms[0] : forms[1];
  57                 }
  58                 pluralFormIndex = mw.cldr.getPluralForm( count, pluralRules );
  59                 pluralFormIndex = Math.min( pluralFormIndex, forms.length - 1 );
  60                 return forms[pluralFormIndex];
  61         },
  62
  63         /**
  64          * Pads an array to a specific length by copying the last one element.
  65          *
  66          * @param forms array Number of forms given to convertPlural
  67          * @param count integer Number of forms required
  68          * @return array Padded array of forms
  69          */
  70         preConvertPlural: function ( forms, count ) {
  71                 while ( forms.length < count ) {
  72                         forms.push( forms[ forms.length-1 ] );
  73                 }
  74                 return forms;
  75         },
  76
  77         /**
  78          * Converts a number using digitTransformTable.
  79          *
  80          * @param {Number} number Value to be converted
  81          * @param {boolean} integer Convert the return value to an integer
  82          * @return {Number|String} formatted number
  83          */
  84         convertNumber: function ( num, integer ) {
  85                 var i, tmp, transformTable, numberString, convertedNumber;
  86
  87                 // Set the target Transform table:
  88                 transformTable = mw.language.getData( mw.config.get( 'wgUserLanguage' ), 'digitTransformTable' );
  89
  90                 if ( !transformTable ) {
  91                         return num;
  92                 }
  93
  94                 // Check if the "restore" to Latin number flag is set:
  95                 if ( integer ) {
  96                         if ( parseInt( num, 10 ) === num ) {
  97                                 return num;
  98                         }
  99                         tmp = [];
 100                         for ( i in transformTable ) {
 101                                 tmp[ transformTable[ i ] ] = i;
 102                         }
 103                         transformTable = tmp;
 104                 }
 105                 numberString = '' + num;
 106                 convertedNumber = '';
 107                 for ( i = 0; i < numberString.length; i++ ) {
 108                         if ( transformTable[ numberString[i] ] ) {
 109                                 convertedNumber += transformTable[numberString[i]];
 110                         } else {
 111                                 convertedNumber += numberString[i];
 112                         }
 113                 }
 114                 return integer ? parseInt( convertedNumber, 10 ) : convertedNumber;
 115         },
 116
 117         /**
 118          * Provides an alternative text depending on specified gender.
 119          * Usage {{gender:[gender|user object]|masculine|feminine|neutral}}.
 120          * If second or third parameter are not specified, masculine is used.
 121          *
 122          * These details may be overriden per language.
 123          *
 124          * @param gender string male, female, or anything else for neutral.
 125          * @param forms array List of gender forms
 126          *
 127          * @return string
 128          */
 129         gender: function ( gender, forms ) {
 130                 if ( !forms || forms.length === 0 ) {
 131                         return '';
 132                 }
 133                 forms = mw.language.preConvertPlural( forms, 2 );
 134                 if ( gender === 'male' ) {
 135                         return forms[0];
 136                 }
 137                 if ( gender === 'female' ) {
 138                         return forms[1];
 139                 }
 140                 return ( forms.length === 3 ) ? forms[2] : forms[0];
 141         },
 142
 143         /**
 144          * Grammatical transformations, needed for inflected languages.
 145          * Invoked by putting {{grammar:form|word}} in a message.
 146          * The rules can be defined in $wgGrammarForms global or grammar
 147          * forms can be computed dynamically by overriding this method per language
 148          *
 149          * @param word {String}
 150          * @param form {String}
 151          * @return {String}
 152          */
 153         convertGrammar: function ( word, form ) {
 154                 var grammarForms = mw.language.getData( mw.config.get( 'wgUserLanguage' ), 'grammarForms' );
 155                 if ( grammarForms && grammarForms[form] ) {
 156                         return grammarForms[form][word] || word;
 157                 }
 158                 return word;
 159         },
 160
 161         // Digit Transform Table, populated by language classes where applicable
 162         digitTransformTable: mw.language.getData( mw.config.get( 'wgUserLanguage' ), 'digitTransformTable' )
 163 };
 164
 165 $.extend( mw.language, language );
 166
 167 }( mediaWiki, jQuery ) );