Fix Bulgarian TimeSpan to words & genders in number to words (#1460)

src/Humanizer.Tests/Localisation/bg/NumberToWordsTests.cs

@@ -37,15 +37,21 @@ public class NumberToWordsTests
     [InlineData(111, "сто и единадесет")]
     [InlineData(55, "петдесет и пет")]
     [InlineData(555, "петстотин петдесет и пет")]
+    [InlineData(1000, "една хиляда")]
+    [InlineData(2000, "две хиляди")]
     [InlineData(4213, "четири хиляди двеста и тринадесет")]
     [InlineData(5000, "пет хиляди")]
     [InlineData(28205, "двадесет и осем хиляди двеста и пет")]
     [InlineData(35000, "тридесет и пет хиляди")]
     [InlineData(352192, "триста петдесет и две хиляди сто деветдесет и две")]
+    [InlineData(1000000, "един милион")]
+    [InlineData(2000000, "два милиона")]
     [InlineData(4000210, "четири милиона двеста и десет")]
     [InlineData(5200, "пет хиляди и двеста")]
     [InlineData(1125000, "един милион и сто двадесет и пет хиляди")]
     [InlineData(1000000000, "един милиард")]
+    [InlineData(2000000000, "два милиарда")]
+    [InlineData(3000000000, "три милиарда")]
     public void ToWordsBg(long number, string expected) =>
         Assert.Equal(expected, number.ToWords());
 
@@ -79,6 +85,19 @@ public void ToWordsBg(long number, string expected) =>
     [InlineData(21, "двадесет и първи")]
     [InlineData(22, "двадесет и втори")]
     [InlineData(35, "тридесет и пети")]
+    [InlineData(100, "стотен")]
+    [InlineData(111, "сто и единадесети")]
+    [InlineData(200, "двестотен")]
+    [InlineData(300, "тристотен")]
+    [InlineData(1000, "една хиляден")]
+    [InlineData(1111, "една хиляда сто и единадесети")]
+    [InlineData(10000, "десет хиляден")]
+    [InlineData(12345, "дванадесет хиляди триста четиридесет и пети")]
+    [InlineData(12000, "дванадесет хиляден")]
+    [InlineData(100000, "сто хиляден")]
+    [InlineData(101111, "сто и една хиляда сто и единадесети")]
+    [InlineData(1000000, "един милионен")]
+    [InlineData(2000000, "два милионен")]
     public void ToOrdinalWordsMasculine(int number, string expected) =>
         Assert.Equal(expected, number.ToOrdinalWords(GrammaticalGender.Masculine));
 
@@ -112,6 +131,19 @@ public void ToOrdinalWordsMasculine(int number, string expected) =>
     [InlineData(21, "двадесет и първа")]
     [InlineData(22, "двадесет и втора")]
     [InlineData(35, "тридесет и пета")]
+    [InlineData(100, "стотна")]
+    [InlineData(111, "сто и единадесета")]
+    [InlineData(200, "двестотна")]
+    [InlineData(300, "тристотна")]
+    [InlineData(1000, "една хилядна")]
+    [InlineData(1111, "една хиляда сто и единадесета")]
+    [InlineData(10000, "десет хилядна")]
+    [InlineData(12345, "дванадесет хиляди триста четиридесет и пета")]
+    [InlineData(12000, "дванадесет хилядна")]
+    [InlineData(100000, "сто хилядна")]
+    [InlineData(101111, "сто и една хиляда сто и единадесета")]
+    [InlineData(1000000, "един милионна")]
+    [InlineData(2000000, "два милионна")]
     public void ToOrdinalWordsFeminine(int number, string expected) =>
         Assert.Equal(expected, number.ToOrdinalWords(GrammaticalGender.Feminine));
 
@@ -145,6 +177,19 @@ public void ToOrdinalWordsFeminine(int number, string expected) =>
     [InlineData(21, "двадесет и първо")]
     [InlineData(22, "двадесет и второ")]
     [InlineData(35, "тридесет и пето")]
+    [InlineData(100, "стотно")]
+    [InlineData(111, "сто и единадесето")]
+    [InlineData(200, "двестотно")]
+    [InlineData(300, "тристотно")]
+    [InlineData(1000, "една хилядно")]
+    [InlineData(1111, "една хиляда сто и единадесето")]
+    [InlineData(10000, "десет хилядно")]
+    [InlineData(12345, "дванадесет хиляди триста четиридесет и пето")]
+    [InlineData(12000, "дванадесет хилядно")]
+    [InlineData(100000, "сто хилядно")]
+    [InlineData(101111, "сто и една хиляда сто и единадесето")]
+    [InlineData(1000000, "един милионно")]
+    [InlineData(2000000, "два милионно")]
     public void ToOrdinalWordsNeuter(int number, string expected) =>
         Assert.Equal(expected, number.ToOrdinalWords(GrammaticalGender.Neuter));
 }

src/Humanizer.Tests/Localisation/bg/TimeSpanHumanizeTests.cs

