private static PluralRuleSet[] GetPluralRuleSets(bool ordinals = false)
{
if (options != null && ((ordinals && !options.IncludeOrdinalRuleSets) ||
(!ordinals && !options.IncludePluralRuleSets)))
{
return(null);
}
string filename = ordinals ? "ordinals" : "plurals";
string ruleSetType = ordinals ? "ordinal" : "plural";
XDocument document = GetXmlDocument(String.Format(@"common\supplemental\{0}.xml", filename));
IEnumerable <XElement> ldmlElements = document.Elements("supplementalData");
List <XElement> pluralRuleSetDatas = (from item in ldmlElements.Elements("plurals")
.Elements("pluralRules")
select item).ToList();
if (pluralRuleSetDatas != null && pluralRuleSetDatas.Count > 0)
{
List <PluralRuleSet> pluralRuleSets = new List <PluralRuleSet>();
foreach (XElement data in pluralRuleSetDatas)
{
string cultureNames = data.Attribute("locales").Value.ToString();
Progress(String.Format("Adding {0} rule set", ruleSetType), cultureNames);
PluralRuleSet pluralRuleSet = new PluralRuleSet();
pluralRuleSet.CultureNames = cultureNames.Split(' ');
List <XElement> pluralRuleDatas = (from item in data
.Elements("pluralRule")
select item).ToList();
if (pluralRuleDatas != null)
{
List <PluralRule> pluralRules = new List <PluralRule>();
foreach (XElement pluralRuleData in pluralRuleDatas)
{
PluralRule pluralRule = new PluralRule();
pluralRule.Id = GetPluralRuleCount(pluralRuleData.Attribute("count").Value.ToString());
pluralRule.Rule = pluralRuleData.Value;
pluralRules.Add(pluralRule);
}
pluralRuleSet.PluralRules = pluralRules.ToArray();
}
pluralRuleSets.Add(pluralRuleSet);
Progress(String.Format("Added {0} rule set", ruleSetType), cultureNames, ProgressEventType.Added, pluralRuleSet);
}
return(pluralRuleSets.ToArray());
}
return(null);
}
public void TestCustomForms()
{
var rule1 = new PluralRule(1, number => (int)number);
var rule2 = new PluralRule(1, number => (int)(number * 2));
foreach (var n in new long[] { 0, 1, 2, 3, 100, 101, 102, 103 })
{
Assert.Equal(n, rule1.Evaluate(n));
Assert.Equal(n * 2, rule2.Evaluate(n));
}
}
/// <summary>
/// GetPluralRule gets the CLDR PluralRule for the integer from the array of PluralRules
/// </summary>
/// <param name="pluralRules">The array of PluralRules to get a match from</param>
/// <param name="value">The integer to find a match for</param>
/// <returns>The CLDR PluralRule for the integer from the array of PluralRules</returns>
private static PluralRule GetPluralRule(PluralRule[] pluralRules, int value)
{
foreach (PluralRule pluralRule in pluralRules)
{
if (pluralRule.IsMatch(value))
{
return pluralRule;
}
}
return null;
}
public static void ParseReturnsTheCorrectDecimalSamples(string count, string rule, params string [] expectedSamples)
{
Assert.Equal(expectedSamples, PluralRule.Parse(count, rule, out _).DecimalSamples);
}
public static PluralRules [] Parse(XDocument document)
{
var ruleSets = new List <PluralRules> ( );
var plurals = document.Descendants("plurals").Single( );
var type = plurals.Attribute("type")?.Value;
var prefix = type == "cardinal" ? "CardinalRuleSet" :
type == "ordinal" ? "OrdinalRuleSet" :
throw new XmlException("Invalid plurals type attribute");
var names = new Dictionary <string, int> ( );
foreach (var pluralRules in plurals.Descendants("pluralRules"))
{
var ruleSet = new PluralRules( );
ruleSet.Locales = pluralRules.Attribute("locales").Value
.Replace("_", "-")
.Split(' ');
var operands = new HashSet <string> ( );
var rules = new List <PluralRule> ( );
var defaultRule = DefaultPluralRule;
foreach (var pluralRule in pluralRules.Descendants("pluralRule"))
{
var rule = PluralRule.Parse(pluralRule.Attribute("count").Value,
pluralRule.Value,
out var ruleOperands);
if (ruleOperands != null)
{
foreach (var operand in ruleOperands)
{
operands.Add(operand);
}
}
if (rule.Rule != null)
{
rules.Add(rule);
}
else
{
defaultRule = rule;
}
}
foreach (var rule in rules)
{
ruleSet.PluralForm |= rule.PluralForm;
}
var name = (string)null;
var isDefaultRuleSet = rules.Count == 0 && ruleSet.PluralForm == PluralForm.Other;
if (!isDefaultRuleSet)
{
name = prefix + ruleSet.PluralForm.ToString( ).Replace(", ", string.Empty);
if (!names.TryGetValue(name, out var index))
{
index = -1;
}
names [name] = ++index;
name += (char)('A' + index);
}
else
{
name = "Default" + prefix;
}
ruleSet.Name = name;
ruleSet.Operands = operands.ToArray( );
ruleSet.Rules = rules.ToArray( );
ruleSet.DefaultRule = defaultRule;
ruleSets.Add(ruleSet);
}
return(ruleSets.ToArray( ));
}
public static void ParseReturnsTheCorrectRuleCode(string count, string rule, string expectedRuleCode)
{
Assert.Equal(expectedRuleCode, PluralRule.Parse(count, rule, out _).RuleCode);
}
public static void ParseReturnsTheCorrectOperands(string count, string rule, params string [] expectedOperands)
{
PluralRule.Parse(count, rule, out var operands);
Assert.Equal(expectedOperands, operands);
}
public static void ParseReturnsTheCorrectRule(string count, string rule, string expectedExpression)
{
Assert.Equal(expectedExpression, PluralRule.Parse(count, rule, out _).Rule?.ToString( ));
}
public static void ParseThrowsOnInvalidPluralForm(string count, string rule)
{
Assert.Throws <FormatException> (() => PluralRule.Parse(count, rule, out _));
}
public static void ParseReturnsTheCorrectPluralForm(string count, string rule, PluralForm expectedPluralForm)
{
Assert.Equal(expectedPluralForm, PluralRule.Parse(count, rule, out _).PluralForm);
}
