Implement between length validator

Author: ArturAssisComp

lib/new_api_prototype/collection_validators.dart

@@ -61,6 +61,50 @@ Validator<T> maxLength<T extends Object>(int maxLength,
   };
 }
 
+/// Temporary error message for `betweenLength` validator.
+String betweenLengthTemporaryErrorMessage(
+        {required int min, required int max}) =>
+    'Value must have a length that is between $min and $max, inclusive';
+
+/// Returns a [Validator] function that checks if its input has a length that is
+/// between `minLength` and `maxLength`, inclusive. If the input satisfies this
+/// condition, the validator returns `null`. Otherwise, it returns the default
+/// error message
+/// `FormBuilderLocalizations.current.betweenLengthErrorText(minLength, maxLength)`,
+/// if [betweenLengthMsg] is not provided.
+///
+/// # Caveats
+/// - Objects that are not collections are considered as collections with
+/// length 1.
+///
+/// # Errors
+/// - Throws [AssertionError] if `minLength` or `maxLength` are negative.
+/// - Throws [AssertionError] if `maxLength` is less than `minLength`.
+Validator<T> betweenLength<T extends Object>(
+  int minLength,
+  int maxLength, {
+  String Function({required int min, required int max})? betweenLengthMsg,
+}) {
+  assert(minLength >= 0, 'The "minLength" parameter may not be negative');
+  assert(maxLength >= minLength,
+      'The "maxLength" parameter must be greater than or equal to "minLength"');
+  return (T value) {
+    // I think it makes more sense to say that scalar objects has length 1 instead of 0.
+    int valueLength = 1;
+
+    if (value is String) valueLength = value.length;
+    if (value is Iterable) valueLength = value.length;
+    if (value is Map) valueLength = value.length;
+
+    return (valueLength < minLength || valueLength > maxLength)
+        ? betweenLengthMsg?.call(min: minLength, max: maxLength) ??
+            // TODO (ArturAssisComp): add the translated version of this message
+            // FormBuilderLocalizations.current.betweenLengthErrorText(maxLength)
+            betweenLengthTemporaryErrorMessage(min: minLength, max: maxLength)
+        : null;
+  };
+}
+
 /// Returns a [Validator] function that checks if its input has the length equals
 /// to the provided positional parameter `length`. If the input satisfies this
 /// condition, the validator returns `null`. Otherwise, it returns the default

lib/new_api_prototype/generic_type_validators.dart

@@ -60,7 +60,7 @@ Validator<T> isEqual<T extends Object?>(T value,
 /// ```
 Validator<T> isTrue<T extends Object>(
     {String? isTrueMsg, bool caseSensitive = false, bool trim = true}) {
-  return (value) {
+  return (T value) {
     final (isValid, typeTransformedValue) = _isBoolValidateAndConvert(
       value,
       caseSensitive: caseSensitive,
@@ -100,7 +100,7 @@ Validator<T> isTrue<T extends Object>(
 /// ```
 Validator<T> isFalse<T extends Object>(
     {String? isFalseMsg, bool caseSensitive = false, bool trim = true}) {
-  return (value) {
+  return (T value) {
     final (isValid, typeTransformedValue) = _isBoolValidateAndConvert(
       value,
       caseSensitive: caseSensitive,

test/new_api_testing/collection_validators/between_length_validator_test.dart

@@ -0,0 +1,69 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:form_builder_validators/form_builder_validators.dart';
+
+void main() {
+  group('Validator: betweenLength', () {
+    group('Validators with default error message', () {
+      test(
+          'Should validate the input when it is expected to have minLength equals to maxLength',
+          () {
+        final Validator<List<int>> v = betweenLength(0, 0);
+        final Validator<Object> v2 = betweenLength(3, 3);
+
+        expect(v(<int>[]), isNull);
+        expect(
+            v(<int>[12]), betweenLengthTemporaryErrorMessage(min: 0, max: 0));
+        expect(v2(<int>[12, 23, 456]), isNull);
+        expect(v2(12), betweenLengthTemporaryErrorMessage(min: 3, max: 3));
+      });
+      test(
+          'Should validate the input when it is expected to have minLength 1 and maxLength 5',
+          () {
+        final Validator<List<int>> v = betweenLength(1, 5);
+        final Validator<Object> v2 = betweenLength(1, 5);
+
+        expect(v(<int>[]), betweenLengthTemporaryErrorMessage(min: 1, max: 5));
+        expect(v(<int>[0]), isNull);
+        expect(v(<int>[0, 1]), isNull);
+        expect(v(<int>[0, 2, 3]), isNull);
+        expect(v(<int>[23, 432, 52, 65, 1]), isNull);
+        expect(v(<int>[1, 2, 3, 4, 5, 6]),
+            betweenLengthTemporaryErrorMessage(min: 1, max: 5));
+        expect(v(<int>[1, 2, 3, 4, 5, 6, 7]),
+            betweenLengthTemporaryErrorMessage(min: 1, max: 5));
+
+        expect(v2(<int>[]), betweenLengthTemporaryErrorMessage(min: 1, max: 5));
+        expect(v2(''), betweenLengthTemporaryErrorMessage(min: 1, max: 5));
+        expect(v2(<String>['0']), isNull);
+        expect(v2(0), isNull);
+        expect(v2(<Object>[1, '3']), isNull);
+        expect(v2('hi '), isNull);
+        expect(
+            v2('      '), betweenLengthTemporaryErrorMessage(min: 1, max: 5));
+      });
+    });
+
+    test('Should validate input returning custom message error when invalid',
+        () {
+      const String customMsg = 'custom msg';
+      final Validator<Object> v = betweenLength(3, 4,
+          betweenLengthMsg: ({required int min, required int max}) =>
+              customMsg);
+
+      expect(v(89), equals(customMsg));
+      expect(v(<Object>[1, '2', 3, 4]), isNull);
+      expect(v('   '), isNull);
+    });
+    group('Throws assertion error', () {
+      test('Should throw AssertionError when minLength is negative', () {
+        expect(() => betweenLength(-2, 3), throwsAssertionError);
+        expect(() => betweenLength(-2, -3), throwsAssertionError);
+      });
+      test('Should throw AssertionError when maxLength is less than minLength',
+          () {
+        expect(() => betweenLength(3, 2), throwsAssertionError);
+        expect(() => betweenLength(3, -2), throwsAssertionError);
+      });
+    });
+  });
+}