resources/mediawiki.language/mediawiki.language.js

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