rbnf: make spell_number API less kwargsy

Author: akx

babel/numbers.py

@@ -663,15 +663,15 @@ def __init__(self, message, suggestions=None):
         self.suggestions = suggestions
 
 
-def spell_number(number, locale=LC_NUMERIC, **kwargs):
+def spell_number(number, locale=LC_NUMERIC, ruleset=None):
     """Return value spelled out for a specific locale
     
     :param number: the number to format
     :param locale: the `Locale` object or locale identifier
-    :param kwargs: optional locale specific parameters
+    :param ruleset: the ruleset to use; defaults to regular numbers.
     """
     speller = RuleBasedNumberFormat.negotiate(locale)
-    return speller.format(number, **kwargs)
+    return speller.format(number, ruleset=ruleset)
 
 
 def get_rbnf_rules(locale=LC_NUMERIC):

babel/rbnf.py

@@ -84,10 +84,25 @@
 # normal rule means a number is specified
 
 
-class RBNFError(Exception): pass
-class TokenizationError(RBNFError): pass
-class RulesetNotFound(RBNFError): pass
-class RuleNotFound(RBNFError): pass
+class RBNFError(Exception):
+    pass
+
+
+class TokenizationError(RBNFError):
+    pass
+
+
+class RulesetNotFound(RBNFError):
+    pass
+
+
+class RuleNotFound(RBNFError):
+    pass
+
+
+class RulesetSubstitutionWarning(UserWarning):
+    pass
+
 
 TokenInfo = collections.namedtuple('TokenInfo', 'type reference optional')
 
@@ -221,52 +236,65 @@ def available_rulesets(self):
         """list available public rulesets"""
         return [r.name for r in self.rulesets if not r.private]
 
-
-    def format(self, number, ordinal=False, year=False, ruleset=None, **kwargs):
-        """spell an actual number (int/float/decimal)
-        
-        Search available_rulesets for an entry point
-        default is `spellout-numbering`.
-
-        If year is True: use spellout-numbering-year
-        If ordinal is True: use spellout-ordinal
-        If year and ordinal both True: raise error
-        
-        TODO
-        If no `spellout-ordinal`:
-            if has `spellout-ordinal-*`: use first one, issue warning
-
+    def _find_matching_ruleset(self, prefix):
+        available_rulesets = self.available_rulesets
+        if prefix in available_rulesets:
+            return (prefix, True)
+        # Sorting here avoids use of more specific ("spellout-ordinal-sinokorean-count")
+        # rulesets when a shorter one might be available.
+        for ruleset in sorted(available_rulesets):
+            if ruleset.startswith(prefix):
+                return (ruleset, False)
+        return (None, False)
+
+    def match_ruleset(self, ruleset):
         """
-        if ordinal and year:
-            raise ValueError('both ordinal and year is not possible')
-        if ordinal:
-            search = ruleset or 'spellout-ordinal'
-        elif year:
-            search = ruleset or 'spellout-year'
-        else:
-            search = ruleset or 'spellout-numbering'
-
-        ruleset = self.get_ruleset(search)
-
-        if ruleset is None:
-            raise RulesetNotFound(search)
-
-        return ruleset.apply(number, self)
+        Try to find a matching ruleset given a ruleset name or alias ("year", "ordinal").
+        """
+        if ruleset == "year":
+            ruleset = "spellout-numbering-year"
+        elif ruleset == "ordinal":
+            ruleset, exact_match = self._find_matching_ruleset("spellout-ordinal")
+            if not ruleset:
+                raise RulesetNotFound("No ordinal ruleset is available for %s" % (
+                    self._locale,
+                ))
+            if not exact_match:
+                warnings.warn("Using non-specific ordinal ruleset %s" % ruleset, RulesetSubstitutionWarning)
+        ruleset_obj = self.get_ruleset(ruleset)
+        if not ruleset_obj:
+            raise RulesetNotFound("Ruleset %r is not one of the ones available for %s: %r" % (
+                ruleset,
+                self._locale,
+                self.available_rulesets,
+            ))
+        return ruleset_obj
+
+    def format(self, number, ruleset=None):
+        """Format a number (int/float/decimal) with spelling rules.
+
+        Ruleset may be an actual ruleset name for the locale,
+        or one of the aliases "year" or "ordinal".
+        """
+        if not ruleset:
+            ruleset = "spellout-numbering"
 
+        return self.match_ruleset(ruleset).apply(number, self)
 
     def get_ruleset(self, name):
         for r in self.rulesets:
             if r.name == name:
                 return r
 
-
     @classmethod
     def negotiate(cls, locale):
         """
         Negotiate proper RBNF rules based on global data item `rbnf_locales`
         Caching is not necessary the Locale object does that pretty well
         """
         loc = Locale.negotiate([str(Locale.parse(locale))], get_global('rbnf_locales'))
+        if not loc:
+            raise RulesetNotFound("No RBNF rules available for %s" % locale)
         return cls(loc)
 
 

tests/test_number_spelling.py

@@ -21,14 +21,14 @@ def test_basic(self):
 
     def test_negotiation(self):
         for lid in locale_identifiers():
-            loc = rbnf.RuleBasedNumberFormat.negotiate(lid)._locale
-            if loc is None:
+            try:
+                loc = rbnf.RuleBasedNumberFormat.negotiate(lid)._locale
+            except rbnf.RulesetNotFound:
                 # generate warning if necessary
-                pass
-            else:
-                # test groups
-                for k in loc._data['rbnf_rules']:
-                    assert k in rbnf.RuleBasedNumberFormat.group_types
+                continue
+            # test groups
+            for k in loc._data['rbnf_rules']:
+                assert k in rbnf.RuleBasedNumberFormat.group_types
 
     def test_tokenization(self):
 
@@ -81,7 +81,7 @@ def _spell(x):
 
     def test_hu_HU_ordinal(self):
         def _spell(x):
-            return numbers.spell_number(x, locale='hu_HU', ordinal=True).replace(soft_hyphen, '')
+            return numbers.spell_number(x, locale='hu_HU', ruleset="ordinal").replace(soft_hyphen, '')
 
         assert _spell(0) == "nulla"
         # assert _spell(0) == "nulladik"
@@ -120,7 +120,7 @@ def _spell(x):
 
     def test_en_GB_ordinal(self):
         def _spell(x):
-            return numbers.spell_number(x, locale='en_GB', ordinal=True).replace(soft_hyphen, '')
+            return numbers.spell_number(x, locale='en_GB', ruleset="ordinal").replace(soft_hyphen, '')
 
         assert _spell(0) == "zeroth"
         assert _spell(1) == "first"