bryce/mediawiki-extensions-UniversalLanguageSelector
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a13f9b739d44d93ce81e18e5a5b8cec9e04be2a5
mediawiki-extensions-Univer…/lib/jquery.i18n.js
Santhosh Thottingal a13f9b739d Internationalize ULS 
* Integrate jquery.i18n
* Update jquery.uls from upstream and use the build version

Change-Id: I523444b1f6b177f14a4799a455a16a14649b0e1b
2012-09-23 13:12:45 -07:00

2468 lines
60 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* jQuery Internationalization library
*
* Copyright (C) 2012 Santhosh Thottingal
*
* jquery.i18n is dual licensed GPLv2 or later and MIT. You don't have to do
* anything special to choose one license or the other and you don't have to
* notify anyone which license you are using. You are free to use
* UniversalLanguageSelector in commercial projects as long as the copyright
* header is left intact. See files GPL-LICENSE and MIT-LICENSE for details.
*
* @licence GNU General Public Licence 2.0 or later
* @licence MIT License
*/
( function ( $, window, undefined ) {
"use strict";
var I18N = function ( options ) {
// Load defaults
this.options = $.extend( {}, $.i18n.defaults, options );
this.parser = this.options.parser;
this.messageStore = this.options.messageStore;
this.languages = {};
this.locale = this.options.locale;
this.init();
};
I18N.prototype = {
/**
* Initialize by loading locales and setting up toLocaleString
*/
init: function () {
var that = this;
this.messageStore.init( this.locale );
// Override String.localeString method
String.prototype.toLocaleString = function () {
var value = this.valueOf();
var locale = that.locale;
var fallbackIndex = 0;
while ( locale ) {
// Iterate through locales starting at most-specific until
// localization is found. As in fi-Latn-FI, fi-Latn and fi.
var localeParts = locale.toLowerCase().split( "-" );
var localePartIndex = localeParts.length;
do {
var _locale = localeParts.slice( 0, localePartIndex ).join( "-" );
if ( !that.messageStore.messages[_locale] && that.options.messageLocationResolver ) {
// FIXME If messageloading gives 404, it keep on trying to
// load the file again and again
that.messageStore.load(
that.options.messageLocationResolver( _locale ), _locale );
}
var message = that.messageStore.get( _locale, value );
if ( message ) {
return message;
}
localePartIndex--;
} while (localePartIndex);
if ( locale === "en" ) {
break;
}
locale = ( $.i18n.fallbacks[that.locale] && $.i18n.fallbacks[that.locale][fallbackIndex] )
|| that.options.fallbackLocale;
that.log( "Trying fallback locale for " + that.locale + ": " + locale );
fallbackIndex++;
}
return value; // fallback the original string value
};
String.locale = this.locale;
},
destroy: function () {
$( 'body' ).data( 'i18n', null );
},
/**
* General message loading API This can take a URL string for the json formatted messages.
* Eg: load('path/to/all_localizations.json');
*
* This can also load a localization file for a locale Eg: load('path/to/de-messages.json',
* 'de' );
*
* A data object containing message key- message translation mappings can also be passed Eg:
* load( { 'hello' : 'Hello' }, optionalLocale ); If the data argument is
* null/undefined/false, all cached messages for the i18n instance will get reset.
*
* @param {String|Object|null} data
* @param {String} locale Language tag
*/
load: function ( data, locale ) {
this.messageStore.load( data, locale );
},
log: function (/* arguments */) {
var hasConsole = window.console !== undefined;
if ( hasConsole && $.i18n.debug ) {
window.console.log.apply( window.console, arguments );
}
},
/**
* Does parameter and magic word substitution.
*
* @param {String}
* key Message key
* @param {Array}
* parameters Message parameters
* @return
* @string
*/
parse: function ( key, parameters ) {
var message = key.toLocaleString();
this.parser.language = $.i18n.languages[$.i18n().locale] || $.i18n.languages['default'];
return this.parser.parse( message, parameters );
}
};
String.locale = String.locale || $( 'html' ).attr( 'lang' );
if ( !String.locale ) {
if ( typeof window.navigator !== undefined ) {
var nav = window.navigator;
String.locale = nav.language || nav.userLanguage || "";
} else {
String.locale = "";
}
}
$.i18n = function ( key, parameter_1 /* [, parameter_2] */) {
var parameters = [], i18n = $( 'body' ).data( 'i18n' );
var options = typeof key === 'object' && key;
if ( options && options.locale && i18n && i18n.locale !== options.locale ) {
String.locale = i18n.locale = options.locale;
}
if ( !i18n ) {
$( 'body' ).data( 'i18n', ( i18n = new I18N( options ) ) );
$( '[data-i18n]' ).each( function ( e ) {
var $this = $( this );
if ( $this.data( 'i18n' ) ) {
var messageKey = $this.data( 'i18n' );
var message = $.i18n( messageKey );
if ( message !== messageKey ) {
$this.text( message );
}
}
} );
}
if ( !key ) {
return i18n;
}
// Support variadic arguments
if ( parameter_1 !== undefined ) {
parameters = $.makeArray( arguments );
parameters.shift();
}
if ( typeof key === 'string' ) {
return i18n.parse( key, parameters );
} else {
return i18n;
}
};
$.fn.i18n = function ( option ) {
return this.each( function () {
var $this = $( this );
if ( $this.data( 'i18n' ) ) {
var messageKey = $this.data( 'i18n' );
var message = $.i18n( messageKey );
if ( message !== messageKey ) {
$this.text( message );
}
} else {
$this.find( '[data-i18n]' ).i18n();
}
} );
};
// The default parser only handles variable substitution
var defaultParser = {
parse: function ( message, parameters ) {
return message.replace( /\$(\d+)/g, function ( str, match ) {
var index = parseInt( match, 10 ) - 1;
return parameters[index] !== undefined ? parameters[index] : '$' + match;
} );
}
};
$.i18n.languages = {};
$.i18n.messageStore = $.i18n.messageStore || {};
$.i18n.parser = defaultParser;
$.i18n.parser.emitter = {};
$.i18n.debug = false;
$.i18n.defaults = {
locale: String.locale,
fallbackLocale: "en",
parser: $.i18n.parser,
messageStore: $.i18n.messageStore,
/* messageLocationResolver - should be a function taking language code as argument and
* returning absolute/ relative path to the localization file
*/
messageLocationResolver: null
};
$.i18n.Constructor = I18N;
/**
* Convenient alias
*/
window._ = window._ || $.i18n;
}( jQuery, window ) );
/**
* jQuery Internationalization library Message loading , parsing, retrieving utilities
*
* Copyright (C) 2012 Santhosh Thottingal
*
* jquery.i18n is dual licensed GPLv2 or later and MIT. You don't have to do anything special to
* choose one license or the other and you don't have to notify anyone which license you are using.
* You are free to use UniversalLanguageSelector in commercial projects as long as the copyright
* header is left intact. See files GPL-LICENSE and MIT-LICENSE for details.
*
* @licence GNU General Public Licence 2.0 or later
* @licence MIT License
*/
( function ( $, window, undefined ) {
"use strict";
var MessageStore = function () {
this.messages = {};
this.sources = {};
this.locale = String.locale;
};
MessageStore.prototype = {
/**
* See https://github.com/wikimedia/jquery.i18n/wiki/Specification#wiki-Message_File_Loading
*
* @param locale
*/
init: function ( locale ) {
this.locale = locale;
var that = this;
var $links = $( "link" );
var linksCount = $links.length;
this.log( "initializing for " + locale );
// Check for <link rel="localization" hreflang="xyz" elements
while (linksCount--) {
var $link = $( $links[linksCount] );
var rel = ( $link.attr( "rel" ) || "" ).toLowerCase().split( /\s+/ );
if ( $.inArray( "localizations", rel ) !== -1 ) {
// multiple localizations
that.load( $link.attr( "href" ) );
} else if ( $.inArray( "localization", rel ) !== -1 ) {
// single localization
var localization = {};
localization[ ( $link.attr( "hreflang" ) || "" ).toLowerCase()] = $link
.attr( "href" );
that.load( localization );
}
}
},
/**
* General message loading API This can take a URL string for the json formatted messages.
* <code>load('path/to/all_localizations.json');</code>
*
* This can also load a localization file for a locale <code>
* load('path/to/de-messages.json', 'de' );
* </code>
* A data object containing message key- message translation mappings can also be passed Eg:
* <code>
* load( { 'hello' : 'Hello' }, optionalLocale );
* </code> If the data argument is
* null/undefined/false, all cached messages for the i18n instance will get reset.
*
* @param {String|Object|null} data
* @param {String} locale Language tag
*/
load: function ( data, locale ) {
var that = this;
var hasOwn = Object.prototype.hasOwnProperty;
if ( !data ) {
// reset all localizations
this.log( "Resetting for locale" + locale );
that.messages = {};
return;
}
var dataType = typeof data;
if ( locale && this.locale !== locale ) {
// queue loading locale if not needed
if ( ! ( locale in this.sources ) ) {
this.sources[locale] = [];
}
this.log( "Queueing: " + locale + " Current locale " + this.locale );
this.sources[locale].push( data );
return;
}
if ( arguments.length > 0 && dataType !== "number" ) {
if ( dataType === "string" ) {
// This is a URL to the messages file.
this.log( "Loading messages from: " + data );
this.jsonMessageLoader( data ).done( function ( localization, textStatus ) {
that.load( localization, locale );
delete that.sources[locale];
} );
} else {
// data is Object
// Extend current localizations instead of completely
// overwriting them
var localization = data;
for ( var messageKey in localization ) {
if ( !hasOwn.call( localization, messageKey ) ) {
continue;
}
var messageKeyType = typeof messageKey;
if ( messageKeyType === "string" && locale ) {
that.log( "[" + locale + "][" + messageKey + "] : "
+ localization[messageKey] );
that.messages[locale] = that.messages[locale] || [];
that.messages[locale][messageKey] = localization[messageKey];
} else {
var passedLocale = messageKey;
this.log( "Loading locale: " + passedLocale );
that.load( localization[passedLocale], passedLocale );
}
}
}
}
},
log: function (/* arguments */) {
var hasConsole = window.console !== undefined;
if ( hasConsole && $.i18n.debug ) {
window.console.log.apply( window.console, arguments );
}
},
/**
* Load the messages from the source queue for the locale
*
* @param {String} locale
*/
loadFromQueue: function ( locale ) {
var that = this;
var queue = that.sources[locale];
for ( var i = 0; i < queue.length; i++ ) {
that.load( queue[i], locale );
}
delete that.sources[locale];
},
jsonMessageLoader: function ( url ) {
var that = this;
return $.ajax( {
url: url,
dataType: "json",
async: false
// that is unfortunate
} ).fail( function ( jqxhr, settings, exception ) {
that.log( "Error in loading messages from " + url + " Exception: " + exception );
} );
},
/**
*
* @param locale
* @param messageKey
* @returns {Boolean}
*/
get: function ( locale, messageKey ) {
// load locale if not loaded
if ( this.sources[locale] ) {
// We need to switch to this locale
this.locale = locale;
this.loadFromQueue( locale );
}
return this.messages[locale] && this.messages[locale][messageKey];
}
};
$.extend( $.i18n.messageStore, new MessageStore() );
}( jQuery, window ) );
/**
* jQuery Internationalization library
*
* Copyright (C) 2012 Santhosh Thottingal
*
* jquery.i18n is dual licensed GPLv2 or later and MIT. You don't have to do anything special to
* choose one license or the other and you don't have to notify anyone which license you are using.
* You are free to use UniversalLanguageSelector in commercial projects as long as the copyright
* header is left intact. See files GPL-LICENSE and MIT-LICENSE for details.
*
* @licence GNU General Public Licence 2.0 or later
* @licence MIT License
*/
( function ( $, undefined ) {
$.i18n = $.i18n || {};
$.i18n.fallbacks = {
"ab": ["ru"],
"ace": ["id"],
"aln": ["sq"],
"als": ["gsw", "de"],
"an": ["es"],
"anp": ["hi"],
"arn": ["es"],
"arz": ["ar"],
"av": ["ru"],
"ay": ["es"],
"ba": ["ru"],
"bar": ["de"],
"bat-smg": ["sgs", "lt"],
"bcc": ["fa"],
"be-x-old": ["be-tarask"],
"bh": ["bho"],
"bjn": ["id"],
"bm": ["fr"],
"bpy": ["bn"],
"bqi": ["fa"],
"bug": ["id"],
"cbk-zam": ["es"],
"ce": ["ru"],
"crh": ["crh-latn"],
"crh-cyrl": ["ru"],
"csb": ["pl"],
"cv": ["ru"],
"de-at": ["de"],
"de-ch": ["de"],
"de-formal": ["de"],
"dsb": ["de"],
"dtp": ["ms"],
"egl": ["it"],
"eml": ["it"],
"ff": ["fr"],
"fit": ["fi"],
"fiu-vro": ["vro", "et"],
"frc": ["fr"],
"frp": ["fr"],
"frr": ["de"],
"fur": ["it"],
"gag": ["tr"],
"gan": ["gan-hant", "zh-hant", "zh-hans"],
"gan-hans": ["zh-hans"],
"gan-hant": ["zh-hant", "zh-hans"],
"gl": ["pt"],
"glk": ["fa"],
"gn": ["es"],
"gsw": ["de"],
"hif": ["hif-latn"],
"hsb": ["de"],
"ht": ["fr"],
"ii": ["zh-cn", "zh-hans"],
"inh": ["ru"],
"iu": ["ike-cans"],
"jut": ["da"],
"jv": ["id"],
"kaa": ["kk-latn", "kk-cyrl"],
"kbd": ["kbd-cyrl"],
"khw": ["ur"],
"kiu": ["tr"],
"kk": ["kk-cyrl"],
"kk-arab": ["kk-cyrl"],
"kk-latn": ["kk-cyrl"],
"kk-cn": ["kk-arab", "kk-cyrl"],
"kk-kz": ["kk-cyrl"],
"kk-tr": ["kk-latn", "kk-cyrl"],
"kl": ["da"],
"ko-kp": ["ko"],
"koi": ["ru"],
"krc": ["ru"],
"ks": ["ks-arab"],
"ksh": ["de"],
"ku": ["ku-latn"],
"ku-arab": ["ckb"],
"kv": ["ru"],
"lad": ["es"],
"lb": ["de"],
"lbe": ["ru"],
"lez": ["ru"],
"li": ["nl"],
"lij": ["it"],
"liv": ["et"],
"lmo": ["it"],
"ln": ["fr"],
"ltg": ["lv"],
"lzz": ["tr"],
"mai": ["hi"],
"map-bms": ["jv", "id"],
"mg": ["fr"],
"mhr": ["ru"],
"min": ["id"],
"mo": ["ro"],
"mrj": ["ru"],
"mwl": ["pt"],
"myv": ["ru"],
"mzn": ["fa"],
"nah": ["es"],
"nap": ["it"],
"nds": ["de"],
"nds-nl": ["nl"],
"nl-informal": ["nl"],
"no": ["nb"],
"os": ["ru"],
"pcd": ["fr"],
"pdc": ["de"],
"pdt": ["de"],
"pfl": ["de"],
"pms": ["it"],
"pt": ["pt-br"],
"pt-br": ["pt"],
"qu": ["es"],
"qug": ["qu", "es"],
"rgn": ["it"],
"rmy": ["ro"],
"roa-rup": ["rup"],
"rue": ["uk", "ru"],
"ruq": ["ruq-latn", "ro"],
"ruq-cyrl": ["mk"],
"ruq-latn": ["ro"],
"sa": ["hi"],
"sah": ["ru"],
"scn": ["it"],
"sg": ["fr"],
"sgs": ["lt"],
"sli": ["de"],
"sr": ["sr-ec"],
"srn": ["nl"],
"stq": ["de"],
"su": ["id"],
"szl": ["pl"],
"tcy": ["kn"],
"tg": ["tg-cyrl"],
"tt": ["tt-cyrl", "ru"],
"tt-cyrl": ["ru"],
"ty": ["fr"],
"udm": ["ru"],
"ug": ["ug-arab"],
"uk": ["ru"],
"vec": ["it"],
"vep": ["et"],
"vls": ["nl"],
"vmf": ["de"],
"vot": ["fi"],
"vro": ["et"],
"wa": ["fr"],
"wo": ["fr"],
"wuu": ["zh-hans"],
"xal": ["ru"],
"xmf": ["ka"],
"yi": ["he"],
"za": ["zh-hans"],
"zea": ["nl"],
"zh": ["zh-hans"],
"zh-classical": ["lzh"],
"zh-cn": ["zh-hans"],
"zh-hant": ["zh-hans"],
"zh-hk": ["zh-hant", "zh-hans"],
"zh-min-nan": ["nan"],
"zh-mo": ["zh-hk", "zh-hant", "zh-hans"],
"zh-my": ["zh-sg", "zh-hans"],
"zh-sg": ["zh-hans"],
"zh-tw": ["zh-hant", "zh-hans"],
"zh-yue": ["yue"]
};
}( jQuery ) );
/**
* jQuery Internationalization library
*
* Copyright (C) 2012 Santhosh Thottingal
*
* jquery.i18n is dual licensed GPLv2 or later and MIT. You don't have to do
* anything special to choose one license or the other and you don't have to
* notify anyone which license you are using. You are free to use
* UniversalLanguageSelector in commercial projects as long as the copyright
* header is left intact. See files GPL-LICENSE and MIT-LICENSE for details.
*
* @licence GNU General Public Licence 2.0 or later
* @licence MIT License
*/
( function ( $ ) {
"use strict";
var MessageParser = function ( options ) {
this.options = $.extend( {}, $.i18n.parser.defaults, options );
this.language = $.i18n.languages[$.i18n().locale];
this.emitter = $.i18n.parser.emitter;
};
MessageParser.prototype = {
constructor: MessageParser,
simpleParse: function ( message, parameters ) {
return message.replace( /\$(\d+)/g, function ( str, match ) {
var index = parseInt( match, 10 ) - 1;
return parameters[index] !== undefined ? parameters[index] : '$' + match;
} );
},
parse: function ( message, replacements ) {
if ( message.indexOf( '{{' ) < 0 ) {
return this.simpleParse( message, replacements );
}
this.emitter.language = $.i18n.languages[$.i18n().locale]
|| $.i18n.languages['default'];
return this.emitter.emit( this.ast( message ), replacements );
},
ast: function ( message ) {
var pos = 0;
// Try parsers until one works, if none work return null
function choice ( parserSyntax ) {
return function () {
for ( var i = 0; i < parserSyntax.length; i++) {
var result = parserSyntax[i]();
if ( result !== null ) {
return result;
}
}
return null;
};
}
// Try several parserSyntax-es in a row.
// All must succeed; otherwise, return null.
// This is the only eager one.
function sequence ( parserSyntax ) {
var originalPos = pos;
var result = [];
for ( var i = 0; i < parserSyntax.length; i++) {
var res = parserSyntax[i]();
if ( res === null ) {
pos = originalPos;
return null;
}
result.push( res );
}
return result;
}
// Run the same parser over and over until it fails.
// Must succeed a minimum of n times; otherwise, return null.
function nOrMore ( n, p ) {
return function () {
var originalPos = pos;
var result = [];
var parsed = p();
while (parsed !== null) {
result.push( parsed );
parsed = p();
}
if ( result.length < n ) {
pos = originalPos;
return null;
}
return result;
};
}
// Helpers -- just make parserSyntax out of simpler JS builtin types
function makeStringParser ( s ) {
var len = s.length;
return function () {
var result = null;
if ( message.substr( pos, len ) === s ) {
result = s;
pos += len;
}
return result;
};
}
function makeRegexParser ( regex ) {
return function () {
var matches = message.substr( pos ).match( regex );
if ( matches === null ) {
return null;
}
pos += matches[0].length;
return matches[0];
};
}
var pipe = makeStringParser( '|' );
var colon = makeStringParser( ':' );
var backslash = makeStringParser( "\\" );
var anyCharacter = makeRegexParser( /^./ );
var dollar = makeStringParser( '$' );
var digits = makeRegexParser( /^\d+/ );
var regularLiteral = makeRegexParser( /^[^{}\[\]$\\]/ );
var regularLiteralWithoutBar = makeRegexParser( /^[^{}\[\]$\\|]/ );
var regularLiteralWithoutSpace = makeRegexParser( /^[^{}\[\]$\s]/ );
// There is a general pattern -- parse a thing, if that worked,
// apply transform, otherwise return null.
// But using this as a combinator seems to cause problems when
// combined with nOrMore().
// May be some scoping issue
function transform ( p, fn ) {
return function () {
var result = p();
return result === null ? null : fn( result );
};
}
// Used to define "literals" without spaces, in space-delimited
// situations
function literalWithoutSpace () {
var result = nOrMore( 1, escapedOrLiteralWithoutSpace )();
return result === null ? null : result.join( '' );
}
// Used to define "literals" within template parameters. The pipe
// character is the parameter delimeter, so by default
// it is not a literal in the parameter
function literalWithoutBar () {
var result = nOrMore( 1, escapedOrLiteralWithoutBar )();
return result === null ? null : result.join( '' );
}
function literal () {
var result = nOrMore( 1, escapedOrRegularLiteral )();
return result === null ? null : result.join( '' );
}
function escapedLiteral () {
var result = sequence( [ backslash, anyCharacter ] );
return result === null ? null : result[1];
}
var escapedOrLiteralWithoutSpace = choice( [ escapedLiteral, regularLiteralWithoutSpace ] );
var escapedOrLiteralWithoutBar = choice( [ escapedLiteral, regularLiteralWithoutBar ] );
var escapedOrRegularLiteral = choice( [ escapedLiteral, regularLiteral ] );
function replacement () {
var result = sequence( [ dollar, digits ] );
if ( result === null ) {
return null;
}
return [ 'REPLACE', parseInt( result[1], 10 ) - 1 ];
}
var templateName = transform(
// see $wgLegalTitleChars
// not allowing : due to the need to catch "PLURAL:$1"
makeRegexParser( /^[ !"$&'()*,.\/0-9;=?@A-Z\^_`a-z~\x80-\xFF+\-]+/ ),
function ( result ) {
return result.toString();
} );
function templateParam () {
var result = sequence( [ pipe, nOrMore( 0, paramExpression ) ] );
if ( result === null ) {
return null;
}
var expr = result[1];
// use a "CONCAT" operator if there are multiple nodes,
// otherwise return the first node, raw.
return expr.length > 1 ? [ "CONCAT" ].concat( expr ) : expr[0];
}
function templateWithReplacement () {
var result = sequence( [ templateName, colon, replacement ] );
return result === null ? null : [ result[0], result[2] ];
}
function templateWithOutReplacement () {
var result = sequence( [ templateName, colon, paramExpression ] );
return result === null ? null : [ result[0], result[2] ];
}
var templateContents = choice( [
function () {
var res = sequence( [
// templates can have placeholders for dynamic
// replacement eg: {{PLURAL:$1|one car|$1 cars}}
// or no placeholders eg:
// {{GRAMMAR:genitive|{{SITENAME}}}
choice( [ templateWithReplacement, templateWithOutReplacement ] ),
nOrMore( 0, templateParam ) ] );
return res === null ? null : res[0].concat( res[1] );
}, function () {
var res = sequence( [ templateName, nOrMore( 0, templateParam ) ] );
if ( res === null ) {
return null;
}
return [ res[0] ].concat( res[1] );
} ] );
var openTemplate = makeStringParser( '{{' );
var closeTemplate = makeStringParser( '}}' );
function template () {
var result = sequence( [ openTemplate, templateContents, closeTemplate ] );
return result === null ? null : result[1];
}
var expression = choice( [ template, replacement, literal ] );
var paramExpression = choice( [ template, replacement, literalWithoutBar ] );
function start () {
var result = nOrMore( 0, expression )();
if ( result === null ) {
return null;
}
return [ "CONCAT" ].concat( result );
}
var result = start();
return result;
}
};
$.extend( $.i18n.parser, new MessageParser() );
}( jQuery ) );
/**
* jQuery Internationalization library
*
* Copyright (C) 2012 Santhosh Thottingal
*
* jquery.i18n is dual licensed GPLv2 or later and MIT. You don't have to do
* anything special to choose one license or the other and you don't have to
* notify anyone which license you are using. You are free to use
* UniversalLanguageSelector in commercial projects as long as the copyright
* header is left intact. See files GPL-LICENSE and MIT-LICENSE for details.
*
* @licence GNU General Public Licence 2.0 or later
* @licence MIT License
*/
( function ( $ ) {
"use strict";
var MessageParserEmitter = function () {
this.language = $.i18n.languages[$.i18n().locale] || $.i18n.languages['default'];
};
MessageParserEmitter.prototype = {
constructor: MessageParserEmitter,
/**
* (We put this method definition here, and not in prototype, to make
* sure it's not overwritten by any magic.) Walk entire node structure,
* applying replacements and template functions when appropriate
*
* @param {Mixed}
* abstract syntax tree (top node or subnode)
* @param {Array}
* replacements for $1, $2, ... $n
* @return {Mixed} single-string node or array of nodes suitable for
* jQuery appending
*/
emit: function ( node, replacements ) {
var ret = null;
var that = this;
switch (typeof node) {
case 'string':
case 'number':
ret = node;
break;
case 'object':
// node is an array of nodes
var subnodes = $.map( node.slice( 1 ), function ( n ) {
return that.emit( n, replacements );
} );
var operation = node[0].toLowerCase();
if ( typeof that[operation] === 'function' ) {
ret = that[operation]( subnodes, replacements );
} else {
throw new Error( 'unknown operation "' + operation + '"' );
}
break;
case 'undefined':
// Parsing the empty string (as an entire expression, or as a
// paramExpression in a template) results in undefined
// Perhaps a more clever parser can detect this, and return the
// empty string? Or is that useful information?
// The logical thing is probably to return the empty string here
// when we encounter undefined.
ret = '';
break;
default:
throw new Error( 'unexpected type in AST: ' + typeof node );
}
return ret;
},
/**
* Parsing has been applied depth-first we can assume that all nodes
* here are single nodes Must return a single node to parents -- a
* jQuery with synthetic span However, unwrap any other synthetic spans
* in our children and pass them upwards
*
* @param {Array}
* nodes - mixed, some single nodes, some arrays of nodes
* @return String
*/
concat: function ( nodes ) {
var result = "";
$.each( nodes, function ( i, node ) {
// strings, integers, anything else
result += node;
} );
return result;
},
/**
* Return escaped replacement of correct index, or string if
* unavailable. Note that we expect the parsed parameter to be
* zero-based. i.e. $1 should have become [ 0 ]. if the specified
* parameter is not found return the same string (e.g. "$99" ->
* parameter 98 -> not found -> return "$99" ) TODO throw error if
* nodes.length > 1 ?
*
* @param {Array}
* of one element, integer, n >= 0
* @return {String} replacement
*/
replace: function ( nodes, replacements ) {
var index = parseInt( nodes[0], 10 );
if ( index < replacements.length ) {
// replacement is not a string, don't touch!
return replacements[index];
} else {
// index not found, fallback to displaying variable
return '$' + ( index + 1 );
}
},
/**
* Transform parsed structure into pluralization n.b. The first node may
* be a non-integer (for instance, a string representing an Arabic
* number). So convert it back with the current language's
* convertNumber.
*
* @param {Array}
* of nodes, [ {String|Number}, {String}, {String} ... ]
* @return {String} selected pluralized form according to current
* language
*/
plural: function ( nodes ) {
var count = parseFloat( this.language.convertNumber( nodes[0], 10 ) );
var forms = nodes.slice( 1 );
return forms.length ? this.language.convertPlural( count, forms ) : '';
},
/**
* Transform parsed structure into gender Usage
* {{gender:gender|masculine|feminine|neutral}}.
*
* @param {Array}
* of nodes, [ {String}, {String}, {String} , {String} ]
* @return {String} selected gender form according to current language
*/
gender: function ( nodes ) {
var gender = nodes[0];
var forms = nodes.slice( 1 );
return this.language.gender( gender, forms );
},
/**
* Transform parsed structure into grammar conversion. Invoked by
* putting {{grammar:form|word}} in a message
*
* @param {Array}
* of nodes [{Grammar case eg: genitive}, {String word}]
* @return {String} selected grammatical form according to current
* language
*/
grammar: function ( nodes ) {
var form = nodes[0];
var word = nodes[1];
return word && form && this.language.convertGrammar( word, form );
}
};
$.extend( $.i18n.parser.emitter, new MessageParserEmitter() );
}( jQuery ) );
/* global pluralRuleParser */
( function ( $ ) {
"use strict";
var language = {
// CLDR plural rules generated using
// http://i18ndata.appspot.com/cldr/tags/unconfirmed/supplemental/plurals?action=browse&depth=-1
// and compressed
pluralRules: {
gv: {
one: "n mod 10 in 1..2 or n mod 20 is 0"
},
gu: {
one: "n is 1"
},
rof: {
one: "n is 1"
},
ga: {
few: "n in 3..6",
many: "n in 7..10",
two: "n is 2",
one: "n is 1"
},
gl: {
one: "n is 1"
},
lg: {
one: "n is 1"
},
lb: {
one: "n is 1"
},
xog: {
one: "n is 1"
},
ln: {
one: "n in 0..1"
},
lo: "",
brx: {
one: "n is 1"
},
tr: "",
ts: {
one: "n is 1"
},
tn: {
one: "n is 1"
},
to: "",
lt: {
few: "n mod 10 in 2..9 and n mod 100 not in 11..19",
one: "n mod 10 is 1 and n mod 100 not in 11..19"
},
tk: {
one: "n is 1"
},
th: "",
ksb: {
one: "n is 1"
},
te: {
one: "n is 1"
},
ksh: {
zero: "n is 0",
one: "n is 1"
},
fil: {
one: "n in 0..1"
},
haw: {
one: "n is 1"
},
kcg: {
one: "n is 1"
},
ssy: {
one: "n is 1"
},
yo: "",
de: {
one: "n is 1"
},
ko: "",
da: {
one: "n is 1"
},
dz: "",
dv: {
one: "n is 1"
},
guw: {
one: "n in 0..1"
},
shi: {
few: "n in 2..10",
one: "n within 0..1"
},
el: {
one: "n is 1"
},
eo: {
one: "n is 1"
},
en: {
one: "n is 1"
},
ses: "",
teo: {
one: "n is 1"
},
ee: {
one: "n is 1"
},
kde: "",
fr: {
one: "n within 0..2 and n is not 2"
},
eu: {
one: "n is 1"
},
et: {
one: "n is 1"
},
es: {
one: "n is 1"
},
seh: {
one: "n is 1"
},
ru: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
kl: {
one: "n is 1"
},
sms: {
two: "n is 2",
one: "n is 1"
},
smn: {
two: "n is 2",
one: "n is 1"
},
smj: {
two: "n is 2",
one: "n is 1"
},
smi: {
two: "n is 2",
one: "n is 1"
},
fy: {
one: "n is 1"
},
rm: {
one: "n is 1"
},
ro: {
few: "n is 0 OR n is not 1 AND n mod 100 in 1..19",
one: "n is 1"
},
bn: {
one: "n is 1"
},
sma: {
two: "n is 2",
one: "n is 1"
},
be: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
bg: {
one: "n is 1"
},
ms: "",
wa: {
one: "n in 0..1"
},
ps: {
one: "n is 1"
},
wo: "",
bm: "",
jv: "",
bo: "",
bh: {
one: "n in 0..1"
},
kea: "",
asa: {
one: "n is 1"
},
cgg: {
one: "n is 1"
},
br: {
few: "n mod 10 in 3..4,9 and n mod 100 not in 10..19,70..79,90..99",
many: "n mod 1000000 is 0 and n is not 0",
two: "n mod 10 is 2 and n mod 100 not in 12,72,92",
one: "n mod 10 is 1 and n mod 100 not in 11,71,91"
},
bs: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
ja: "",
om: {
one: "n is 1"
},
fa: "",
vun: {
one: "n is 1"
},
or: {
one: "n is 1"
},
xh: {
one: "n is 1"
},
nso: {
one: "n in 0..1"
},
ca: {
one: "n is 1"
},
cy: {
few: "n is 3",
zero: "n is 0",
many: "n is 6",
two: "n is 2",
one: "n is 1"
},
cs: {
few: "n in 2..4",
one: "n is 1"
},
zh: "",
lv: {
zero: "n is 0",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
pt: {
one: "n is 1"
},
wae: {
one: "n is 1"
},
tl: {
one: "n in 0..1"
},
chr: {
one: "n is 1"
},
pa: {
one: "n is 1"
},
ak: {
one: "n in 0..1"
},
pl: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n is not 1 and n mod 10 in 0..1 or n mod 10 in 5..9 or n mod 100 in 12..14",
one: "n is 1"
},
hr: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
am: {
one: "n in 0..1"
},
ti: {
one: "n in 0..1"
},
hu: "",
hi: {
one: "n in 0..1"
},
jmc: {
one: "n is 1"
},
ha: {
one: "n is 1"
},
he: {
one: "n is 1"
},
mg: {
one: "n in 0..1"
},
fur: {
one: "n is 1"
},
bem: {
one: "n is 1"
},
ml: {
one: "n is 1"
},
mo: {
few: "n is 0 OR n is not 1 AND n mod 100 in 1..19",
one: "n is 1"
},
mn: {
one: "n is 1"
},
mk: {
one: "n mod 10 is 1 and n is not 11"
},
ur: {
one: "n is 1"
},
bez: {
one: "n is 1"
},
mt: {
few: "n is 0 or n mod 100 in 2..10",
many: "n mod 100 in 11..19",
one: "n is 1"
},
uk: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
mr: {
one: "n is 1"
},
ta: {
one: "n is 1"
},
my: "",
sah: "",
ve: {
one: "n is 1"
},
af: {
one: "n is 1"
},
vi: "",
is: {
one: "n is 1"
},
iu: {
two: "n is 2",
one: "n is 1"
},
it: {
one: "n is 1"
},
kn: "",
ii: "",
ar: {
few: "n mod 100 in 3..10",
zero: "n is 0",
many: "n mod 100 in 11..99",
two: "n is 2",
one: "n is 1"
},
zu: {
one: "n is 1"
},
saq: {
one: "n is 1"
},
az: "",
tzm: {
one: "n in 0..1 or n in 11..99"
},
id: "",
ig: "",
pap: {
one: "n is 1"
},
nl: {
one: "n is 1"
},
nn: {
one: "n is 1"
},
no: {
one: "n is 1"
},
nah: {
one: "n is 1"
},
nd: {
one: "n is 1"
},
ne: {
one: "n is 1"
},
ny: {
one: "n is 1"
},
naq: {
two: "n is 2",
one: "n is 1"
},
nyn: {
one: "n is 1"
},
kw: {
two: "n is 2",
one: "n is 1"
},
nr: {
one: "n is 1"
},
tig: {
one: "n is 1"
},
kab: {
one: "n within 0..2 and n is not 2"
},
mas: {
one: "n is 1"
},
rwk: {
one: "n is 1"
},
kaj: {
one: "n is 1"
},
lag: {
zero: "n is 0",
one: "n within 0..2 and n is not 0 and n is not 2"
},
syr: {
one: "n is 1"
},
kk: {
one: "n is 1"
},
ff: {
one: "n within 0..2 and n is not 2"
},
fi: {
one: "n is 1"
},
fo: {
one: "n is 1"
},
ka: "",
gsw: {
one: "n is 1"
},
ckb: {
one: "n is 1"
},
ss: {
one: "n is 1"
},
sr: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
sq: {
one: "n is 1"
},
sw: {
one: "n is 1"
},
sv: {
one: "n is 1"
},
km: "",
st: {
one: "n is 1"
},
sk: {
few: "n in 2..4",
one: "n is 1"
},
sh: {
few: "n mod 10 in 2..4 and n mod 100 not in 12..14",
many: "n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14",
one: "n mod 10 is 1 and n mod 100 is not 11"
},
so: {
one: "n is 1"
},
sn: {
one: "n is 1"
},
ku: {
one: "n is 1"
},
sl: {
few: "n mod 100 in 3..4",
two: "n mod 100 is 2",
one: "n mod 100 is 1"
},
sg: "",
nb: {
one: "n is 1"
},
se: {
two: "n is 2",
one: "n is 1"
}
},
/**
* Plural form transformations, needed for some languages.
*
* @param count
* integer Non-localized quantifier
* @param forms
* array List of plural forms
* @return string Correct form for quantifier in this language
*/
convertPlural: function ( count, forms ) {
var pluralFormIndex = 0;
if ( !forms || forms.length === 0 ) {
return '';
}
var pluralRules = this.pluralRules[$.i18n().locale];
if ( !pluralRules ) {
// default fallback.
return ( count === 1 ) ? forms[0] : forms[1];
}
pluralFormIndex = this.getPluralForm( count, pluralRules );
pluralFormIndex = Math.min( pluralFormIndex, forms.length - 1 );
return forms[pluralFormIndex];
},
/**
* For the number, get the plural for index
*
* @param number
* @param pluralRules
* @return plural form index
*/
getPluralForm: function ( number, pluralRules ) {
var pluralForms = [ 'zero', 'one', 'two', 'few', 'many', 'other' ];
var pluralFormIndex = 0;
for ( var i = 0; i < pluralForms.length; i++) {
if ( pluralRules[pluralForms[i]] ) {
if ( pluralRuleParser( pluralRules[pluralForms[i]], number ) ) {
return pluralFormIndex;
}
pluralFormIndex++;
}
}
return pluralFormIndex;
},
/**
* Converts a number using digitTransformTable.
*
* @param {num}
* number Value to be converted
* @param {boolean}
* integer Convert the return value to an integer
*/
'convertNumber': function ( num, integer ) {
// Set the target Transform table:
var transformTable = this.digitTransformTable( $.i18n().locale ), numberString = ''
+ num, convertedNumber = '';
if ( !transformTable ) {
return num;
}
// Check if the "restore" to Latin number flag is set:
if ( integer ) {
if ( parseFloat( num, 10 ) === num ) {
return num;
}
var tmp = [];
for ( var item in transformTable) {
tmp[transformTable[item]] = item;
}
transformTable = tmp;
}
for ( var i = 0; i < numberString.length; i++) {
if ( transformTable[numberString[i]] ) {
convertedNumber += transformTable[numberString[i]];
} else {
convertedNumber += numberString[i];
}
}
return integer ? parseFloat( convertedNumber, 10 ) : convertedNumber;
},
/**
* Grammatical transformations, needed for inflected languages.
* Invoked by putting {{grammar:form|word}} in a message.
* forms can be computed dynamically by overriding this method per language
*
* @param word {String}
* @param form {String}
* @return {String}
*/
convertGrammar: function ( word, form ) {
return word + form;
},
/**
* Provides an alternative text depending on specified gender. Usage
* {{gender:[gender|user object]|masculine|feminine|neutral}}. If second
* or third parameter are not specified, masculine is used.
*
* These details may be overriden per language.
*
* @param gender
* string male, female, or anything else for neutral.
* @param forms
* array List of gender forms
*
* @return string
*/
'gender': function ( gender, forms ) {
if ( !forms || forms.length === 0 ) {
return '';
}
while (forms.length < 2) {
forms.push( forms[forms.length - 1] );
}
if ( gender === 'male' ) {
return forms[0];
}
if ( gender === 'female' ) {
return forms[1];
}
return ( forms.length === 3 ) ? forms[2] : forms[0];
},
/**
* Get the digit transform table for the given language
* See http://cldr.unicode.org/translation/numbering-systems
* @param language
* @returns Array of digits in the passed language representation
*/
digitTransformTable: function ( language ) {
var tables = {
ar: "۰۱۲۳۴۵۶۷۸۹",
ml: "൦൧൨൩൪൫൬൭൮൯",
kn: "೦೧೨೩೪೫೬೭೮೯",
lo: "໐໑໒໓໔໕໖໗໘໙",
or: "୦୧୨୩୪୫୬୭୮୯",
kh: "០១២៣៤៥៦៧៨៩",
pa: "੦੧੨੩੪੫੬੭੮੯",
gu: "૦૧૨૩૪૫૬૭૮૯",
hi: "०१२३४५६७८९",
my: "၀၁၂၃၄၅၆၇၈၉",
ta: "௦௧௨௩௪௫௬௭௮௯",
te: "౦౧౨౩౪౫౬౭౮౯",
th: "๐๑๒๓๔๕๖๗๘๙", //FIXME use iso 639 codes
bo: "༠༡༢༣༤༥༦༧༨༩" //FIXME use iso 639 codes
};
if ( !tables[language] ) {
return null;
}
return tables[language].split( "" );
}
};
$.extend( $.i18n.languages, {
'default': language
} );
}( jQuery ) );
/**
* Bosnian (bosanski) language functions
*/
( function ( $ ) {
"use strict";
var bosanski = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'instrumental': // instrumental
word = 's ' + word;
break;
case 'lokativ': // locative
word = 'o ' + word;
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'bs': bosanski
} );
}( jQuery ) );
/**
* Lower Sorbian (Dolnoserbski) language functions
*/
( function ( $ ) {
"use strict";
var dsb = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'instrumental': // instrumental
word = 'z ' + word;
break;
case 'lokatiw': // lokatiw
word = 'wo ' + word;
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'dsb': dsb
} );
}( jQuery ) );
/**
* Finnish (Suomi) language functions
*
* @author Santhosh Thottingal
*/
( function ( $ ) {
"use strict";
var finnish = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
// vowel harmony flag
var aou = word.match( /[aou][^äöy]*$/i );
var origWord = word;
if ( word.match( /wiki$/i ) ) {
aou = false;
}
// append i after final consonant
if ( word.match( /[bcdfghjklmnpqrstvwxz]$/i ) ) {
word += 'i';
}
switch (form) {
case 'genitive':
word += 'n';
break;
case 'elative':
word += ( aou ? 'sta' : 'stä' );
break;
case 'partitive':
word += ( aou ? 'a' : 'ä' );
break;
case 'illative':
// Double the last letter and add 'n'
word += word.substr( word.length - 1 ) + 'n';
break;
case 'inessive':
word += ( aou ? 'ssa' : 'ssä' );
break;
default:
word = origWord;
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'fi': finnish
} );
}( jQuery ) );
/**
* Irish (Gaeilge) language functions
*/
( function ( $ ) {
"use strict";
var ga = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
if ( form === 'ainmlae' ) {
switch (word) {
case 'an Domhnach':
word = 'Dé Domhnaigh';
break;
case 'an Luan':
word = 'Dé Luain';
break;
case 'an Mháirt':
word = 'Dé Mháirt';
break;
case 'an Chéadaoin':
word = 'Dé Chéadaoin';
break;
case 'an Déardaoin':
word = 'Déardaoin';
break;
case 'an Aoine':
word = 'Dé hAoine';
break;
case 'an Satharn':
word = 'Dé Sathairn';
break;
}
}
return word;
}
} );
$.extend( $.i18n.languages, {
'ga': ga
} );
}( jQuery ) );
/**
* Hebrew (עברית) language functions
*/
( function ( $ ) {
"use strict";
var hebrew = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'prefixed':
case 'תחילית': // the same word in Hebrew
// Duplicate prefixed "Waw", but only if it's not already double
if ( word.substr( 0, 1 ) === "ו" && word.substr( 0, 2 ) !== "וו" ) {
word = "ו" + word;
}
// Remove the "He" if prefixed
if ( word.substr( 0, 1 ) === "ה" ) {
word = word.substr( 1, word.length );
}
// Add a hyphen (maqaf) before numbers and non-Hebrew letters
if ( word.substr( 0, 1 ) < "א" || word.substr( 0, 1 ) > "ת" ) {
word = "־" + word;
}
}
return word;
}
} );
$.extend( $.i18n.languages, {
'he': hebrew
} );
}( jQuery ) );
/**
* Upper Sorbian (Hornjoserbsce) language functions
*/
( function ( $ ) {
"use strict";
var hsb = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'instrumental': // instrumental
word = 'z ' + word;
break;
case 'lokatiw': // lokatiw
word = 'wo ' + word;
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'hsb': hsb
} );
}( jQuery ) );
/**
* Hungarian language functions
*
* @author Santhosh Thottingal
*/
( function ( $ ) {
"use strict";
var hu = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'rol':
word += 'ról';
break;
case 'ba':
word += 'ba';
break;
case 'k':
word += 'k';
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'hu': hu
} );
}( jQuery ) );
/**
* Armenian (Հայերեն) language functions
*/
( function ( $ ) {
"use strict";
var hy = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
if ( form === 'genitive' ) {// սեռական հոլով
if ( word.substr( -1 ) === 'ա' ) {
word = word.substr( 0, word.length - 1 ) + 'այի';
} else if ( word.substr( -1 ) === 'ո' ) {
word = word.substr( 0, word.length - 1 ) + 'ոյի';
} else if ( word.substr( -4 ) === 'գիրք' ) {
word = word.substr( 0, word.length - 4 ) + 'գրքի';
} else {
word = word + 'ի';
}
}
return word;
}
} );
$.extend( $.i18n.languages, {
'hy': hy
} );
}( jQuery ) );
/**
* Latin (lingua Latina) language functions
*
* @author Santhosh Thottingal
*/
( function ( $ ) {
"use strict";
var la = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'genitive':
// only a few declensions, and even for those mostly the singular only
word = word.replace( /u[ms]$/i, 'i' ); // 2nd declension singular
word = word.replace( /ommunia$/i, 'ommunium' ); // 3rd declension neuter plural (partly)
word = word.replace( /a$/i, 'ae' ); // 1st declension singular
word = word.replace( /libri$/i, 'librorum' ); // 2nd declension plural (partly)
word = word.replace( /nuntii$/i, 'nuntiorum' ); // 2nd declension plural (partly)
word = word.replace( /tio$/i, 'tionis' ); // 3rd declension singular (partly)
word = word.replace( /ns$/i, 'ntis' );
word = word.replace( /as$/i, 'atis' );
word = word.replace( /es$/i, 'ei' ); // 5th declension singular
break;
case 'accusative':
// only a few declensions, and even for those mostly the singular only
word = word.replace( /u[ms]$/i, 'um' ); // 2nd declension singular
word = word.replace( /ommunia$/i, 'am' ); // 3rd declension neuter plural (partly)
word = word.replace( /a$/i, 'ommunia' ); // 1st declension singular
word = word.replace( /libri$/i, 'libros' ); // 2nd declension plural (partly)
word = word.replace( /nuntii$/i, 'nuntios' );// 2nd declension plural (partly)
word = word.replace( /tio$/i, 'tionem' ); // 3rd declension singular (partly)
word = word.replace( /ns$/i, 'ntem' );
word = word.replace( /as$/i, 'atem' );
word = word.replace( /es$/i, 'em' ); // 5th declension singular
break;
case 'ablative':
// only a few declensions, and even for those mostly the singular only
word = word.replace( /u[ms]$/i, 'o' ); // 2nd declension singular
word = word.replace( /ommunia$/i, 'ommunibus' ); // 3rd declension neuter plural (partly)
word = word.replace( /a$/i, 'a' ); // 1st declension singular
word = word.replace( /libri$/i, 'libris' ); // 2nd declension plural (partly)
word = word.replace( /nuntii$/i, 'nuntiis' ); // 2nd declension plural (partly)
word = word.replace( /tio$/i, 'tione' ); // 3rd declension singular (partly)
word = word.replace( /ns$/i, 'nte' );
word = word.replace( /as$/i, 'ate' );
word = word.replace( /es$/i, 'e' ); // 5th declension singular
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'la': la
} );
}( jQuery ) );
/**
* Ossetian (Ирон) language functions
*
* @author Santhosh Thottingal
*/
( function ( $ ) {
"use strict";
var os = $.extend( {}, $.i18n.languages['default'],
{
convertGrammar: function ( word, form ) {
// Ending for allative case
var end_allative = 'мæ';
// Variable for 'j' beetwen vowels
var jot = '';
// Variable for "-" for not Ossetic words
var hyphen = '';
// Variable for ending
var ending = '';
// Checking if the $word is in plural form
if ( word.match( /тæ$/i ) ) {
word = word.substring( 0, word.length - 1 );
end_allative = 'æм';
}
// Works if word is in singular form.
// Checking if word ends on one of the vowels: е, ё, и, о, ы, э, ю,
// я.
else if ( word.match( /[аæеёиоыэюя]$/i ) ) {
jot = 'й';
}
// Checking if word ends on 'у'. 'У' can be either consonant 'W' or
// vowel 'U' in cyrillic Ossetic.
// Examples: {{grammar:genitive|аунеу}} = аунеуы,
// {{grammar:genitive|лæппу}} = лæппуйы.
else if ( word.match( /у$/i ) ) {
if ( !word.substring( word.length - 2, word.length - 1 ).match(
/[аæеёиоыэюя]$/i ) ) {
jot = 'й';
}
} else if ( !word.match( /[бвгджзйклмнопрстфхцчшщьъ]$/i ) ) {
hyphen = '-';
}
switch (form) {
case 'genitive':
ending = hyphen + jot + 'ы';
break;
case 'dative':
ending = hyphen + jot + 'æн';
break;
case 'allative':
ending = hyphen + end_allative;
break;
case 'ablative':
if ( jot === 'й' ) {
ending = hyphen + jot + 'æ';
} else {
ending = hyphen + jot + 'æй';
}
break;
case 'superessive':
ending = hyphen + jot + 'ыл';
break;
case 'equative':
ending = hyphen + jot + 'ау';
break;
case 'comitative':
ending = hyphen + 'имæ';
break;
}
return word + ending;
}
} );
$.extend( $.i18n.languages, {
'os': os
} );
}( jQuery ) );
/**
* Russian (Русский) language functions
*/
( function ( $ ) {
"use strict";
var ru = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
if ( form === 'genitive' ) { // родительный падеж
if ( ( word.substr( word.length - 4 ) === 'вики' )
|| ( word.substr( word.length - 4 ) === 'Вики' ) ) {
} else if ( word.substr( word.length - 1 ) === 'ь' ) {
word = word.substr( 0, word.length - 1 ) + 'я';
} else if ( word.substr( word.length - 2 ) === 'ия' ) {
word = word.substr( 0, word.length - 2 ) + 'ии';
} else if ( word.substr( word.length - 2 ) === 'ка' ) {
word = word.substr( 0, word.length - 2 ) + 'ки';
} else if ( word.substr( word.length - 2 ) === 'ти' ) {
word = word.substr( 0, word.length - 2 ) + 'тей';
} else if ( word.substr( word.length - 2 ) === 'ды' ) {
word = word.substr( 0, word.length - 2 ) + 'дов';
} else if ( word.substr( word.length - 3 ) === 'ник' ) {
word = word.substr( 0, word.length - 3 ) + 'ника';
}
}
return word;
}
} );
$.extend( $.i18n.languages, {
'ru': ru
} );
}( jQuery ) );
/**
* Slovenian (Slovenščina) language functions
*/
( function ( $ ) {
"use strict";
var sl = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'mestnik': // locative
word = 'o ' + word;
break;
case 'orodnik': // instrumental
word = 'z ' + word;
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'sl': sl
} );
}( jQuery ) );
/**
* Ukrainian (Українська) language functions
*/
( function ( $ ) {
"use strict";
var uk = $.extend( {}, $.i18n.languages['default'], {
convertGrammar: function ( word, form ) {
switch (form) {
case 'genitive': // родовий відмінок
if ( ( word.substr( word.length - 4 ) === 'вікі' )
|| ( word.substr( word.length - 4 ) === 'Вікі' ) ) {
} else if ( word.substr( word.length - 1 ) === 'ь' ) {
word = word.substr( 0, word.length - 1 ) + 'я';
} else if ( word.substr( word.length - 2 ) === 'ія' ) {
word = word.substr( 0, word.length - 2 ) + 'ії';
} else if ( word.substr( word.length - 2 ) === 'ка' ) {
word = word.substr( 0, word.length - 2 ) + 'ки';
} else if ( word.substr( word.length - 2 ) === 'ти' ) {
word = word.substr( 0, word.length - 2 ) + 'тей';
} else if ( word.substr( word.length - 2 ) === 'ды' ) {
word = word.substr( 0, word.length - 2 ) + 'дов';
} else if ( word.substr( word.length - 3 ) === 'ник' ) {
word = word.substr( 0, word.length - 3 ) + 'ника';
}
break;
case 'accusative': // знахідний відмінок
if ( ( word.substr( word.length - 4 ) === 'вікі' )
|| ( word.substr( word.length - 4 ) === 'Вікі' ) ) {
} else if ( word.substr( word.length - 2 ) === 'ія' ) {
word = word.substr( 0, word.length - 2 ) + 'ію';
}
break;
}
return word;
}
} );
$.extend( $.i18n.languages, {
'uk': uk
} );
}( jQuery ) );
/**
* cldrpluralparser.js
* A parser engine for CLDR plural rules.
*
* Copyright 2012 GPLV3+, Santhosh Thottingal
*
* @version 0.1.0-alpha
* @source https://github.com/santhoshtr/CLDRPluralRuleParser
* @author Santhosh Thottingal <santhosh.thottingal@gmail.com>
* @author Timo Tijhof
* @author Amir Aharoni
*/
/**
* Evaluates a plural rule in CLDR syntax for a number
* @param rule
* @param number
* @return true|false|null
*/
function pluralRuleParser(rule, number) {
/*
Syntax: see http://unicode.org/reports/tr35/#Language_Plural_Rules
-----------------------------------------------------------------
condition = and_condition ('or' and_condition)*
and_condition = relation ('and' relation)*
relation = is_relation | in_relation | within_relation | 'n' <EOL>
is_relation = expr 'is' ('not')? value
in_relation = expr ('not')? 'in' range_list
within_relation = expr ('not')? 'within' range_list
expr = 'n' ('mod' value)?
range_list = (range | value) (',' range_list)*
value = digit+
digit = 0|1|2|3|4|5|6|7|8|9
range = value'..'value
*/
// Indicates current position in the rule as we parse through it.
// Shared among all parsing functions below.
var pos = 0;
var whitespace = makeRegexParser(/^\s+/);
var digits = makeRegexParser(/^\d+/);
var _n_ = makeStringParser('n');
var _is_ = makeStringParser('is');
var _mod_ = makeStringParser('mod');
var _not_ = makeStringParser('not');
var _in_ = makeStringParser('in');
var _within_ = makeStringParser('within');
var _range_ = makeStringParser('..');
var _comma_ = makeStringParser(',');
var _or_ = makeStringParser('or');
var _and_ = makeStringParser('and');
function debug() {
/* console.log.apply(console, arguments);*/
}
debug('pluralRuleParser', rule, number);
// Try parsers until one works, if none work return null
function choice(parserSyntax) {
return function () {
for (var i = 0; i < parserSyntax.length; i++) {
var result = parserSyntax[i]();
if (result !== null) {
return result;
}
}
return null;
};
}
// Try several parserSyntax-es in a row.
// All must succeed; otherwise, return null.
// This is the only eager one.
function sequence(parserSyntax) {
var originalPos = pos;
var result = [];
for (var i = 0; i < parserSyntax.length; i++) {
var res = parserSyntax[i]();
if (res === null) {
pos = originalPos;
return null;
}
result.push(res);
}
return result;
}
// Run the same parser over and over until it fails.
// Must succeed a minimum of n times; otherwise, return null.
function nOrMore(n, p) {
return function () {
var originalPos = pos;
var result = [];
var parsed = p();
while (parsed !== null) {
result.push(parsed);
parsed = p();
}
if (result.length < n) {
pos = originalPos;
return null;
}
return result;
};
}
// Helpers -- just make parserSyntax out of simpler JS builtin types
function makeStringParser(s) {
var len = s.length;
return function () {
var result = null;
if (rule.substr(pos, len) === s) {
result = s;
pos += len;
}
return result;
};
}
function makeRegexParser(regex) {
return function () {
var matches = rule.substr(pos).match(regex);
if (matches === null) {
return null;
}
pos += matches[0].length;
return matches[0];
};
}
function n() {
var result = _n_();
if (result === null) {
debug(" -- failed n");
return result;
}
result = parseInt(number, 10);
debug(" -- passed n ", result);
return result;
}
var expression = choice([mod, n]);
function mod() {
var result = sequence([n, whitespace, _mod_, whitespace, digits]);
if (result === null) {
debug(" -- failed mod");
return null;
}
debug(" -- passed mod");
return parseInt(result[0], 10) % parseInt(result[4], 10);
}
function not() {
var result = sequence([whitespace, _not_]);
if (result === null) {
debug(" -- failed not");
return null;
} else {
return result[1];
}
}
function is() {
var result = sequence([expression, whitespace, _is_, nOrMore(0, not), whitespace, digits]);
if (result !== null) {
debug(" -- passed is");
if (result[3][0] === 'not') {
return result[0] !== parseInt(result[5], 10);
} else {
return result[0] === parseInt(result[5], 10);
}
}
debug(" -- failed is");
return null;
}
function rangeList() {
// range_list = (range | value) (',' range_list)*
var result = sequence([choice([range, digits]), nOrMore(0, rangeTail)]);
var resultList = [];
if (result !== null) {
resultList = resultList.concat(result[0], result[1][0]);
return resultList;
}
debug(" -- failed rangeList");
return null;
}
function rangeTail() {
// ',' range_list
var result = sequence([_comma_, rangeList]);
if (result !== null) {
return result[1];
}
debug(" -- failed rangeTail");
return null;
}
function range() {
var result = sequence([digits, _range_, digits]);
if (result !== null) {
debug(" -- passed range");
var array = [];
var left = parseInt(result[0], 10);
var right = parseInt(result[2], 10);
for ( i = left; i <= right; i++) {
array.push(i);
}
return array;
}
debug(" -- failed range");
return null;
}
function _in() {
// in_relation = expr ('not')? 'in' range_list
var result = sequence([expression, nOrMore(0, not), whitespace, _in_, whitespace, rangeList]);
if (result !== null) {
debug(" -- passed _in");
var range_list = result[5];
for (var i = 0; i < range_list.length; i++) {
if (parseInt(range_list[i], 10) === result[0]) {
return (result[1][0] !== 'not');
}
}
return (result[1][0] === 'not');
}
debug(" -- failed _in ");
return null;
}
function within() {
var result = sequence([expression, whitespace, _within_, whitespace, rangeList]);
if (result !== null) {
debug(" -- passed within ");
var range_list = result[4];
return (parseInt( range_list[0],10 )<= result[0] && result[0] <= parseInt( range_list[1], 10));
}
debug(" -- failed within ");
return null;
}
var relation = choice([is, _in, within]);
function and() {
var result = sequence([relation, whitespace, _and_, whitespace, condition]);
if (result) {
debug(" -- passed and");
return result[0] && result[4];
}
debug(" -- failed and");
return null;
}
function or() {
var result = sequence([relation, whitespace, _or_, whitespace, condition]);
if (result) {
debug(" -- passed or");
return result[0] || result[4];
}
debug(" -- failed or");
return null;
}
var condition = choice([and, or, relation]);
function isInt(n) {
return parseFloat(n) % 1 === 0;
}
function start() {
if (!isInt(number)) {
return false;
}
var result = condition();
return result;
}
var result = start();
/*
* For success, the pos must have gotten to the end of the rule
* and returned a non-null.
* n.b. This is part of language infrastructure, so we do not throw an internationalizable message.
*/
if (result === null || pos !== rule.length) {
// throw new Error("Parse error at position " + pos.toString() + " in input: " + rule + " result is " + result);
}
return result;
}
/* For module loaders, e.g. NodeJS, NPM */
if (typeof module !== 'undefined' && module.exports) {
module.exports = pluralRuleParser;
}
Reference in New Issue View Git Blame Copy Permalink