608 lines
12 KiB
JavaScript
608 lines
12 KiB
JavaScript
/**
|
|
* cldrpluralparser.js
|
|
* A parser engine for CLDR plural rules.
|
|
*
|
|
* Copyright 2012-2014 Santhosh Thottingal and other contributors
|
|
* Released under the MIT license
|
|
* http://opensource.org/licenses/MIT
|
|
*
|
|
* @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 {string} rule
|
|
* @param {integer} number
|
|
* @return {boolean} true if evaluation passed, false if evaluation failed.
|
|
*/
|
|
|
|
// UMD returnExports https://github.com/umdjs/umd/blob/master/returnExports.js
|
|
(function(root, factory) {
|
|
if (typeof define === 'function' && define.amd) {
|
|
// AMD. Register as an anonymous module.
|
|
define(factory);
|
|
} else if (typeof exports === 'object') {
|
|
// Node. Does not work with strict CommonJS, but
|
|
// only CommonJS-like environments that support module.exports,
|
|
// like Node.
|
|
module.exports = factory();
|
|
} else {
|
|
// Browser globals (root is window)
|
|
root.pluralRuleParser = factory();
|
|
}
|
|
}(this, function() {
|
|
|
|
function pluralRuleParser(rule, number) {
|
|
'use strict';
|
|
|
|
/*
|
|
Syntax: see http://unicode.org/reports/tr35/#Language_Plural_Rules
|
|
-----------------------------------------------------------------
|
|
condition = and_condition ('or' and_condition)*
|
|
('@integer' samples)?
|
|
('@decimal' samples)?
|
|
and_condition = relation ('and' relation)*
|
|
relation = is_relation | in_relation | within_relation
|
|
is_relation = expr 'is' ('not')? value
|
|
in_relation = expr (('not')? 'in' | '=' | '!=') range_list
|
|
within_relation = expr ('not')? 'within' range_list
|
|
expr = operand (('mod' | '%') value)?
|
|
operand = 'n' | 'i' | 'f' | 't' | 'v' | 'w'
|
|
range_list = (range | value) (',' range_list)*
|
|
value = digit+
|
|
digit = 0|1|2|3|4|5|6|7|8|9
|
|
range = value'..'value
|
|
samples = sampleRange (',' sampleRange)* (',' ('…'|'...'))?
|
|
sampleRange = decimalValue '~' decimalValue
|
|
decimalValue = value ('.' value)?
|
|
*/
|
|
|
|
// We don't evaluate the samples section of the rule. Ignore it.
|
|
rule = rule.split('@')[0].replace(/^\s*/, '').replace(/\s*$/, '');
|
|
|
|
if (!rule.length) {
|
|
// Empty rule or 'other' rule.
|
|
return true;
|
|
}
|
|
|
|
// Indicates the current position in the rule as we parse through it.
|
|
// Shared among all parsing functions below.
|
|
var pos = 0,
|
|
operand,
|
|
expression,
|
|
relation,
|
|
result,
|
|
whitespace = makeRegexParser(/^\s+/),
|
|
value = makeRegexParser(/^\d+/),
|
|
_n_ = makeStringParser('n'),
|
|
_i_ = makeStringParser('i'),
|
|
_f_ = makeStringParser('f'),
|
|
_t_ = makeStringParser('t'),
|
|
_v_ = makeStringParser('v'),
|
|
_w_ = makeStringParser('w'),
|
|
_is_ = makeStringParser('is'),
|
|
_isnot_ = makeStringParser('is not'),
|
|
_isnot_sign_ = makeStringParser('!='),
|
|
_equal_ = makeStringParser('='),
|
|
_mod_ = makeStringParser('mod'),
|
|
_percent_ = makeStringParser('%'),
|
|
_not_ = makeStringParser('not'),
|
|
_in_ = makeStringParser('in'),
|
|
_within_ = makeStringParser('within'),
|
|
_range_ = makeStringParser('..'),
|
|
_comma_ = makeStringParser(','),
|
|
_or_ = makeStringParser('or'),
|
|
_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() {
|
|
var i, result;
|
|
|
|
for (i = 0; i < parserSyntax.length; i++) {
|
|
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 i, parserRes,
|
|
originalPos = pos,
|
|
result = [];
|
|
|
|
for (i = 0; i < parserSyntax.length; i++) {
|
|
parserRes = parserSyntax[i]();
|
|
|
|
if (parserRes === null) {
|
|
pos = originalPos;
|
|
|
|
return null;
|
|
}
|
|
|
|
result.push(parserRes);
|
|
}
|
|
|
|
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,
|
|
result = [],
|
|
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];
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Integer digits of n.
|
|
*/
|
|
function i() {
|
|
var result = _i_();
|
|
|
|
if (result === null) {
|
|
debug(' -- failed i', parseInt(number, 10));
|
|
|
|
return result;
|
|
}
|
|
|
|
result = parseInt(number, 10);
|
|
debug(' -- passed i ', result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Absolute value of the source number (integer and decimals).
|
|
*/
|
|
function n() {
|
|
var result = _n_();
|
|
|
|
if (result === null) {
|
|
debug(' -- failed n ', number);
|
|
|
|
return result;
|
|
}
|
|
|
|
result = parseFloat(number, 10);
|
|
debug(' -- passed n ', result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Visible fractional digits in n, with trailing zeros.
|
|
*/
|
|
function f() {
|
|
var result = _f_();
|
|
|
|
if (result === null) {
|
|
debug(' -- failed f ', number);
|
|
|
|
return result;
|
|
}
|
|
|
|
result = (number + '.').split('.')[1] || 0;
|
|
debug(' -- passed f ', result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Visible fractional digits in n, without trailing zeros.
|
|
*/
|
|
function t() {
|
|
var result = _t_();
|
|
|
|
if (result === null) {
|
|
debug(' -- failed t ', number);
|
|
|
|
return result;
|
|
}
|
|
|
|
result = (number + '.').split('.')[1].replace(/0$/, '') || 0;
|
|
debug(' -- passed t ', result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Number of visible fraction digits in n, with trailing zeros.
|
|
*/
|
|
function v() {
|
|
var result = _v_();
|
|
|
|
if (result === null) {
|
|
debug(' -- failed v ', number);
|
|
|
|
return result;
|
|
}
|
|
|
|
result = (number + '.').split('.')[1].length || 0;
|
|
debug(' -- passed v ', result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Number of visible fraction digits in n, without trailing zeros.
|
|
*/
|
|
function w() {
|
|
var result = _w_();
|
|
|
|
if (result === null) {
|
|
debug(' -- failed w ', number);
|
|
|
|
return result;
|
|
}
|
|
|
|
result = (number + '.').split('.')[1].replace(/0$/, '').length || 0;
|
|
debug(' -- passed w ', result);
|
|
|
|
return result;
|
|
}
|
|
|
|
// operand = 'n' | 'i' | 'f' | 't' | 'v' | 'w'
|
|
operand = choice([n, i, f, t, v, w]);
|
|
|
|
// expr = operand (('mod' | '%') value)?
|
|
expression = choice([mod, operand]);
|
|
|
|
function mod() {
|
|
var result = sequence(
|
|
[operand, whitespace, choice([_mod_, _percent_]), whitespace, value]
|
|
);
|
|
|
|
if (result === null) {
|
|
debug(' -- failed mod');
|
|
|
|
return null;
|
|
}
|
|
|
|
debug(' -- passed ' + parseInt(result[0], 10) + ' ' + result[2] + ' ' + parseInt(result[4], 10));
|
|
|
|
return parseFloat(result[0]) % parseInt(result[4], 10);
|
|
}
|
|
|
|
function not() {
|
|
var result = sequence([whitespace, _not_]);
|
|
|
|
if (result === null) {
|
|
debug(' -- failed not');
|
|
|
|
return null;
|
|
}
|
|
|
|
return result[1];
|
|
}
|
|
|
|
// is_relation = expr 'is' ('not')? value
|
|
function is() {
|
|
var result = sequence([expression, whitespace, choice([_is_]), whitespace, value]);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed is : ' + result[0] + ' == ' + parseInt(result[4], 10));
|
|
|
|
return result[0] === parseInt(result[4], 10);
|
|
}
|
|
|
|
debug(' -- failed is');
|
|
|
|
return null;
|
|
}
|
|
|
|
// is_relation = expr 'is' ('not')? value
|
|
function isnot() {
|
|
var result = sequence(
|
|
[expression, whitespace, choice([_isnot_, _isnot_sign_]), whitespace, value]
|
|
);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed isnot: ' + result[0] + ' != ' + parseInt(result[4], 10));
|
|
|
|
return result[0] !== parseInt(result[4], 10);
|
|
}
|
|
|
|
debug(' -- failed isnot');
|
|
|
|
return null;
|
|
}
|
|
|
|
function not_in() {
|
|
var i, range_list,
|
|
result = sequence([expression, whitespace, _isnot_sign_, whitespace, rangeList]);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed not_in: ' + result[0] + ' != ' + result[4]);
|
|
range_list = result[4];
|
|
|
|
for (i = 0; i < range_list.length; i++) {
|
|
if (parseInt(range_list[i], 10) === parseInt(result[0], 10)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
debug(' -- failed not_in');
|
|
|
|
return null;
|
|
}
|
|
|
|
// range_list = (range | value) (',' range_list)*
|
|
function rangeList() {
|
|
var result = sequence([choice([range, value]), nOrMore(0, rangeTail)]),
|
|
resultList = [];
|
|
|
|
if (result !== null) {
|
|
resultList = resultList.concat(result[0]);
|
|
|
|
if (result[1][0]) {
|
|
resultList = resultList.concat(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;
|
|
}
|
|
|
|
// range = value'..'value
|
|
function range() {
|
|
var i, array, left, right,
|
|
result = sequence([value, _range_, value]);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed range');
|
|
|
|
array = [];
|
|
left = parseInt(result[0], 10);
|
|
right = parseInt(result[2], 10);
|
|
|
|
for (i = left; i <= right; i++) {
|
|
array.push(i);
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
debug(' -- failed range');
|
|
|
|
return null;
|
|
}
|
|
|
|
function _in() {
|
|
var result, range_list, i;
|
|
|
|
// in_relation = expr ('not')? 'in' range_list
|
|
result = sequence(
|
|
[expression, nOrMore(0, not), whitespace, choice([_in_, _equal_]), whitespace, rangeList]
|
|
);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed _in:' + result);
|
|
|
|
range_list = result[5];
|
|
|
|
for (i = 0; i < range_list.length; i++) {
|
|
if (parseInt(range_list[i], 10) === parseFloat(result[0])) {
|
|
return (result[1][0] !== 'not');
|
|
}
|
|
}
|
|
|
|
return (result[1][0] === 'not');
|
|
}
|
|
|
|
debug(' -- failed _in ');
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* The difference between "in" and "within" is that
|
|
* "in" only includes integers in the specified range,
|
|
* while "within" includes all values.
|
|
*/
|
|
function within() {
|
|
var range_list, result;
|
|
|
|
// within_relation = expr ('not')? 'within' range_list
|
|
result = sequence(
|
|
[expression, nOrMore(0, not), whitespace, _within_, whitespace, rangeList]
|
|
);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed within');
|
|
|
|
range_list = result[5];
|
|
|
|
if ((result[0] >= parseInt(range_list[0], 10)) &&
|
|
(result[0] < parseInt(range_list[range_list.length - 1], 10))) {
|
|
|
|
return (result[1][0] !== 'not');
|
|
}
|
|
|
|
return (result[1][0] === 'not');
|
|
}
|
|
|
|
debug(' -- failed within ');
|
|
|
|
return null;
|
|
}
|
|
|
|
// relation = is_relation | in_relation | within_relation
|
|
relation = choice([is, not_in, isnot, _in, within]);
|
|
|
|
// and_condition = relation ('and' relation)*
|
|
function and() {
|
|
var i,
|
|
result = sequence([relation, nOrMore(0, andTail)]);
|
|
|
|
if (result) {
|
|
if (!result[0]) {
|
|
return false;
|
|
}
|
|
|
|
for (i = 0; i < result[1].length; i++) {
|
|
if (!result[1][i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
debug(' -- failed and');
|
|
|
|
return null;
|
|
}
|
|
|
|
// ('and' relation)*
|
|
function andTail() {
|
|
var result = sequence([whitespace, _and_, whitespace, relation]);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed andTail' + result);
|
|
|
|
return result[3];
|
|
}
|
|
|
|
debug(' -- failed andTail');
|
|
|
|
return null;
|
|
|
|
}
|
|
// ('or' and_condition)*
|
|
function orTail() {
|
|
var result = sequence([whitespace, _or_, whitespace, and]);
|
|
|
|
if (result !== null) {
|
|
debug(' -- passed orTail: ' + result[3]);
|
|
|
|
return result[3];
|
|
}
|
|
|
|
debug(' -- failed orTail');
|
|
|
|
return null;
|
|
}
|
|
|
|
// condition = and_condition ('or' and_condition)*
|
|
function condition() {
|
|
var i,
|
|
result = sequence([and, nOrMore(0, orTail)]);
|
|
|
|
if (result) {
|
|
for (i = 0; i < result[1].length; i++) {
|
|
if (result[1][i]) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return result[0];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
result = condition();
|
|
|
|
/**
|
|
* 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) {
|
|
throw new Error('Parse error at position ' + pos.toString() + ' for rule: ' + rule);
|
|
}
|
|
|
|
if (pos !== rule.length) {
|
|
debug('Warning: Rule not parsed completely. Parser stopped at ' + rule.substr(0, pos) + ' for rule: ' + rule);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
return pluralRuleParser;
|
|
|
|
}));
|