@@ -5,7 +5,7 @@ public class TimeSpanHumanizeTests
 {
     [Theory]
     [Trait("Translation", "Google")]
-    [InlineData(366, "една година")]
+    [InlineData(366, "1 година")]
     [InlineData(731, "2 години")]
     [InlineData(1096, "3 години")]
     [InlineData(4018, "11 години")]
@@ -14,49 +14,104 @@ public void Years(int days, string expected) =>
 
     [Theory]
     [Trait("Translation", "Google")]
-    [InlineData(31, "един месец")]
+    [InlineData(366, "една година")]
+    [InlineData(731, "две години")]
+    [InlineData(1096, "три години")]
+    [InlineData(4018, "единадесет години")]
+    // [InlineData(7671, "двадесет и една година")]
+    public void YearsToWords(int days, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: true));
+
+    [Theory]
+    [Trait("Translation", "Google")]
+    [InlineData(31, "1 месец")]
     [InlineData(61, "2 месеца")]
     [InlineData(92, "3 месеца")]
     [InlineData(335, "11 месеца")]
     public void Months(int days, string expected) =>
         Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year));
 
     [Theory]
-    [InlineData(7, "една седмица")]
+    [Trait("Translation", "Google")]
+    [InlineData(31, "един месец")]
+    [InlineData(61, "два месеца")]
+    [InlineData(92, "три месеца")]
+    [InlineData(335, "единадесет месеца")]
+    public void MonthsToWords(int days, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Month, toWords: true));
+
+    [Theory]
+    [InlineData(7, "1 седмица")]
     [InlineData(14, "2 седмици")]
     public void Weeks(int days, string expected) =>
         Assert.Equal(expected, TimeSpan.FromDays(days).Humanize());
 
     [Theory]
-    [InlineData(1, "един ден")]
+    [InlineData(7, "една седмица")]
+    [InlineData(14, "две седмици")]
+    public void WeeksToWords(int days, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: true));
+
+    [Theory]
+    [InlineData(1, "1 ден")]
     [InlineData(2, "2 дена")]
     public void Days(int days, string expected) =>
         Assert.Equal(expected, TimeSpan.FromDays(days).Humanize());
 
     [Theory]
-    [InlineData(1, "един час")]
+    [InlineData(1, "един ден")]
+    [InlineData(2, "два дена")]
+    public void DaysToWords(int days, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: true));
+
+    [Theory]
+    [InlineData(1, "1 час")]
     [InlineData(2, "2 часа")]
     public void Hours(int hours, string expected) =>
         Assert.Equal(expected, TimeSpan.FromHours(hours).Humanize());
 
     [Theory]
-    [InlineData(1, "една минута")]
+    [InlineData(1, "един час")]
+    [InlineData(2, "два часа")]
+    public void HoursToWords(int hours, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromHours(hours).Humanize(toWords: true));
+
+    [Theory]
+    [InlineData(1, "1 минута")]
     [InlineData(2, "2 минути")]
     public void Minutes(int minutes, string expected) =>
         Assert.Equal(expected, TimeSpan.FromMinutes(minutes).Humanize());
 
     [Theory]
-    [InlineData(1, "една секунда")]
+    [InlineData(1, "една минута")]
+    [InlineData(2, "две минути")]
+    public void MinutesToWords(int minutes, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromMinutes(minutes).Humanize(toWords: true));
+
+    [Theory]
+    [InlineData(1, "1 секунда")]
     [InlineData(2, "2 секунди")]
     public void Seconds(int seconds, string expected) =>
         Assert.Equal(expected, TimeSpan.FromSeconds(seconds).Humanize());
 
     [Theory]
-    [InlineData(1, "една милисекунда")]
+    [InlineData(1, "една секунда")]
+    [InlineData(2, "две секунди")]
+    public void SecondsToWords(int seconds, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromSeconds(seconds).Humanize(toWords: true));
+
+    [Theory]
+    [InlineData(1, "1 милисекунда")]
     [InlineData(2, "2 милисекунди")]
     public void Milliseconds(int milliseconds, string expected) =>
         Assert.Equal(expected, TimeSpan.FromMilliseconds(milliseconds).Humanize());
 
+    [Theory]
+    [InlineData(1, "една милисекунда")]
+    [InlineData(2, "две милисекунди")]
+    public void MillisecondsToWords(int milliseconds, string expected) =>
+        Assert.Equal(expected, TimeSpan.FromMilliseconds(milliseconds).Humanize(toWords: true));
+
     [Fact]
     public void NoTime() =>
         // This one doesn't make a lot of sense but ... w/e

src/Humanizer/Configuration/FormatterRegistry.cs

@@ -20,7 +20,7 @@ public FormatterRegistry()
         RegisterCzechSlovakPolishFormatter("cs");
         RegisterCzechSlovakPolishFormatter("pl");
         RegisterCzechSlovakPolishFormatter("sk");
-        RegisterDefaultFormatter("bg");
+        Register("bg", new BulgarianFormatter());
         RegisterDefaultFormatter("ku");
         RegisterDefaultFormatter("pt");
         RegisterDefaultFormatter("sv");

src/Humanizer/Localisation/Formatters/BulgarianFormatter.cs

@@ -0,0 +1,14 @@
+namespace Humanizer;
+
+class BulgarianFormatter() : DefaultFormatter("bg")
+{
+    protected override string NumberToWords(TimeUnit unit, int number, CultureInfo culture) =>
+        number.ToWords(GetUnitGender(unit), culture);
+
+    static GrammaticalGender GetUnitGender(TimeUnit unit) =>
+        unit switch
+        {
+            TimeUnit.Hour or TimeUnit.Day or TimeUnit.Month => GrammaticalGender.Masculine,
+            _ => GrammaticalGender.Feminine
+        };
+}