feat!: support ignores commit messages

Author: hyiso

lib/src/is_ignored.dart

@@ -0,0 +1,22 @@
+bool isIgnored(String message,
+    {bool? defaultIgnores, Iterable<String>? ignores}) {
+  final base = defaultIgnores == false ? [] : wildcards;
+  return [...base, ...?ignores?.map(ignore)].any((mathcer) => mathcer(message));
+}
+
+final wildcards = [
+  ignore(
+      r'((Merge pull request)|(Merge (.*?) into (.*?)|(Merge branch (.*?)))(?:\r?\n)*$)'),
+  ignore(r'(Merge tag (.*?))(?:\r?\n)*$'),
+  ignore(r'(R|r)evert (.*)'),
+  ignore(r'(fixup|squash)!'),
+  ignore(r'(Merged (.*?)(in|into) (.*)|Merged PR (.*): (.*))'),
+  ignore(r'Merge remote-tracking branch(\s*)(.*)'),
+  ignore(r'Automatic merge(.*)'),
+  ignore(r'Auto-merged (.*?) into (.*)'),
+];
+
+Matcher ignore(String pattern) =>
+    (String message) => RegExp(pattern).hasMatch(message);
+
+typedef Matcher = bool Function(String);

lib/src/lint.dart

@@ -1,3 +1,4 @@
+import 'is_ignored.dart';
 import 'parse.dart';
 import 'rules.dart';
 import 'types/commit.dart';
@@ -7,12 +8,18 @@ import 'types/rule.dart';
 ///
 /// Lint commit [message] with configured [rules]
 ///
