resources/src/mediawiki.language/mediawiki.language.js

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