feat: Add Brazilian Portuguese (pt_BR) and UntilDateFormat

lib/src/codecs/text/encoder.dart

@@ -1,6 +1,7 @@
 import 'dart:convert';
 
 import 'package:collection/collection.dart';
+import 'package:intl/intl.dart';
 import 'package:meta/meta.dart';
 
 import '../../by_week_day_entry.dart';
@@ -11,9 +12,10 @@ import 'l10n/l10n.dart';
 
 @immutable
 class RecurrenceRuleToTextEncoder extends Converter<RecurrenceRule, String> {
-  const RecurrenceRuleToTextEncoder(this.l10n);
+  const RecurrenceRuleToTextEncoder(this.l10n, {this.untilDateFormat});
 
   final RruleL10n l10n;
+  final DateFormat? untilDateFormat;
 
   @override
   String convert(RecurrenceRule input) {
@@ -52,7 +54,7 @@ class RecurrenceRuleToTextEncoder extends Converter<RecurrenceRule, String> {
     }
 
     if (input.until != null) {
-      output.write(l10n.until(input.until!, input.frequency));
+      output.write(l10n.until(input.until!, input.frequency, dateFormat: untilDateFormat));
     } else if (input.count != null) {
       output.write(l10n.count(input.count!));
     }

lib/src/codecs/text/l10n/en.dart

@@ -41,9 +41,9 @@ class RruleL10nEn extends RruleL10n {
   }
 
   @override
-  String until(DateTime until, Frequency frequency) {
+  String until(DateTime until, Frequency frequency, {DateFormat? dateFormat}) {
     final untilString =
-        formatWithIntl(() => DateFormat.yMMMMEEEEd().add_jms().format(until));
+        formatWithIntl(() => dateFormat?.format(until) ?? DateFormat.yMMMMEEEEd().add_jms().format(until));
     return ', until $untilString';
   }
 

lib/src/codecs/text/l10n/l10n.dart

@@ -8,6 +8,7 @@ import 'en.dart';
 
 export 'en.dart';
 export 'nl.dart';
+export 'pt_BR.dart';
 
 /// Contains localized strings used by [RecurrenceRule.toText].
 ///
@@ -21,7 +22,7 @@ abstract class RruleL10n {
       Intl.withLocale(locale, formatter) as String;
 
   String frequencyInterval(Frequency frequency, int interval);
-  String until(DateTime until, Frequency frequency);
+  String until(DateTime until, Frequency frequency, {DateFormat? dateFormat});
   String count(int count);
   String range(String start, String end) => '$start – $end';
 

lib/src/codecs/text/l10n/nl.dart

@@ -39,9 +39,9 @@ class RruleL10nNl extends RruleL10n {
   }
 
   @override
-  String until(DateTime until, Frequency frequency) {
+  String until(DateTime until, Frequency frequency, {DateFormat? dateFormat}) {
     final untilString = formatWithIntl(
-      () => DateFormat("EEEE d MMMM yyyy 'om' H:mm 'uur'", 'nl').format(until),
+      () => dateFormat?.format(until) ?? DateFormat("EEEE d MMMM yyyy 'om' H:mm 'uur'", 'nl').format(until),
     );
     return ', tot $untilString';
   }

lib/src/codecs/text/l10n/pt_BR.dart

@@ -0,0 +1,195 @@
+import 'package:intl/date_symbol_data_local.dart';
+import 'package:intl/intl.dart';
+import 'package:meta/meta.dart';
+
+import '../../../frequency.dart';
+import 'l10n.dart';
+
+@immutable
+class RruleL10nPtBr extends RruleL10n {
+  const RruleL10nPtBr._();
+
+  static Future<RruleL10nPtBr> create() async {
+    // TODO(JonasWanke): Move `initializeDateFormatting(…)` call to the
+    // library's user
+    await initializeDateFormatting('pt_BR');
+    return const RruleL10nPtBr._();
+  }
+
+  @override
+  String get locale => 'pt_BR';
+
+  @override
+  String frequencyInterval(Frequency frequency, int interval) {
+    String plurals({required String one, required String singular}) {
+      if (frequency == Frequency.monthly) {
+        return switch (interval) {
+          1 => one,
+          _ => 'A cada $interval meses',
+        };
+      }
+
+      return switch (interval) {
+        1 => one,
+        _ => 'A cada $interval ${singular}s',
+      };
+    }
+
+    return {
+      Frequency.secondly: plurals(one: 'A cada segundo', singular: 'segundo'),
+      Frequency.minutely: plurals(one: 'A cada minuto', singular: 'minuto'),
+      Frequency.hourly: plurals(one: 'A cada hora', singular: 'hora'),
+      Frequency.daily: plurals(one: 'Todos os dias', singular: 'dia'),
+      Frequency.weekly: plurals(one: 'Semanal:', singular: 'semana'),
+      Frequency.monthly: plurals(one: 'Mensal', singular: 'mês'),
+      Frequency.yearly: plurals(one: 'Anual:', singular: 'ano'),
+    }[frequency]!;
+  }
+
+  @override
+  String until(DateTime until, Frequency frequency, {DateFormat? dateFormat}) {
+    final untilString = formatWithIntl(() => 
+      dateFormat?.format(until) ?? DateFormat('d MMM y', 'pt_BR').format(until)
+    );
+    return ' até $untilString';
+  }
+
+  @override
+  String count(int count) {
+    return switch (count) {
+      1 => ', uma vez',
+      2 => ', duas vezes',
+      _ => ' $count vezes',
+    };
+  }
+
+  @override
+  String onInstances(String instances) => 'na $instances ocorrência';
+
+  @override
+  String inMonths(String months, {InOnVariant variant = InOnVariant.simple}) =>
+      '${_inVariant(variant)} $months';
+
+  @override
+  String inWeeks(String weeks, {InOnVariant variant = InOnVariant.simple}) =>
+      '${_inVariant(variant)} $weeks semana do ano';
+
+  String _inVariant(InOnVariant variant) {
+    return switch (variant) {
+      InOnVariant.simple => 'em',
+      InOnVariant.also => 'que também estão em',
+      InOnVariant.instanceOf => 'de',
+    };
+  }
+
+  @override
+  String onDaysOfWeek(
+    String days, {
+    bool indicateFrequency = false,
+    DaysOfWeekFrequency? frequency = DaysOfWeekFrequency.monthly,
+    InOnVariant variant = InOnVariant.simple,
+  }) {
+    assert(variant != InOnVariant.also);
+
+    final frequencyString = frequency == DaysOfWeekFrequency.monthly ? 'mês' : 'ano';
+    final suffix = indicateFrequency ? ' do $frequencyString' : '';
+
+    // Workaround: replace "toda sábado" with "todo sábado" and "toda domingo" with "todo domingo"
+    final modifiedDays = days
+        .replaceAll('toda sábado', 'todo sábado')
+        .replaceAll('toda domingo', 'todo domingo');
+
+    return '${_onVariant(variant, Frequency.weekly)} $modifiedDays$suffix';
+  }
+
+  @override
+  String? get weekdaysString => 'dias úteis';
+
+  @override
+  String get everyXDaysOfWeekPrefix => 'toda ';
+
+  @override
+  String nthDaysOfWeek(Iterable<int> occurrences, String daysOfWeek) {
+    if (occurrences.isEmpty) return daysOfWeek;
+
+    final ordinals = list(
+      occurrences.map(ordinal).toList(),
+      ListCombination.conjunctiveShort,
+    );
+
+    // Workaround: replace the feminine form "última" with the masculine "último" 
+    // when the first day of the week is Saturday or Sunday
+    final firstDay = daysOfWeek.split(',')[0].trim();
+    final modifiedOrdinals = (firstDay == 'sábado' || firstDay == 'domingo') 
+        ? ordinals.replaceAll('última', 'último') 
+        : ordinals;
+
+    return '$modifiedOrdinals $daysOfWeek';
+  }
+
+  @override
+  String onDaysOfMonth(
+    String days, {
+    DaysOfVariant daysOfVariant = DaysOfVariant.dayAndFrequency,
+    InOnVariant variant = InOnVariant.simple,
+  }) {
+    final suffix = {
+      DaysOfVariant.simple: ' dia',
+      DaysOfVariant.day: ' dia',
+      DaysOfVariant.dayAndFrequency: ' dia do mês',
+    }[daysOfVariant];
+
+    // Workaround: replace the feminine form "última" with the masculine "último" 
+    // when referring to the last day of the month.
+    final modifiedDays = days.endsWith('última') ? days.replaceAll('última', 'último') : days;
+    return '${_onVariant(variant, Frequency.monthly)} $modifiedDays$suffix';
+  }
+
+  @override
+  String onDaysOfYear(
+    String days, {
+    InOnVariant variant = InOnVariant.simple,
+  }) {
+    // Workaround: replace the feminine form "última" with the masculine "último" 
+    // when referring to the last day of the year.
+    final modifiedDays = days.endsWith('última') ? days.replaceAll('última', 'último') : days;
+    return '${_onVariant(variant, Frequency.yearly)} $modifiedDays dia do ano';
+  }
+
+  String _onVariant(InOnVariant variant, Frequency frequency) {
+    return switch (variant) {
+      InOnVariant.simple => frequency == Frequency.monthly ? 'no' : 'cada',
+      InOnVariant.also => 'que também são',
+      InOnVariant.instanceOf => 'de',
+    };
+  }
+
+  @override
+  String list(List<String> items, ListCombination combination) {
+    final (two, end) = switch (combination) {
+      ListCombination.conjunctiveShort => (' e ', ' e '),
+      ListCombination.conjunctiveLong => (' e ', ', e '),
+      ListCombination.disjunctive => (' ou ', ', ou '),
+    };
+    return RruleL10n.defaultList(items, two: two, end: end);
+  }
+
+  @override
+  String ordinal(int number) {
+    assert(number != 0);
+    if (number == -1) return 'última';
+
+    final n = number.abs();
+    String string;
+    if (n % 10 == 1 && n % 100 != 11) {
+      string = '${n}º';
+    } else if (n % 10 == 2 && n % 100 != 12) {
+      string = '${n}º';
+    } else if (n % 10 == 3 && n % 100 != 13) {
+      string = '${n}º';
+    } else {
+      string = '${n}º';
+    }
+    return number < 0 ? '${n}º última' : string;
+  }
+}

lib/src/recurrence_rule.dart

@@ -1,4 +1,5 @@
 import 'package:collection/collection.dart';
+import 'package:intl/intl.dart';
 import 'package:meta/meta.dart';
 
 import 'by_week_day_entry.dart';
@@ -334,14 +335,14 @@ class RecurrenceRule {
   /// Converts this rule to a human-readable string.
   ///
   /// This may only be called on rules that are fully convertable to text.
-  String toText({required RruleL10n l10n}) {
+  String toText({required RruleL10n l10n, DateFormat? untilDateFormat}) {
     assert(
       canFullyConvertToText,
       "This recurrence rule can't fully be converted to text. See "
       '[RecurrenceRule.canFullyConvertToText] for more information.',
     );
 
-    return RecurrenceRuleToTextEncoder(l10n).convert(this);
+    return RecurrenceRuleToTextEncoder(l10n, untilDateFormat: untilDateFormat).convert(this);
   }
 
   /// Converts this rule to a machine-readable, RFC-7265-compliant string.