-Future<LintOutcome> lint(String message, Map<String, RuleConfig> rules) async {
-  // Parse the commit message
+Future<LintOutcome> lint(String message, Map<String, Rule> rules,
+    {bool? defaultIgnores, Iterable<String>? ignores}) async {
+  /// Found a wildcard match, skip
+  if (isIgnored(message, defaultIgnores: defaultIgnores, ignores: ignores)) {
+    return LintOutcome(input: message, valid: true, errors: [], warnings: []);
+  }
+
+  /// Parse the commit message
   final commit = message.isEmpty ? Commit.empty() : parse(message);
 
   if (commit.header.isEmpty && commit.body == null && commit.footer == null) {
-    // Commit is empty, skip
+    /// Commit is empty, skip
     return LintOutcome(input: message, valid: true, errors: [], warnings: []);
   }
   final allRules = Map.of(supportedRules);
@@ -28,7 +35,7 @@ Future<LintOutcome> lint(String message, Map<String, RuleConfig> rules) async {
   /// Validate against all rules
   final results = rules.entries
       // Level 0 rules are ignored
-      .where((entry) => entry.value.severity != RuleConfigSeverity.ignore)
+      .where((entry) => entry.value.severity != RuleSeverity.ignore)
       .map((entry) {
         final name = entry.key;
         final config = entry.value;
@@ -49,9 +56,9 @@ Future<LintOutcome> lint(String message, Map<String, RuleConfig> rules) async {
       .where((outcome) => !outcome.valid)
       .toList();
   final errors =
-      results.where((element) => element.level == RuleConfigSeverity.error);
+      results.where((element) => element.level == RuleSeverity.error);
   final warnings =
-      results.where((element) => element.level == RuleConfigSeverity.warning);
+      results.where((element) => element.level == RuleSeverity.warning);
   return LintOutcome(
     input: message,
     valid: errors.isEmpty,

lib/src/load.dart

@@ -5,117 +5,117 @@ import 'package:path/path.dart';
 import 'package:yaml/yaml.dart';
 
 import 'types/case.dart';
+import 'types/commitlint.dart';
 import 'types/rule.dart';
 
 ///
-/// Load configured rules in given [file] from given [dir].
+/// Load configured rules in given [path] from given [directory].
 ///
-Future<Map<String, RuleConfig>> load({
-  required String file,
-  String? dir,
+Future<CommitLint> load(
+  String path, {
+  Directory? directory,
 }) async {
-  Map<String, RuleConfig> rules = {};
-  Uri? uri;
-  if (!file.startsWith('package:')) {
-    uri = toUri(join(dir ?? Directory.current.path, file));
-    dir = dirname(uri.path);
+  File? file;
+  if (!path.startsWith('package:')) {
+    final uri = toUri(join(directory?.path ?? Directory.current.path, path));
+    file = File.fromUri(uri);
   } else {
-    uri = await Isolate.resolvePackageUri(Uri.parse(file));
-    dir = uri?.path.split('/lib/').first;
+    final uri = await Isolate.resolvePackageUri(Uri.parse(path));
+    if (uri != null) {
+      file = File.fromUri(uri);
+    }
   }
-  if (uri != null) {
-    final file = File.fromUri(uri);
-    if (await file.exists()) {
-      final yaml = loadYaml(await file.readAsString());
-      final include = yaml?['include'] as String?;
-      final rulesMap = yaml?['rules'] as Map?;
-      if (rulesMap != null) {
-        for (var entry in rulesMap.entries) {
-          rules[entry.key] = _extractRuleConfig(entry.value);
-        }
-      }
-      if (include != null) {
-        final upstream = await load(dir: dir, file: include);
-        if (upstream.isNotEmpty) {
-          rules = {
-            ...upstream,
-            ...rules,
-          };
-        }
+  if (file != null && file.existsSync()) {
+    final yaml = loadYaml(await file.readAsString());
+    final include = yaml?['include'] as String?;
+    final rulesMap = yaml?['rules'] as Map?;
+    Map<String, Rule> rules = {};
+    if (rulesMap != null) {
+      for (var entry in rulesMap.entries) {
+        rules[entry.key] = _extractRule(entry.value);
       }
     }
+    final config = CommitLint(
+        rules: rules,
+        deafultIgnores: yaml?['deafultIgnores'] as bool?,
+        ignores: yaml?['ignores'] as Iterable<String>?);
+    if (include != null) {
+      final upstream = await load(include, directory: file.parent);
+      return config.inherit(upstream);
+    }
+    return config;
   }
-  return rules;
+  return CommitLint();
 }
 
-RuleConfig _extractRuleConfig(dynamic config) {
+Rule _extractRule(dynamic config) {
   if (config is! List) {
     throw Exception('rule config must be list, but get $config');
   }
   if (config.isEmpty || config.length < 2 || config.length > 3) {
     throw Exception(
         'rule config must contain at least two, at most three items.');
   }
-  final severity = _extractRuleConfigSeverity(config.first as int);
-  final condition = _extractRuleConfigCondition(config.elementAt(1) as String);
+  final severity = _extractRuleSeverity(config.first as int);
+  final condition = _extractRuleCondition(config.elementAt(1) as String);
   dynamic value;
   if (config.length == 3) {
     value = config.last;
   }
   if (value == null) {
-    return RuleConfig(severity: severity, condition: condition);
+    return Rule(severity: severity, condition: condition);
   }
   if (value is num) {
-    return LengthRuleConfig(
+    return LengthRule(
       severity: severity,
       condition: condition,
       length: value,
     );
   }
   if (value is String) {
     if (value.endsWith('-case')) {
-      return CaseRuleConfig(
+      return CaseRule(
         severity: severity,
         condition: condition,
         type: _extractCase(value),
       );
     } else {
-      return ValueRuleConfig(
+      return ValueRule(
         severity: severity,
         condition: condition,
         value: value,
       );
     }
   }
   if (value is List) {
-    return EnumRuleConfig(
+    return EnumRule(
       severity: severity,
       condition: condition,
       allowed: value.cast(),
     );
   }
-  return ValueRuleConfig(
+  return ValueRule(
     severity: severity,
     condition: condition,
     value: value,
   );
 }
 
-RuleConfigSeverity _extractRuleConfigSeverity(int severity) {
-  if (severity < 0 || severity > RuleConfigSeverity.values.length - 1) {
+RuleSeverity _extractRuleSeverity(int severity) {
+  if (severity < 0 || severity > RuleSeverity.values.length - 1) {
     throw Exception(
-        'rule severity can only be 0..${RuleConfigSeverity.values.length - 1}');
+        'rule severity can only be 0..${RuleSeverity.values.length - 1}');
   }
-  return RuleConfigSeverity.values[severity];
+  return RuleSeverity.values[severity];
 }
 
-RuleConfigCondition _extractRuleConfigCondition(String condition) {
-  var allowed = RuleConfigCondition.values.map((e) => e.name).toList();
+RuleCondition _extractRuleCondition(String condition) {
+  var allowed = RuleCondition.values.map((e) => e.name).toList();
   final index = allowed.indexOf(condition);
   if (index == -1) {
     throw Exception('rule condition can only one of $allowed');
   }
-  return RuleConfigCondition.values[index];
+  return RuleCondition.values[index];
 }
 
 Case _extractCase(String name) {

lib/src/rules.dart

@@ -3,7 +3,7 @@ import 'types/case.dart';
 import 'types/commit.dart';
 import 'types/rule.dart';
 
-Map<String, Rule> get supportedRules => {
+Map<String, RuleFunction> get supportedRules => {
       'type-case': caseRule(CommitComponent.type),
       'type-empty': emptyRule(CommitComponent.type),
       'type-enum': enumRule(CommitComponent.type),
@@ -39,14 +39,14 @@ Map<String, Rule> get supportedRules => {
     };
 
 /// Build full stop rule for commit component.
-Rule fullStopRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
-    if (config is! ValueRuleConfig) {
+RuleFunction fullStopRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
+    if (config is! ValueRule) {
       throw Exception('$config is not ValueRuleConfig<String>');
     }
     final raw = commit.componentRaw(component);
     final result = raw != null && ensureFullStop(raw, config.value);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message: [
@@ -59,11 +59,11 @@ Rule fullStopRule(CommitComponent component) {
 }
 
 /// Build leanding blank rule for commit component.
-Rule leadingBlankRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
+RuleFunction leadingBlankRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
     final raw = commit.componentRaw(component);
     final result = raw != null && ensureLeadingBlank(raw);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message: [
@@ -76,11 +76,11 @@ Rule leadingBlankRule(CommitComponent component) {
 }
 
 /// Build leanding blank rule for commit component.
-Rule emptyRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
+RuleFunction emptyRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
     final raw = commit.componentRaw(component);
     final result = ensureEmpty(raw);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message:
@@ -90,14 +90,14 @@ Rule emptyRule(CommitComponent component) {
 }
 
 /// Build case rule for commit component.
-Rule caseRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
-    if (config is! CaseRuleConfig) {
+RuleFunction caseRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
+    if (config is! CaseRule) {
       throw Exception('$config is not CaseRuleConfig');
     }
     final raw = commit.componentRaw(component);
     final result = raw != null && ensureCase(raw, config.type);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message: [
@@ -110,14 +110,14 @@ Rule caseRule(CommitComponent component) {
 }
 
 /// Build max length rule for commit component.
-Rule maxLengthRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
-    if (config is! LengthRuleConfig) {
+RuleFunction maxLengthRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
+    if (config is! LengthRule) {
       throw Exception('$config is not LengthRuleConfig');
     }
     final raw = commit.componentRaw(component);
     final result = raw != null && ensureMaxLength(raw, config.length);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message: [
@@ -130,14 +130,14 @@ Rule maxLengthRule(CommitComponent component) {
 }
 
 /// Build max line length rule for commit component.
-Rule maxLineLengthRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
-    if (config is! LengthRuleConfig) {
+RuleFunction maxLineLengthRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
+    if (config is! LengthRule) {
       throw Exception('$config is not LengthRuleConfig');
     }
     final raw = commit.componentRaw(component);
     final result = raw != null && ensureMaxLineLength(raw, config.length);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message: [
@@ -150,14 +150,14 @@ Rule maxLineLengthRule(CommitComponent component) {
 }
 
 /// Build min length rule for commit component.
-Rule minLengthRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
-    if (config is! LengthRuleConfig) {
+RuleFunction minLengthRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
+    if (config is! LengthRule) {
       throw Exception('$config is not LengthRuleConfig');
     }
     final raw = commit.componentRaw(component);
     final result = raw != null && ensureMinLength(raw, config.length);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message: [
@@ -169,14 +169,14 @@ Rule minLengthRule(CommitComponent component) {
   };
 }
 
-Rule enumRule(CommitComponent component) {
-  return (Commit commit, RuleConfig config) {
-    if (config is! EnumRuleConfig) {
+RuleFunction enumRule(CommitComponent component) {
+  return (Commit commit, Rule config) {
+    if (config is! EnumRule) {
       throw Exception('$config is not EnumRuleConfig');
     }
     final raw = commit.componentRaw(component);
     final result = ensureEnum(raw, config.allowed);
-    final negated = config.condition == RuleConfigCondition.never;
+    final negated = config.condition == RuleCondition.never;
     return RuleOutcome(
       valid: negated ? !result : result,
       message: [

lib/src/runner.dart

@@ -44,10 +44,11 @@ class CommitLintRunner extends CommandRunner {
     bool fromStdin = from == null && to == null && edit == null;
     final messages =
         fromStdin ? await _stdin() : await read(from: from, to: to, edit: edit);
-    final rules = await load(file: topLevelResults['config']);
-    final results = (await Future.wait(
-        messages.map((message) async => await lint(message, rules))));
-    if (rules.isEmpty) {
+    final config = await load(topLevelResults['config']);
+    final results = (await Future.wait(messages.map((message) async =>
+        await lint(message, config.rules,
+            defaultIgnores: config.deafultIgnores, ignores: config.ignores))));
+    if (config.rules.isEmpty) {
       String input = '';
       if (results.isNotEmpty) {
         input = results.first.input;
@@ -58,7 +59,7 @@ class CommitLintRunner extends CommandRunner {
           valid: false,
           errors: [
             LintRuleOutcome(
-              level: RuleConfigSeverity.error,
+              level: RuleSeverity.error,
               valid: false,
               name: 'empty-rules',
               message: [

lib/src/types/commitlint.dart

@@ -0,0 +1,25 @@
+import 'rule.dart';
+
+class CommitLint {
+  CommitLint({this.rules = const {}, this.deafultIgnores, this.ignores});
+
+  final Map<String, Rule> rules;
+
+  final bool? deafultIgnores;
+
+  final Iterable<String>? ignores;
+
+  CommitLint inherit(CommitLint other) {
+    return CommitLint(
+      rules: {
+        ...other.rules,
+        ...rules,
+      },
+      deafultIgnores: other.deafultIgnores ?? deafultIgnores,
+      ignores: [
+        ...?other.ignores,
+        ...?ignores,
+      ],
+    );
+  }
+}

lib/src/types/lint.dart

@@ -26,7 +26,7 @@ class LintRuleOutcome {
   final bool valid;
 
   /// The "severity" of the rule (0 = ignore, 1 = warning, 2 = error)
-  final RuleConfigSeverity level;
+  final RuleSeverity level;
 
   /// The name of the rule
   final String name;

lib/src/types/rule.dart

@@ -2,22 +2,22 @@ import 'case.dart';
 import 'commit.dart';
 
 /// 0 disables the rule. For 1 it will be considered a warning for 2 an error
-enum RuleConfigSeverity {
+enum RuleSeverity {
   ignore,
   warning,
   error,
 }
 
-enum RuleConfigCondition {
+enum RuleCondition {
   always,
   never,
 }
 
-class RuleConfig {
-  final RuleConfigSeverity severity;
-  final RuleConfigCondition condition;
+class Rule {
+  final RuleSeverity severity;
+  final RuleCondition condition;
 
-  RuleConfig({
+  Rule({
     required this.severity,
     required this.condition,
   });
@@ -30,47 +30,47 @@ class RuleOutcome {
   RuleOutcome({required this.valid, required this.message});
 }
 
-typedef Rule = RuleOutcome Function(Commit, RuleConfig config);
+typedef RuleFunction = RuleOutcome Function(Commit, Rule config);
 
-class ValueRuleConfig extends RuleConfig {
+class ValueRule extends Rule {
   final String value;
 
-  ValueRuleConfig({
-    required RuleConfigSeverity severity,
-    required RuleConfigCondition condition,
+  ValueRule({
+    required RuleSeverity severity,
+    required RuleCondition condition,
     required this.value,
   }) : super(severity: severity, condition: condition);
 }
 
-class LengthRuleConfig extends RuleConfig {
+class LengthRule extends Rule {
   final num length;
 
-  LengthRuleConfig({
-    required RuleConfigSeverity severity,
-    required RuleConfigCondition condition,
+  LengthRule({
+    required RuleSeverity severity,
+    required RuleCondition condition,
     required this.length,
   }) : super(
           severity: severity,
           condition: condition,
         );
 }
 
-class EnumRuleConfig extends RuleConfig {
+class EnumRule extends Rule {
   final List<String> allowed;
 
-  EnumRuleConfig({
-    required RuleConfigSeverity severity,
-    required RuleConfigCondition condition,
+  EnumRule({
+    required RuleSeverity severity,
+    required RuleCondition condition,
     required this.allowed,
   }) : super(severity: severity, condition: condition);
 }
 
-class CaseRuleConfig extends RuleConfig {
+class CaseRule extends Rule {
   final Case type;
 
-  CaseRuleConfig({
-    required RuleConfigSeverity severity,
-    required RuleConfigCondition condition,
+  CaseRule({
+    required RuleSeverity severity,
+    required RuleCondition condition,
     required this.type,
   }) : super(severity: severity, condition: condition);
 }

test/format_test.dart

@@ -16,7 +16,7 @@ void main() {
       errors: [
         LintRuleOutcome(
           valid: false,
-          level: RuleConfigSeverity.error,
+          level: RuleSeverity.error,
           name: 'error-name',
           message: 'There was an error',
         ),
@@ -31,7 +31,7 @@ void main() {
       warnings: [
         LintRuleOutcome(
           valid: false,
-          level: RuleConfigSeverity.warning,
+          level: RuleSeverity.warning,
           name: 'warning-name',
           message: 'There was a problem',
         ),

test/lint_test.dart

@@ -18,9 +18,9 @@ void main() {
 
   test('positive on stub message and adhered rule', () async {
     final result = await lint('foo: bar', {
-      'type-enum': EnumRuleConfig(
-        severity: RuleConfigSeverity.error,
-        condition: RuleConfigCondition.always,
+      'type-enum': EnumRule(
+        severity: RuleSeverity.error,
+        condition: RuleCondition.always,
         allowed: ['foo'],
       ),
     });
@@ -29,9 +29,9 @@ void main() {
 
   test('negative on stub message and broken rule', () async {
     final result = await lint('foo: bar', {
-      'type-enum': EnumRuleConfig(
-        severity: RuleConfigSeverity.error,
-        condition: RuleConfigCondition.never,
+      'type-enum': EnumRule(
+        severity: RuleSeverity.error,
+        condition: RuleCondition.never,
         allowed: ['foo'],
       ),
     });
@@ -40,23 +40,26 @@ void main() {
 
   test('positive on ignored message and broken rule', () async {
     final result = await lint('Revert "some bogus commit"', {
-      'type-empty': RuleConfig(
-        severity: RuleConfigSeverity.error,
-        condition: RuleConfigCondition.never,
+      'type-empty': Rule(
+        severity: RuleSeverity.error,
+        condition: RuleCondition.never,
       ),
     });
-    expect(result.valid, false);
+    expect(result.valid, true);
     expect(result.input, equals('Revert "some bogus commit"'));
   });
 
   test('negative on ignored message, disabled ignored messages and broken rule',
       () async {
-    final result = await lint('Revert "some bogus commit"', {
-      'type-empty': RuleConfig(
-        severity: RuleConfigSeverity.error,
-        condition: RuleConfigCondition.never,
-      ),
-    });
+    final result = await lint(
+        'Revert "some bogus commit"',
+        {
+          'type-empty': Rule(
+            severity: RuleSeverity.error,
+            condition: RuleCondition.never,
+          ),
+        },
+        defaultIgnores: false);
     expect(result.valid, false);
   });
 }

test/load_test.dart

@@ -5,33 +5,33 @@ import 'package:test/test.dart';
 
 void main() {
   test('empty should have no rules', () async {
-    final rules = await load(file: 'test/__fixtures__/empty.yaml');
-    expect(rules.isEmpty, true);
+    final config = await load('test/__fixtures__/empty.yaml');
+    expect(config.rules.isEmpty, true);
   });
   test('only `rules` should work', () async {
-    final rules = await load(file: 'test/__fixtures__/only-rules.yaml');
-    expect(rules.isEmpty, false);
-    expect(rules.keys.length, equals(2));
-    expect(rules['type-case'], isA<CaseRuleConfig>());
-    expect(rules['type-enum'], isA<EnumRuleConfig>());
-    expect((rules['type-case'] as CaseRuleConfig).type, Case.lower);
-    expect((rules['type-enum'] as EnumRuleConfig).allowed,
+    final config = await load('test/__fixtures__/only-rules.yaml');
+    expect(config.rules.isEmpty, false);
+    expect(config.rules.keys.length, equals(2));
+    expect(config.rules['type-case'], isA<CaseRule>());
+    expect(config.rules['type-enum'], isA<EnumRule>());
+    expect((config.rules['type-case'] as CaseRule).type, Case.lower);
+    expect((config.rules['type-enum'] as EnumRule).allowed,
         equals(['feat', 'fix', 'docs', 'chore']));
   });
   test('include relative path should work', () async {
-    final rules = await load(file: 'test/__fixtures__/include-path.yaml');
-    expect(rules.isEmpty, false);
-    expect(rules.keys.length, greaterThan(1));
-    expect(rules['type-case'], isA<CaseRuleConfig>());
-    expect(rules['type-enum'], isA<EnumRuleConfig>());
-    expect((rules['type-case'] as CaseRuleConfig).type, Case.upper);
+    final config = await load('test/__fixtures__/include-path.yaml');
+    expect(config.rules.isEmpty, false);
+    expect(config.rules.keys.length, greaterThan(1));
+    expect(config.rules['type-case'], isA<CaseRule>());
+    expect(config.rules['type-enum'], isA<EnumRule>());
+    expect((config.rules['type-case'] as CaseRule).type, Case.upper);
   });
   test('include package path should work', () async {
-    final rules = await load(file: 'test/__fixtures__/include-package.yaml');
-    expect(rules.isEmpty, false);
-    expect(rules.keys.length, greaterThan(1));
-    expect(rules['type-case'], isA<CaseRuleConfig>());
-    expect(rules['type-enum'], isA<EnumRuleConfig>());
-    expect((rules['type-case'] as CaseRuleConfig).type, Case.upper);
+    final config = await load('test/__fixtures__/include-package.yaml');
+    expect(config.rules.isEmpty, false);
+    expect(config.rules.keys.length, greaterThan(1));
+    expect(config.rules['type-case'], isA<CaseRule>());
+    expect(config.rules['type-enum'], isA<EnumRule>());
+    expect((config.rules['type-case'] as CaseRule).type, Case.upper);
   });
 }