From 6275b4c85c97df48704fd013411c6cb700d5bb2a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Wed, 22 Apr 2026 10:20:26 +0300
Subject: [PATCH 01/21] Created analysis_options.yaml rules parser

---
 .../analysis_options_loader.dart              | 115 ++++++++++++++++++
 1 file changed, 115 insertions(+)
 create mode 100644 lib/src/common/parameter_parser/analysis_options_loader.dart

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
new file mode 100644
index 00000000..2b1d5162
--- /dev/null
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -0,0 +1,115 @@
+import 'dart:io';
+import 'package:yaml/yaml.dart';
+
+/// Loads and parses analysis options from a Dart project's YAML file.
+class AnalysisOptionsLoader {
+  final Map<String, dynamic> _cache = {};
+
+  /// Loads analysis options from a YAML file at the given [yamlPath].
+  Map<String, dynamic> loadAnalysisOptions(String yamlPath) {
+    if (_cache.containsKey(yamlPath)) {
+      return _cache[yamlPath] as Map<String, dynamic>;
+    }
+
+    final file = File(yamlPath);
+    if (!file.existsSync()) {
+      _cache[yamlPath] = {};
+      return {};
+    }
+
+    try {
+      final content = file.readAsStringSync();
+      final yamlMap = loadYaml(content);
+      final parsedYaml = _convertYaml(yamlMap);
+      final result =
+          parsedYaml is Map<String, dynamic> ? parsedYaml : <String, dynamic>{};
+
+      _cache[yamlPath] = result;
+      return result;
+    } on YamlException {
+      _cache[yamlPath] = {};
+      return {};
+    }
+  }
+
+  /// Extracts custom lint rules from the provided YAML map.
+  Map<String, dynamic> extractLintRules(
+    Map<String, dynamic> yaml, {
+    String lintName = 'custom_lint',
+  }) {
+    final customLint = yaml[lintName];
+
+    if (customLint is! Map) return {};
+
+    final rules = customLint['rules'];
+
+    if (rules is! List) return {};
+
+    final result = <String, dynamic>{};
+
+    for (final item in rules) {
+      final rule = _extractRuleEntry(item);
+      if (rule == null) continue;
+
+      result[rule.$1] = rule.$2;
+    }
+
+    return result;
+  }
+
+  dynamic _convertYaml(dynamic yaml) {
+    if (yaml is YamlMap) {
+      return _yamlMapToDartMap(yaml);
+    }
+
+    if (yaml is YamlList) {
+      return yaml.map(_convertRuleItem).toList();
+    }
+
+    return yaml;
+  }
+
+  dynamic _convertRuleItem(dynamic item) {
+    if (item is! YamlMap) return item;
+
+    final map = _yamlMapToDartMap(item);
+
+    final keys = map.keys.toList();
+
+    if (keys.length >= 2 && map[keys.first] == null) {
+      final ruleName = keys.first;
+      final config = Map<String, dynamic>.from(map)..remove(ruleName);
+
+      return {ruleName: config.isEmpty ? null : config};
+    }
+
+    return map;
+  }
+
+  Map<String, dynamic> _yamlMapToDartMap(YamlMap yamlMap) {
+    return Map<String, dynamic>.fromEntries(
+      yamlMap.entries.map(
+        (e) => MapEntry(e.key.toString(), _convertYaml(e.value)),
+      ),
+    );
+  }
+
+  (String, Map<String, dynamic>)? _extractRuleEntry(dynamic item) {
+    if (item is String) return (item, {});
+    if (item is! Map || item.isEmpty) return null;
+
+    final entry = item.entries.first;
+    final ruleName = entry.key.toString();
+    final config = entry.value;
+
+    if (config is Map<String, dynamic>) {
+      return (ruleName, config);
+    }
+
+    if (config is Map) {
+      return (ruleName, Map<String, dynamic>.from(config));
+    }
+
+    return (ruleName, {});
+  }
+}

From 48860fbbb0b31bb4fdb75b01f38ffe79d5e64c7d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 11:44:53 +0300
Subject: [PATCH 02/21] Improved yaml parser and added the analysis_options
 loader

---
 lib/main.dart                                 |   3 +
 .../analysis_options_loader.dart              | 153 +++++++-----------
 .../common/parameter_parser/lint_options.dart |  30 ++++
 3 files changed, 87 insertions(+), 99 deletions(-)
 create mode 100644 lib/src/common/parameter_parser/lint_options.dart

diff --git a/lib/main.dart b/lib/main.dart
index 5657b7a1..03b78de6 100644
--- a/lib/main.dart
+++ b/lib/main.dart
@@ -21,6 +21,9 @@ class SolidLintsPlugin extends Plugin {
 
   @override
   void register(PluginRegistry registry) {
+    //  final directory = Directory.current;
+    // final rules = analysisLoader.loadRules(directory.path);
+
     registry.registerLintRule(
       AvoidGlobalStateRule(),
     );
diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 2b1d5162..0cea9442 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -1,115 +1,70 @@
-import 'dart:io';
+import 'dart:collection';
+
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:path/path.dart' as p;
+import 'package:solid_lints/src/common/parameter_parser/lint_options.dart';
 import 'package:yaml/yaml.dart';
 
+/// A global instance of [AnalysisOptionsLoader] for use across the plugin.
+final analysisLoader = AnalysisOptionsLoader();
+
 /// Loads and parses analysis options from a Dart project's YAML file.
 class AnalysisOptionsLoader {
-  final Map<String, dynamic> _cache = {};
+  /// Asynchronously loads analysis options from the specified [rootPath].
+  Map<String, LintOptions> loadRules(String rootPath) {
+    final file = PhysicalResourceProvider.INSTANCE.getFile(
+      p.join(rootPath, 'analysis_options.yaml'),
+    );
 
-  /// Loads analysis options from a YAML file at the given [yamlPath].
-  Map<String, dynamic> loadAnalysisOptions(String yamlPath) {
-    if (_cache.containsKey(yamlPath)) {
-      return _cache[yamlPath] as Map<String, dynamic>;
-    }
+    final rules = _getRules(file);
+    return rules;
+  }
 
-    final file = File(yamlPath);
-    if (!file.existsSync()) {
-      _cache[yamlPath] = {};
+  Map<String, LintOptions> _getRules(File? analysisOptionsFile) {
+    if (analysisOptionsFile == null || !analysisOptionsFile.exists) {
       return {};
     }
 
+    final optionsString = analysisOptionsFile.readAsStringSync();
+    Object? yaml;
     try {
-      final content = file.readAsStringSync();
-      final yamlMap = loadYaml(content);
-      final parsedYaml = _convertYaml(yamlMap);
-      final result =
-          parsedYaml is Map<String, dynamic> ? parsedYaml : <String, dynamic>{};
-
-      _cache[yamlPath] = result;
-      return result;
-    } on YamlException {
-      _cache[yamlPath] = {};
+      yaml = loadYaml(optionsString) as Object?;
+    } catch (err) {
       return {};
     }
-  }
-
-  /// Extracts custom lint rules from the provided YAML map.
-  Map<String, dynamic> extractLintRules(
-    Map<String, dynamic> yaml, {
-    String lintName = 'custom_lint',
-  }) {
-    final customLint = yaml[lintName];
-
-    if (customLint is! Map) return {};
-
-    final rules = customLint['rules'];
-
-    if (rules is! List) return {};
-
-    final result = <String, dynamic>{};
-
-    for (final item in rules) {
-      final rule = _extractRuleEntry(item);
-      if (rule == null) continue;
-
-      result[rule.$1] = rule.$2;
-    }
-
-    return result;
-  }
-
-  dynamic _convertYaml(dynamic yaml) {
-    if (yaml is YamlMap) {
-      return _yamlMapToDartMap(yaml);
-    }
-
-    if (yaml is YamlList) {
-      return yaml.map(_convertRuleItem).toList();
-    }
-
-    return yaml;
-  }
-
-  dynamic _convertRuleItem(dynamic item) {
-    if (item is! YamlMap) return item;
-
-    final map = _yamlMapToDartMap(item);
-
-    final keys = map.keys.toList();
-
-    if (keys.length >= 2 && map[keys.first] == null) {
-      final ruleName = keys.first;
-      final config = Map<String, dynamic>.from(map)..remove(ruleName);
-
-      return {ruleName: config.isEmpty ? null : config};
-    }
-
-    return map;
-  }
-
-  Map<String, dynamic> _yamlMapToDartMap(YamlMap yamlMap) {
-    return Map<String, dynamic>.fromEntries(
-      yamlMap.entries.map(
-        (e) => MapEntry(e.key.toString(), _convertYaml(e.value)),
-      ),
-    );
-  }
-
-  (String, Map<String, dynamic>)? _extractRuleEntry(dynamic item) {
-    if (item is String) return (item, {});
-    if (item is! Map || item.isEmpty) return null;
-
-    final entry = item.entries.first;
-    final ruleName = entry.key.toString();
-    final config = entry.value;
-
-    if (config is Map<String, dynamic>) {
-      return (ruleName, config);
-    }
-
-    if (config is Map) {
-      return (ruleName, Map<String, dynamic>.from(config));
+    if (yaml is! Map) return {};
+
+    final rules = <String, LintOptions>{};
+    final pluginsYaml = yaml['plugins'] as Object?;
+
+    if (pluginsYaml is Map) {
+      final solidLint = pluginsYaml['solid_lints'];
+      if (solidLint is Map) {
+        final diagnostics = solidLint['diagnostics'];
+
+        if (diagnostics is Map) {
+          for (final diag in diagnostics.entries) {
+            final ruleName = diag.key as String;
+            final value = diag.value;
+
+            if (value is bool) {
+              rules[ruleName] = LintOptions.empty(enabled: value);
+            } else if (value is Map) {
+              final map = Map<String, Object?>.from(value);
+
+              final enabled = map.remove('enabled') as bool? ?? true;
+
+              rules[ruleName] = LintOptions.fromYaml(
+                map,
+                enabled: enabled,
+              );
+            }
+          }
+        }
+      }
     }
 
-    return (ruleName, {});
+    return UnmodifiableMapView(rules);
   }
 }
diff --git a/lib/src/common/parameter_parser/lint_options.dart b/lib/src/common/parameter_parser/lint_options.dart
new file mode 100644
index 00000000..f368ae13
--- /dev/null
+++ b/lib/src/common/parameter_parser/lint_options.dart
@@ -0,0 +1,30 @@
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
+import 'package:collection/collection.dart';
+
+/// Option information for a specific [AnalysisRule].
+class LintOptions {
+  /// Creates a [LintOptions] from YAML.
+  const LintOptions.fromYaml(Map<String, Object?> yaml, {required this.enabled})
+      : json = yaml;
+
+  /// Options with no [json]
+  const LintOptions.empty({required this.enabled}) : json = const {};
+
+  /// Whether the configuration enables/disables the lint rule.
+  final bool enabled;
+
+  /// Extra configurations for a [AnalysisRule].
+  final Map<String, Object?> json;
+
+  @override
+  bool operator ==(Object other) =>
+      other is LintOptions &&
+      other.enabled == enabled &&
+      const MapEquality<String, Object?>().equals(other.json, json);
+
+  @override
+  int get hashCode => Object.hash(
+        enabled,
+        const MapEquality<String, Object?>().hash(json),
+      );
+}

From 186220b7f69c69677a5018a781a133fa341609ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 15:52:19 +0300
Subject: [PATCH 03/21] Improved rules loader from yaml

---
 lib/main.dart                                 |   3 -
 .../analysis_options_loader.dart              |  60 +++++-
 .../common/parameter_parser/lint_options.dart | 202 ++++++++++++++++++
 3 files changed, 255 insertions(+), 10 deletions(-)

diff --git a/lib/main.dart b/lib/main.dart
index 03b78de6..5657b7a1 100644
--- a/lib/main.dart
+++ b/lib/main.dart
@@ -21,9 +21,6 @@ class SolidLintsPlugin extends Plugin {
 
   @override
   void register(PluginRegistry registry) {
-    //  final directory = Directory.current;
-    // final rules = analysisLoader.loadRules(directory.path);
-
     registry.registerLintRule(
       AvoidGlobalStateRule(),
     );
diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 0cea9442..a48e8701 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -1,8 +1,10 @@
 import 'dart:collection';
 
+import 'dart:io' as io;
+import 'dart:io';
+import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
-import 'package:path/path.dart' as p;
 import 'package:solid_lints/src/common/parameter_parser/lint_options.dart';
 import 'package:yaml/yaml.dart';
 
@@ -11,14 +13,58 @@ final analysisLoader = AnalysisOptionsLoader();
 
 /// Loads and parses analysis options from a Dart project's YAML file.
 class AnalysisOptionsLoader {
-  /// Asynchronously loads analysis options from the specified [rootPath].
-  Map<String, LintOptions> loadRules(String rootPath) {
-    final file = PhysicalResourceProvider.INSTANCE.getFile(
-      p.join(rootPath, 'analysis_options.yaml'),
-    );
+  Map<String, LintOptions> _rulesCache = {};
+
+  /// Retrieves the currently loaded lint rules.
+  Map<String, LintOptions> get rules => _rulesCache;
+
+  /// Loads lint rules from the analysis options file based
+  /// on the provided [RuleContext].
+  void loadRulesFromContext(RuleContext context) {
+    if (_rulesCache.isNotEmpty) {
+      return;
+    }
+
+    final directory = context.allUnits.first.file.path;
+    _loadRules(directory);
+  }
+
+  void _loadRules(String rootPath) {
+    final yamlPath = _findNearestYamlUpwards(rootPath);
+
+    if (yamlPath == null) {
+      return;
+    }
+
+    final file = PhysicalResourceProvider.INSTANCE.getFile(yamlPath);
 
     final rules = _getRules(file);
-    return rules;
+    _rulesCache = rules;
+  }
+
+  String? _findNearestYamlUpwards(
+    String filePath, {
+    String fileName = 'analysis_options.yaml',
+  }) {
+    final startFile = io.File(filePath);
+    io.Directory dir = startFile.parent;
+
+    while (true) {
+      final candidate = PhysicalResourceProvider.INSTANCE
+          .getFile('${dir.path}${Platform.pathSeparator}$fileName');
+
+      if (candidate.exists) {
+        return candidate.path;
+      }
+
+      final parent = dir.parent;
+
+      if (parent.path == dir.path) {
+        return null;
+      }
+
+      dir = parent;
+    }
   }
 
   Map<String, LintOptions> _getRules(File? analysisOptionsFile) {
diff --git a/lib/src/common/parameter_parser/lint_options.dart b/lib/src/common/parameter_parser/lint_options.dart
index f368ae13..0174f7fc 100644
--- a/lib/src/common/parameter_parser/lint_options.dart
+++ b/lib/src/common/parameter_parser/lint_options.dart
@@ -1,3 +1,205 @@
+//                                Apache License
+//                          Version 2.0, January 2004
+//                       http://www.apache.org/licenses/
+
+//  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+//  1. Definitions.
+
+//     "License" shall mean the terms and conditions for use, reproduction,
+//     and distribution as defined by Sections 1 through 9 of this document.
+
+//     "Licensor" shall mean the copyright owner or entity authorized by
+//     the copyright owner that is granting the License.
+
+//     "Legal Entity" shall mean the union of the acting entity and all
+//     other entities that control, are controlled by, or are under common
+//     control with that entity. For the purposes of this definition,
+//     "control" means (i) the power, direct or indirect, to cause the
+//     direction or management of such entity, whether by contract or
+//     otherwise, or (ii) ownership of fifty percent (50%) or more of the
+//     outstanding shares, or (iii) beneficial ownership of such entity.
+
+//     "You" (or "Your") shall mean an individual or Legal Entity
+//     exercising permissions granted by this License.
+
+//     "Source" form shall mean the preferred form for making modifications,
+//     including but not limited to software source code, documentation
+//     source, and configuration files.
+
+//     "Object" form shall mean any form resulting from mechanical
+//     transformation or translation of a Source form, including but
+//     not limited to compiled object code, generated documentation,
+//     and conversions to other media types.
+
+//     "Work" shall mean the work of authorship, whether in Source or
+//     Object form, made available under the License, as indicated by a
+//     copyright notice that is included in or attached to the work
+//     (an example is provided in the Appendix below).
+
+//     "Derivative Works" shall mean any work, whether in Source or Object
+//     form, that is based on (or derived from) the Work and for which the
+//     editorial revisions, annotations, elaborations, or other modifications
+//     represent, as a whole, an original work of authorship. For the purposes
+//     of this License, Derivative Works shall not include works that remain
+//     separable from, or merely link (or bind by name) to the interfaces of,
+//     the Work and Derivative Works thereof.
+
+//     "Contribution" shall mean any work of authorship, including
+//     the original version of the Work and any modifications or additions
+//     to that Work or Derivative Works thereof, that is intentionally
+//     submitted to Licensor for inclusion in the Work by the copyright owner
+//     or by an individual or Legal Entity authorized to submit on behalf of
+//     the copyright owner. For the purposes of this definition, "submitted"
+//     means any form of electronic, verbal, or written communication sent
+//     to the Licensor or its representatives, including but not limited to
+//     communication on electronic mailing lists, source code control systems,
+//     and issue tracking systems that are managed by, or on behalf of, the
+//     Licensor for the purpose of discussing and improving the Work, but
+//     excluding communication that is conspicuously marked or otherwise
+//     designated in writing by the copyright owner as "Not a Contribution."
+
+//     "Contributor" shall mean Licensor and any individual or Legal Entity
+//     on behalf of whom a Contribution has been received by Licensor and
+//     subsequently incorporated within the Work.
+
+//  2. Grant of Copyright License. Subject to the terms and conditions of
+//     this License, each Contributor hereby grants to You a perpetual,
+//     worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+//     copyright license to reproduce, prepare Derivative Works of,
+//     publicly display, publicly perform, sublicense, and distribute the
+//     Work and such Derivative Works in Source or Object form.
+
+//  3. Grant of Patent License. Subject to the terms and conditions of
+//     this License, each Contributor hereby grants to You a perpetual,
+//     worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+//     (except as stated in this section) patent license to make, have made,
+//     use, offer to sell, sell, import, and otherwise transfer the Work,
+//     where such license applies only to those patent claims licensable
+//     by such Contributor that are necessarily infringed by their
+//     Contribution(s) alone or by combination of their Contribution(s)
+//     with the Work to which such Contribution(s) was submitted. If You
+//     institute patent litigation against any entity (including a
+//     cross-claim or counterclaim in a lawsuit) alleging that the Work
+//     or a Contribution incorporated within the Work constitutes direct
+//     or contributory patent infringement, then any patent licenses
+//     granted to You under this License for that Work shall terminate
+//     as of the date such litigation is filed.
+
+//  4. Redistribution. You may reproduce and distribute copies of the
+//     Work or Derivative Works thereof in any medium, with or without
+//     modifications, and in Source or Object form, provided that You
+//     meet the following conditions:
+
+//     (a) You must give any other recipients of the Work or
+//         Derivative Works a copy of this License; and
+
+//     (b) You must cause any modified files to carry prominent notices
+//         stating that You changed the files; and
+
+//     (c) You must retain, in the Source form of any Derivative Works
+//         that You distribute, all copyright, patent, trademark, and
+//         attribution notices from the Source form of the Work,
+//         excluding those notices that do not pertain to any part of
+//         the Derivative Works; and
+
+//     (d) If the Work includes a "NOTICE" text file as part of its
+//         distribution, then any Derivative Works that You distribute must
+//         include a readable copy of the attribution notices contained
+//         within such NOTICE file, excluding those notices that do not
+//         pertain to any part of the Derivative Works, in at least one
+//         of the following places: within a NOTICE text file distributed
+//         as part of the Derivative Works; within the Source form or
+//         documentation, if provided along with the Derivative Works; or,
+//         within a display generated by the Derivative Works, if and
+//         wherever such third-party notices normally appear. The contents
+//         of the NOTICE file are for informational purposes only and
+//         do not modify the License. You may add Your own attribution
+//         notices within Derivative Works that You distribute, alongside
+//         or as an addendum to the NOTICE text from the Work, provided
+//         that such additional attribution notices cannot be construed
+//         as modifying the License.
+
+//     You may add Your own copyright statement to Your modifications and
+//     may provide additional or different license terms and conditions
+//     for use, reproduction, or distribution of Your modifications, or
+//     for any such Derivative Works as a whole, provided Your use,
+//     reproduction, and distribution of the Work otherwise complies with
+//     the conditions stated in this License.
+
+//  5. Submission of Contributions. Unless You explicitly state otherwise,
+//     any Contribution intentionally submitted for inclusion in the Work
+//     by You to the Licensor shall be under the terms and conditions of
+//     this License, without any additional terms or conditions.
+//     Notwithstanding the above, nothing herein shall supersede or modify
+//     the terms of any separate license agreement you may have executed
+//     with Licensor regarding such Contributions.
+
+//  6. Trademarks. This License does not grant permission to use the trade
+//     names, trademarks, service marks, or product names of the Licensor,
+//     except as required for reasonable and customary use in describing the
+//     origin of the Work and reproducing the content of the NOTICE file.
+
+//  7. Disclaimer of Warranty. Unless required by applicable law or
+//     agreed to in writing, Licensor provides the Work (and each
+//     Contributor provides its Contributions) on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+//     implied, including, without limitation, any warranties or conditions
+//     of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+//     PARTICULAR PURPOSE. You are solely responsible for determining the
+//     appropriateness of using or redistributing the Work and assume any
+//     risks associated with Your exercise of permissions under this License.
+
+//  8. Limitation of Liability. In no event and under no legal theory,
+//     whether in tort (including negligence), contract, or otherwise,
+//     unless required by applicable law (such as deliberate and grossly
+//     negligent acts) or agreed to in writing, shall any Contributor be
+//     liable to You for damages, including any direct, indirect, special,
+//     incidental, or consequential damages of any character arising as a
+//     result of this License or out of the use or inability to use the
+//     Work (including but not limited to damages for loss of goodwill,
+//     work stoppage, computer failure or malfunction, or any and all
+//     other commercial damages or losses), even if such Contributor
+//     has been advised of the possibility of such damages.
+
+//  9. Accepting Warranty or Additional Liability. While redistributing
+//     the Work or Derivative Works thereof, You may choose to offer,
+//     and charge a fee for, acceptance of support, warranty, indemnity,
+//     or other liability obligations and/or rights consistent with this
+//     License. However, in accepting such obligations, You may act only
+//     on Your own behalf and on Your sole responsibility, not on behalf
+//     of any other Contributor, and only if You agree to indemnify,
+//     defend, and hold each Contributor harmless for any liability
+//     incurred by, or claims asserted against, such Contributor by reason
+//     of your accepting any such warranty or additional liability.
+
+//  END OF TERMS AND CONDITIONS
+
+//  APPENDIX: How to apply the Apache License to your work.
+
+//     To apply the Apache License to your work, attach the following
+//     boilerplate notice, with the fields enclosed by brackets "[]"
+//     replaced with your own identifying information. (Don't include
+//     the brackets!)  The text should be enclosed in the appropriate
+//     comment syntax for the file format. We also recommend that a
+//     file or class name and description of purpose be included on the
+//     same "printed page" as the copyright notice for easier
+//     identification within third-party archives.
+
+//  Copyright 2020 Invertase Limited
+
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+
+//      http://www.apache.org/licenses/LICENSE-2.0
+
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
 import 'package:analyzer/analysis_rule/analysis_rule.dart';
 import 'package:collection/collection.dart';
 

From 67fb836b30b75d6e17cb91d7554bf6412834c896 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 16:11:39 +0300
Subject: [PATCH 04/21] Added verification before looking for .yaml's path

---
 lib/src/common/parameter_parser/analysis_options_loader.dart | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index a48e8701..2a0f3107 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -24,7 +24,9 @@ class AnalysisOptionsLoader {
     if (_rulesCache.isNotEmpty) {
       return;
     }
-
+    if (context.allUnits.isEmpty) {
+      return;
+    }
     final directory = context.allUnits.first.file.path;
     _loadRules(directory);
   }

From c770d171cb06008c572d0d678552a5ee03725358 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 17:54:59 +0300
Subject: [PATCH 05/21] Fields and getters are now declared before the
 constructor

---
 lib/src/common/parameter_parser/lint_options.dart | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/src/common/parameter_parser/lint_options.dart b/lib/src/common/parameter_parser/lint_options.dart
index 0174f7fc..ad22fed9 100644
--- a/lib/src/common/parameter_parser/lint_options.dart
+++ b/lib/src/common/parameter_parser/lint_options.dart
@@ -205,10 +205,6 @@ import 'package:collection/collection.dart';
 
 /// Option information for a specific [AnalysisRule].
 class LintOptions {
-  /// Creates a [LintOptions] from YAML.
-  const LintOptions.fromYaml(Map<String, Object?> yaml, {required this.enabled})
-      : json = yaml;
-
   /// Options with no [json]
   const LintOptions.empty({required this.enabled}) : json = const {};
 
@@ -218,6 +214,10 @@ class LintOptions {
   /// Extra configurations for a [AnalysisRule].
   final Map<String, Object?> json;
 
+  /// Creates a [LintOptions] from YAML.
+  const LintOptions.fromYaml(Map<String, Object?> yaml, {required this.enabled})
+      : json = yaml;
+
   @override
   bool operator ==(Object other) =>
       other is LintOptions &&

From 4f7b35e83c6d589a97cf7ef6f806859d416963fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 18:12:15 +0300
Subject: [PATCH 06/21] Added method to get options of a rule by it's name

---
 lib/src/common/parameter_parser/analysis_options_loader.dart | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 2a0f3107..23822a8f 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -18,6 +18,9 @@ class AnalysisOptionsLoader {
   /// Retrieves the currently loaded lint rules.
   Map<String, LintOptions> get rules => _rulesCache;
 
+  /// Gets the options for a specific rule by its name.
+  LintOptions? getRuleOptions(String ruleName) => _rulesCache[ruleName];
+
   /// Loads lint rules from the analysis options file based
   /// on the provided [RuleContext].
   void loadRulesFromContext(RuleContext context) {

From a8a3643b40fc00619704d88b5b00ea6cf65ab91b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 18:21:36 +0300
Subject: [PATCH 07/21] Made suggested changes to file upward finder

---
 .../parameter_parser/analysis_options_loader.dart | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 23822a8f..3c0a6d6a 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -1,5 +1,3 @@
-import 'dart:collection';
-
 import 'dart:io' as io;
 import 'dart:io';
 import 'package:analyzer/analysis_rule/rule_context.dart';
@@ -35,7 +33,7 @@ class AnalysisOptionsLoader {
   }
 
   void _loadRules(String rootPath) {
-    final yamlPath = _findNearestYamlUpwards(rootPath);
+    final yamlPath = _findNearestFileUpwards(rootPath);
 
     if (yamlPath == null) {
       return;
@@ -47,14 +45,14 @@ class AnalysisOptionsLoader {
     _rulesCache = rules;
   }
 
-  String? _findNearestYamlUpwards(
+  String? _findNearestFileUpwards(
     String filePath, {
     String fileName = 'analysis_options.yaml',
   }) {
     final startFile = io.File(filePath);
     io.Directory dir = startFile.parent;
 
-    while (true) {
+    while (dir.path != dir.parent.path) {
       final candidate = PhysicalResourceProvider.INSTANCE
           .getFile('${dir.path}${Platform.pathSeparator}$fileName');
 
@@ -64,12 +62,9 @@ class AnalysisOptionsLoader {
 
       final parent = dir.parent;
 
-      if (parent.path == dir.path) {
-        return null;
-      }
-
       dir = parent;
     }
+    return null;
   }
 
   Map<String, LintOptions> _getRules(File? analysisOptionsFile) {
@@ -116,6 +111,6 @@ class AnalysisOptionsLoader {
       }
     }
 
-    return UnmodifiableMapView(rules);
+    return rules;
   }
 }

From 8b0e9042d197d01d861138841f7f181852cf7acd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 18:28:58 +0300
Subject: [PATCH 08/21] Removed top-level variable

---
 lib/src/common/parameter_parser/analysis_options_loader.dart | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 3c0a6d6a..9570fb34 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -6,9 +6,6 @@ import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:solid_lints/src/common/parameter_parser/lint_options.dart';
 import 'package:yaml/yaml.dart';
 
-/// A global instance of [AnalysisOptionsLoader] for use across the plugin.
-final analysisLoader = AnalysisOptionsLoader();
-
 /// Loads and parses analysis options from a Dart project's YAML file.
 class AnalysisOptionsLoader {
   Map<String, LintOptions> _rulesCache = {};

From a89dc967f2905ae69a7456b1c47be7218a251bac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 18:31:36 +0300
Subject: [PATCH 09/21] Improved name of variable in loadRuleFromContext

---
 lib/src/common/parameter_parser/analysis_options_loader.dart | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 9570fb34..b6f1ac8f 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -25,8 +25,8 @@ class AnalysisOptionsLoader {
     if (context.allUnits.isEmpty) {
       return;
     }
-    final directory = context.allUnits.first.file.path;
-    _loadRules(directory);
+    final filePath = context.allUnits.first.file.path;
+    _loadRules(filePath);
   }
 
   void _loadRules(String rootPath) {

From 1da8d7ec24b61818fab49be2d1dab2f45b9cc113 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 18:50:12 +0300
Subject: [PATCH 10/21] Updated analysis options to have rules for each
 configuration file path

---
 .../analysis_options_loader.dart              | 20 ++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index b6f1ac8f..d8179f76 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -8,20 +8,18 @@ import 'package:yaml/yaml.dart';
 
 /// Loads and parses analysis options from a Dart project's YAML file.
 class AnalysisOptionsLoader {
-  Map<String, LintOptions> _rulesCache = {};
-
-  /// Retrieves the currently loaded lint rules.
-  Map<String, LintOptions> get rules => _rulesCache;
+  final Map<String, Map<String, LintOptions>> _rulesCache = {};
 
   /// Gets the options for a specific rule by its name.
-  LintOptions? getRuleOptions(String ruleName) => _rulesCache[ruleName];
+  LintOptions? getRuleOptions(RuleContext context, String ruleName) {
+    final yamlPath = _findNearestFileUpwards(context.allUnits.first.file.path);
+    if (yamlPath == null) return null;
+    return _rulesCache[yamlPath]?[ruleName];
+  }
 
   /// Loads lint rules from the analysis options file based
   /// on the provided [RuleContext].
   void loadRulesFromContext(RuleContext context) {
-    if (_rulesCache.isNotEmpty) {
-      return;
-    }
     if (context.allUnits.isEmpty) {
       return;
     }
@@ -36,10 +34,14 @@ class AnalysisOptionsLoader {
       return;
     }
 
+    if (_rulesCache.containsKey(yamlPath)) {
+      return;
+    }
+
     final file = PhysicalResourceProvider.INSTANCE.getFile(yamlPath);
 
     final rules = _getRules(file);
-    _rulesCache = rules;
+    _rulesCache[yamlPath] = rules;
   }
 
   String? _findNearestFileUpwards(

From ae8520a6bef7eb5a8d0bd5463821a284a7bbfe7d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 19:06:09 +0300
Subject: [PATCH 11/21] Updated file upward finder to not mix File from dart.io
 with file from analyzer

---
 .../analysis_options_loader.dart              | 20 +++++++++----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index d8179f76..65c53ce5 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -1,5 +1,3 @@
-import 'dart:io' as io;
-import 'dart:io';
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
@@ -48,20 +46,20 @@ class AnalysisOptionsLoader {
     String filePath, {
     String fileName = 'analysis_options.yaml',
   }) {
-    final startFile = io.File(filePath);
-    io.Directory dir = startFile.parent;
+    final pathContext = PhysicalResourceProvider.INSTANCE.pathContext;
+    var dir = pathContext.dirname(filePath);
 
-    while (dir.path != dir.parent.path) {
-      final candidate = PhysicalResourceProvider.INSTANCE
-          .getFile('${dir.path}${Platform.pathSeparator}$fileName');
+    while (pathContext.dirname(dir) != dir) {
+      final candidatePath = pathContext.join(dir, fileName);
+      final candidate =
+          PhysicalResourceProvider.INSTANCE.getFile(candidatePath);
 
       if (candidate.exists) {
-        return candidate.path;
+        return candidatePath;
       }
 
-      final parent = dir.parent;
-
-      dir = parent;
+      final parentDir = pathContext.dirname(dir);
+      dir = parentDir;
     }
     return null;
   }

From a6e227cf1eb40977be7ed3ba78e618f50040b7f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tru=C8=99c=C4=83=20Daria=20Maria?=
 <115713732+Dariaa14@users.noreply.github.com>
Date: Thu, 23 Apr 2026 19:09:55 +0300
Subject: [PATCH 12/21] Added usage example in avoid_global_state_rule

---
 lib/main.dart                                            | 4 +++-
 .../avoid_global_state/avoid_global_state_rule.dart      | 9 ++++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/lib/main.dart b/lib/main.dart
index 5657b7a1..b0a50bfc 100644
--- a/lib/main.dart
+++ b/lib/main.dart
@@ -1,5 +1,6 @@
 import 'package:analysis_server_plugin/plugin.dart';
 import 'package:analysis_server_plugin/registry.dart';
+import 'package:solid_lints/src/common/parameter_parser/analysis_options_loader.dart';
 import 'package:solid_lints/src/lints/avoid_debug_print_in_release/avoid_debug_print_in_release_rule.dart';
 import 'package:solid_lints/src/lints/avoid_global_state/avoid_global_state_rule.dart';
 import 'package:solid_lints/src/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule.dart';
@@ -21,8 +22,9 @@ class SolidLintsPlugin extends Plugin {
 
   @override
   void register(PluginRegistry registry) {
+    final analysisLoader = AnalysisOptionsLoader();
     registry.registerLintRule(
-      AvoidGlobalStateRule(),
+      AvoidGlobalStateRule(analysisLoader),
     );
     registry.registerLintRule(
       AvoidNonNullAssertionRule(),
diff --git a/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart b/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart
index 6ee78241..6586673f 100644
--- a/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart
+++ b/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart
@@ -2,6 +2,7 @@ import 'package:analyzer/analysis_rule/analysis_rule.dart';
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:solid_lints/src/common/parameter_parser/analysis_options_loader.dart';
 import 'package:solid_lints/src/lints/avoid_global_state/visitors/avoid_global_state_visitor.dart';
 
 /// Avoid top-level and static mutable variables.
@@ -46,8 +47,10 @@ class AvoidGlobalStateRule extends AnalysisRule {
         'Prefer using final/const or a state management solution.',
   );
 
+  final AnalysisOptionsLoader _analysisLoader;
+
   /// Creates an instance of [AvoidGlobalStateRule].
-  AvoidGlobalStateRule()
+  AvoidGlobalStateRule(this._analysisLoader)
       : super(
           name: lintName,
           description: 'Avoid top-level or static mutable variables ',
@@ -63,6 +66,10 @@ class AvoidGlobalStateRule extends AnalysisRule {
   ) {
     final visitor = AvoidGlobalStateVisitor(this);
 
+    _analysisLoader.loadRulesFromContext(context);
+    // To get the options of the rule:
+    // _analysisLoader.getRuleOptions(context, lintName);
+
     registry.addTopLevelVariableDeclaration(this, visitor);
     registry.addFieldDeclaration(this, visitor);
   }

From 48063bb24b69facba6fe2846f923d006025fad1a Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Tue, 2 Jun 2026 21:22:34 +0300
Subject: [PATCH 13/21] style: move getters and fields before constructor

---
 .../common/parameter_parser/lint_options.dart  | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/lib/src/common/parameter_parser/lint_options.dart b/lib/src/common/parameter_parser/lint_options.dart
index ad22fed9..7880b42d 100644
--- a/lib/src/common/parameter_parser/lint_options.dart
+++ b/lib/src/common/parameter_parser/lint_options.dart
@@ -205,15 +205,21 @@ import 'package:collection/collection.dart';
 
 /// Option information for a specific [AnalysisRule].
 class LintOptions {
-  /// Options with no [json]
-  const LintOptions.empty({required this.enabled}) : json = const {};
-
   /// Whether the configuration enables/disables the lint rule.
   final bool enabled;
 
   /// Extra configurations for a [AnalysisRule].
   final Map<String, Object?> json;
 
+  @override
+  int get hashCode => Object.hash(
+        enabled,
+        const MapEquality<String, Object?>().hash(json),
+      );
+
+  /// Options with no [json]
+  const LintOptions.empty({required this.enabled}) : json = const {};
+
   /// Creates a [LintOptions] from YAML.
   const LintOptions.fromYaml(Map<String, Object?> yaml, {required this.enabled})
       : json = yaml;
@@ -223,10 +229,4 @@ class LintOptions {
       other is LintOptions &&
       other.enabled == enabled &&
       const MapEquality<String, Object?>().equals(other.json, json);
-
-  @override
-  int get hashCode => Object.hash(
-        enabled,
-        const MapEquality<String, Object?>().hash(json),
-      );
 }

From e92ba3e0b718dfa4ff9999dcc1d5cec7ca175f78 Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Tue, 2 Jun 2026 21:28:53 +0300
Subject: [PATCH 14/21] style: improve readability

---
 .../analysis_options_loader.dart               | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 65c53ce5..3b1891c9 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -12,6 +12,7 @@ class AnalysisOptionsLoader {
   LintOptions? getRuleOptions(RuleContext context, String ruleName) {
     final yamlPath = _findNearestFileUpwards(context.allUnits.first.file.path);
     if (yamlPath == null) return null;
+
     return _rulesCache[yamlPath]?[ruleName];
   }
 
@@ -21,6 +22,7 @@ class AnalysisOptionsLoader {
     if (context.allUnits.isEmpty) {
       return;
     }
+
     final filePath = context.allUnits.first.file.path;
     _loadRules(filePath);
   }
@@ -47,20 +49,21 @@ class AnalysisOptionsLoader {
     String fileName = 'analysis_options.yaml',
   }) {
     final pathContext = PhysicalResourceProvider.INSTANCE.pathContext;
-    var dir = pathContext.dirname(filePath);
+    String currentDirectoryPath = pathContext.dirname(filePath);
 
-    while (pathContext.dirname(dir) != dir) {
-      final candidatePath = pathContext.join(dir, fileName);
-      final candidate =
+    while (pathContext.dirname(currentDirectoryPath) != currentDirectoryPath) {
+      final candidatePath = pathContext.join(currentDirectoryPath, fileName);
+      final candidateFile =
           PhysicalResourceProvider.INSTANCE.getFile(candidatePath);
 
-      if (candidate.exists) {
+      if (candidateFile.exists) {
         return candidatePath;
       }
 
-      final parentDir = pathContext.dirname(dir);
-      dir = parentDir;
+      final parentDir = pathContext.dirname(currentDirectoryPath);
+      currentDirectoryPath = parentDir;
     }
+
     return null;
   }
 
@@ -76,6 +79,7 @@ class AnalysisOptionsLoader {
     } catch (err) {
       return {};
     }
+
     if (yaml is! Map) return {};
 
     final rules = <String, LintOptions>{};

From da89ff9c9d455a39a490a9813f733e6c6f03e402 Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Tue, 2 Jun 2026 21:59:22 +0300
Subject: [PATCH 15/21] fix: don't parse enabled if the rule has configured
 options style: improve variable names refactor: use root package path instead
 of library path refactor: use pattern matching to reduce nesting

---
 .../analysis_options_loader.dart              | 77 ++++++++-----------
 1 file changed, 32 insertions(+), 45 deletions(-)

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index 3b1891c9..b9d7b5be 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -10,7 +10,10 @@ class AnalysisOptionsLoader {
 
   /// Gets the options for a specific rule by its name.
   LintOptions? getRuleOptions(RuleContext context, String ruleName) {
-    final yamlPath = _findNearestFileUpwards(context.allUnits.first.file.path);
+    final packageRootPath = context.package?.root.path;
+    if (packageRootPath == null) return null;
+
+    final yamlPath = _findNearestAnalysisOptionsFilePath(packageRootPath);
     if (yamlPath == null) return null;
 
     return _rulesCache[yamlPath]?[ruleName];
@@ -19,40 +22,33 @@ class AnalysisOptionsLoader {
   /// Loads lint rules from the analysis options file based
   /// on the provided [RuleContext].
   void loadRulesFromContext(RuleContext context) {
-    if (context.allUnits.isEmpty) {
-      return;
-    }
+    final packageRootPath = context.package?.root.path;
+    if (packageRootPath == null) return;
 
-    final filePath = context.allUnits.first.file.path;
-    _loadRules(filePath);
+    _loadRules(packageRootPath);
   }
 
   void _loadRules(String rootPath) {
-    final yamlPath = _findNearestFileUpwards(rootPath);
+    final yamlPath = _findNearestAnalysisOptionsFilePath(rootPath);
 
-    if (yamlPath == null) {
+    if (yamlPath == null || _rulesCache.containsKey(yamlPath)) {
       return;
     }
 
-    if (_rulesCache.containsKey(yamlPath)) {
-      return;
-    }
-
-    final file = PhysicalResourceProvider.INSTANCE.getFile(yamlPath);
+    final analysisOptionsFile =
+        PhysicalResourceProvider.INSTANCE.getFile(yamlPath);
 
-    final rules = _getRules(file);
+    final rules = _getRules(analysisOptionsFile);
     _rulesCache[yamlPath] = rules;
   }
 
-  String? _findNearestFileUpwards(
-    String filePath, {
-    String fileName = 'analysis_options.yaml',
-  }) {
+  String? _findNearestAnalysisOptionsFilePath(String packageRootPath) {
     final pathContext = PhysicalResourceProvider.INSTANCE.pathContext;
-    String currentDirectoryPath = pathContext.dirname(filePath);
+    String currentDirectoryPath = packageRootPath;
 
     while (pathContext.dirname(currentDirectoryPath) != currentDirectoryPath) {
-      final candidatePath = pathContext.join(currentDirectoryPath, fileName);
+      final candidatePath =
+          pathContext.join(currentDirectoryPath, 'analysis_options.yaml');
       final candidateFile =
           PhysicalResourceProvider.INSTANCE.getFile(candidatePath);
 
@@ -83,31 +79,22 @@ class AnalysisOptionsLoader {
     if (yaml is! Map) return {};
 
     final rules = <String, LintOptions>{};
-    final pluginsYaml = yaml['plugins'] as Object?;
-
-    if (pluginsYaml is Map) {
-      final solidLint = pluginsYaml['solid_lints'];
-      if (solidLint is Map) {
-        final diagnostics = solidLint['diagnostics'];
-
-        if (diagnostics is Map) {
-          for (final diag in diagnostics.entries) {
-            final ruleName = diag.key as String;
-            final value = diag.value;
-
-            if (value is bool) {
-              rules[ruleName] = LintOptions.empty(enabled: value);
-            } else if (value is Map) {
-              final map = Map<String, Object?>.from(value);
-
-              final enabled = map.remove('enabled') as bool? ?? true;
-
-              rules[ruleName] = LintOptions.fromYaml(
-                map,
-                enabled: enabled,
-              );
-            }
-          }
+
+    if (yaml
+        case {'plugins': {'solid_lints': {'diagnostics': final diagnostics?}}}
+        when diagnostics is Map) {
+      for (final MapEntry(:key, :value) in diagnostics.entries) {
+        if (key is! String) continue;
+
+        final ruleName = key;
+
+        if (value is bool) {
+          rules[ruleName] = LintOptions.empty(enabled: value);
+        } else if (value is Map) {
+          rules[ruleName] = LintOptions.fromYaml(
+            Map<String, Object?>.from(value),
+            enabled: true,
+          );
         }
       }
     }

From 5ca9f16b7a0c20d074b67cfe370cb9c8b16a502a Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Tue, 2 Jun 2026 23:54:18 +0300
Subject: [PATCH 16/21] feat: reload rules from file if newer refactor: allow
 mocking resource provider refactor: extract CachedPackageRules model

---
 .../analysis_options_loader.dart              | 35 ++++++++++++-------
 .../cached_package_rules.dart                 | 16 +++++++++
 2 files changed, 39 insertions(+), 12 deletions(-)
 create mode 100644 lib/src/common/parameter_parser/cached_package_rules.dart

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index b9d7b5be..d6d2f214 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -1,12 +1,19 @@
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:solid_lints/src/common/parameter_parser/cached_package_rules.dart';
 import 'package:solid_lints/src/common/parameter_parser/lint_options.dart';
 import 'package:yaml/yaml.dart';
 
 /// Loads and parses analysis options from a Dart project's YAML file.
 class AnalysisOptionsLoader {
-  final Map<String, Map<String, LintOptions>> _rulesCache = {};
+  final ResourceProvider _resourceProvider;
+  final Map<String, CachedPackageRules> _rulesCache = {};
+
+  /// Creates an instance of [AnalysisOptionsLoader]
+  AnalysisOptionsLoader({ResourceProvider? resourceProvider})
+      : _resourceProvider =
+            resourceProvider ?? PhysicalResourceProvider.INSTANCE;
 
   /// Gets the options for a specific rule by its name.
   LintOptions? getRuleOptions(RuleContext context, String ruleName) {
@@ -16,7 +23,7 @@ class AnalysisOptionsLoader {
     final yamlPath = _findNearestAnalysisOptionsFilePath(packageRootPath);
     if (yamlPath == null) return null;
 
-    return _rulesCache[yamlPath]?[ruleName];
+    return _rulesCache[yamlPath]?.rules[ruleName];
   }
 
   /// Loads lint rules from the analysis options file based
@@ -25,32 +32,36 @@ class AnalysisOptionsLoader {
     final packageRootPath = context.package?.root.path;
     if (packageRootPath == null) return;
 
-    _loadRules(packageRootPath);
+    _loadRulesIfNewer(packageRootPath);
   }
 
-  void _loadRules(String rootPath) {
+  void _loadRulesIfNewer(String rootPath) {
     final yamlPath = _findNearestAnalysisOptionsFilePath(rootPath);
+    if (yamlPath == null) return;
+
+    final analysisOptionsFile = _resourceProvider.getFile(yamlPath);
+    final modificationStamp = analysisOptionsFile.modificationStamp;
+    final cachedRules = _rulesCache[yamlPath];
 
-    if (yamlPath == null || _rulesCache.containsKey(yamlPath)) {
+    if (cachedRules?.modificationStamp == modificationStamp) {
       return;
     }
 
-    final analysisOptionsFile =
-        PhysicalResourceProvider.INSTANCE.getFile(yamlPath);
-
     final rules = _getRules(analysisOptionsFile);
-    _rulesCache[yamlPath] = rules;
+    _rulesCache[yamlPath] = CachedPackageRules(
+      modificationStamp: modificationStamp,
+      rules: rules,
+    );
   }
 
   String? _findNearestAnalysisOptionsFilePath(String packageRootPath) {
-    final pathContext = PhysicalResourceProvider.INSTANCE.pathContext;
+    final pathContext = _resourceProvider.pathContext;
     String currentDirectoryPath = packageRootPath;
 
     while (pathContext.dirname(currentDirectoryPath) != currentDirectoryPath) {
       final candidatePath =
           pathContext.join(currentDirectoryPath, 'analysis_options.yaml');
-      final candidateFile =
-          PhysicalResourceProvider.INSTANCE.getFile(candidatePath);
+      final candidateFile = _resourceProvider.getFile(candidatePath);
 
       if (candidateFile.exists) {
         return candidatePath;
diff --git a/lib/src/common/parameter_parser/cached_package_rules.dart b/lib/src/common/parameter_parser/cached_package_rules.dart
new file mode 100644
index 00000000..dc1f1d07
--- /dev/null
+++ b/lib/src/common/parameter_parser/cached_package_rules.dart
@@ -0,0 +1,16 @@
+import 'package:solid_lints/src/common/parameter_parser/lint_options.dart';
+
+/// Cached rules for a dart package
+class CachedPackageRules {
+  /// The last modification stamp of the analysis options file
+  final int modificationStamp;
+
+  /// Cached rules options by rule name for the package
+  final Map<String, LintOptions> rules;
+
+  /// Creates an instance of [CachedPackageRules]
+  const CachedPackageRules({
+    required this.modificationStamp,
+    required this.rules,
+  });
+}

From 73d09a5ebc5ceba20c25847449d93ea490279761 Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Tue, 2 Jun 2026 23:54:32 +0300
Subject: [PATCH 17/21] test: add AnalysisOptionsLoaderTest

---
 .../analysis_options_loader_test.dart         | 229 ++++++++++++++++++
 1 file changed, 229 insertions(+)
 create mode 100644 test/src/common/parameter_parser/analysis_options_loader_test.dart

diff --git a/test/src/common/parameter_parser/analysis_options_loader_test.dart b/test/src/common/parameter_parser/analysis_options_loader_test.dart
new file mode 100644
index 00000000..e7df2c4a
--- /dev/null
+++ b/test/src/common/parameter_parser/analysis_options_loader_test.dart
@@ -0,0 +1,229 @@
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/workspace/workspace.dart';
+import 'package:analyzer_testing/src/analysis_rule/pub_package_resolution.dart';
+import 'package:solid_lints/src/common/parameter_parser/analysis_options_loader.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(AnalysisOptionsLoaderTest);
+  });
+}
+
+@reflectiveTest
+class AnalysisOptionsLoaderTest extends PubPackageResolutionTest {
+  // TODO: use actual [Rule.lintName] after migrating to analyzer_server_plugin
+  // Can't be used right now because they have compile errors
+  static const _mockRuleThatNeedsConfigName = 'mock_rule_that_needs_config';
+  static const _mockRule2Name = 'mock_rule_2';
+  static const _cyclomaticComplexityName = 'cyclomatic_complexity';
+
+  static const _mockAnalysisOptionsContent = '''
+plugins:
+  solid_lints:
+    diagnostics:
+      $_mockRuleThatNeedsConfigName:
+        abc: def
+      $_mockRule2Name:
+        foo: bar
+        exclude:
+          - class_name: MockClass
+            method_name: mockMethod
+      $_cyclomaticComplexityName:
+        max_complexity: 10
+        exclude:
+          - class_name: MockClass
+            method_name: mockMethod
+          - method_name: mockMethod2
+  ''';
+  static const _mockDifferentAnalysisOptionsContent = '''
+plugins:
+  solid_lints:
+    diagnostics:
+      $_mockRuleThatNeedsConfigName:
+        abc: ghi
+      $_mockRule2Name:
+        foo: baz
+        exclude:
+          - class_name: MockOtherClass
+            method_name: mockOtherMethod
+      $_cyclomaticComplexityName:
+        max_complexity: 20
+        exclude:
+          - class_name: MockOtherClass
+            method_name: mockOtherMethod
+          - method_name: mockOtherMethod2
+  ''';
+
+  late AnalysisOptionsLoader analysisOptionsLoader;
+  late RuleContext mockRuleContext;
+
+  @override
+  void setUp() {
+    super.setUp();
+
+    analysisOptionsLoader =
+        AnalysisOptionsLoader(resourceProvider: resourceProvider);
+    mockRuleContext = _createMockContextForPackage(testPackageRootPath);
+
+    _writeMockAnalysisOptionsYamlFile();
+
+    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+  }
+
+  void _writeMockAnalysisOptionsYamlFile() {
+    newAnalysisOptionsYamlFile(
+      testPackageRootPath,
+      _mockAnalysisOptionsContent,
+    );
+  }
+
+  void test_cached_response_is_scoped_to_package_and_rule() {
+    const otherPackageRootPath = '/home/other';
+
+    newFolder(otherPackageRootPath);
+    newPubspecYamlFile(otherPackageRootPath, 'name: other');
+    newAnalysisOptionsYamlFile(
+      otherPackageRootPath,
+      _mockDifferentAnalysisOptionsContent,
+    );
+
+    for (final ruleName in [
+      _mockRuleThatNeedsConfigName,
+      _mockRule2Name,
+      _cyclomaticComplexityName
+    ]) {
+      final currentPackageOptions = analysisOptionsLoader.getRuleOptions(
+        mockRuleContext,
+        ruleName,
+      );
+      final otherPackageOptions = analysisOptionsLoader.getRuleOptions(
+        _createMockContextForPackage(otherPackageRootPath),
+        ruleName,
+      );
+
+      expect(
+        currentPackageOptions?.json,
+        isNot(equals(otherPackageOptions?.json)),
+      );
+    }
+  }
+
+  void test_each_rule_gets_its_options() {
+    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+
+    final mockRuleThatNeedsConfigOptions = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _mockRuleThatNeedsConfigName,
+    );
+    final mockRule2Options = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _mockRule2Name,
+    );
+    final cyclomaticComplexityOptions = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _cyclomaticComplexityName,
+    );
+
+    expect(mockRuleThatNeedsConfigOptions, isNotNull);
+    expect(mockRuleThatNeedsConfigOptions?.enabled, isTrue);
+    expect(mockRuleThatNeedsConfigOptions?.json, {'abc': 'def'});
+
+    expect(mockRule2Options, isNotNull);
+    expect(mockRule2Options?.enabled, isTrue);
+    expect(mockRule2Options?.json, {
+      'foo': 'bar',
+      'exclude': [
+        {'class_name': 'MockClass', 'method_name': 'mockMethod'},
+      ]
+    });
+
+    expect(cyclomaticComplexityOptions, isNotNull);
+    expect(cyclomaticComplexityOptions?.enabled, isTrue);
+    expect(cyclomaticComplexityOptions?.json, {
+      'max_complexity': 10,
+      'exclude': [
+        {'class_name': 'MockClass', 'method_name': 'mockMethod'},
+        {'method_name': 'mockMethod2'},
+      ]
+    });
+  }
+
+  void test_invalidates_cache_when_analysis_options_changed() {
+    final initialOptions = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _mockRuleThatNeedsConfigName,
+    );
+
+    newAnalysisOptionsYamlFile(
+      testPackageRootPath,
+      _mockDifferentAnalysisOptionsContent,
+    );
+    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+
+    final updatedOptions = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _mockRuleThatNeedsConfigName,
+    );
+
+    expect(initialOptions?.json, {'abc': 'def'});
+    expect(updatedOptions?.json, {'abc': 'ghi'});
+    expect(updatedOptions, isNot(same(initialOptions)));
+  }
+
+  void test_loads_and_parses_rule_options_from_yaml_file() {
+    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+
+    final options = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _mockRuleThatNeedsConfigName,
+    );
+
+    expect(options, isNotNull);
+    expect(options?.enabled, isTrue);
+    expect(options?.json, {'abc': 'def'});
+  }
+
+  void test_returns_cached_response_for_same_rule_name() {
+    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+
+    final firstOptions = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _mockRuleThatNeedsConfigName,
+    );
+    final secondOptions = analysisOptionsLoader.getRuleOptions(
+      mockRuleContext,
+      _mockRuleThatNeedsConfigName,
+    );
+
+    expect(secondOptions, same(firstOptions));
+  }
+
+  RuleContext _createMockContextForPackage(String packageRootPath) {
+    return _TestRuleContext(
+      _TestWorkspacePackage(getFolder(packageRootPath)),
+    );
+  }
+}
+
+class _TestRuleContext implements RuleContext {
+  @override
+  final WorkspacePackage? package;
+
+  _TestRuleContext(this.package);
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class _TestWorkspacePackage implements WorkspacePackage {
+  @override
+  final Folder root;
+
+  _TestWorkspacePackage(this.root);
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}

From ca08701a0fd697f14fc148ab707990f60ba830ac Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Wed, 3 Jun 2026 21:12:30 +0300
Subject: [PATCH 18/21] feat(SolidLintRule): add parameter parsing refactor:
 use Map<String, Object?> instead of LintOptions as the enabled field is
 implicitly true for all rules that the analyzer processes remove RuleConfig
 as it is no longer needed

---
 .../analysis_options_loader.dart              |  43 ++--
 .../common/parameter_parser/lint_options.dart | 232 ------------------
 lib/src/models/rule_config.dart               |  43 ----
 lib/src/models/solid_lint_rule.dart           |  43 +++-
 .../analysis_options_loader_test.dart         |  30 +--
 5 files changed, 63 insertions(+), 328 deletions(-)
 delete mode 100644 lib/src/common/parameter_parser/lint_options.dart
 delete mode 100644 lib/src/models/rule_config.dart

diff --git a/lib/src/common/parameter_parser/analysis_options_loader.dart b/lib/src/common/parameter_parser/analysis_options_loader.dart
index d6d2f214..b397bb08 100644
--- a/lib/src/common/parameter_parser/analysis_options_loader.dart
+++ b/lib/src/common/parameter_parser/analysis_options_loader.dart
@@ -2,7 +2,6 @@ import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:solid_lints/src/common/parameter_parser/cached_package_rules.dart';
-import 'package:solid_lints/src/common/parameter_parser/lint_options.dart';
 import 'package:yaml/yaml.dart';
 
 /// Loads and parses analysis options from a Dart project's YAML file.
@@ -16,7 +15,7 @@ class AnalysisOptionsLoader {
             resourceProvider ?? PhysicalResourceProvider.INSTANCE;
 
   /// Gets the options for a specific rule by its name.
-  LintOptions? getRuleOptions(RuleContext context, String ruleName) {
+  Map<String, Object?>? getRuleOptions(RuleContext context, String ruleName) {
     final packageRootPath = context.package?.root.path;
     if (packageRootPath == null) return null;
 
@@ -26,16 +25,16 @@ class AnalysisOptionsLoader {
     return _rulesCache[yamlPath]?.rules[ruleName];
   }
 
-  /// Loads lint rules from the analysis options file based
-  /// on the provided [RuleContext].
-  void loadRulesFromContext(RuleContext context) {
+  /// Loads lint rules from the analysis options file for all rules
+  /// using the provided [RuleContext].
+  void loadRulesOptionsFromContext(RuleContext context) {
     final packageRootPath = context.package?.root.path;
     if (packageRootPath == null) return;
 
-    _loadRulesIfNewer(packageRootPath);
+    _loadRulesOptionsIfNewer(packageRootPath);
   }
 
-  void _loadRulesIfNewer(String rootPath) {
+  void _loadRulesOptionsIfNewer(String rootPath) {
     final yamlPath = _findNearestAnalysisOptionsFilePath(rootPath);
     if (yamlPath == null) return;
 
@@ -74,7 +73,7 @@ class AnalysisOptionsLoader {
     return null;
   }
 
-  Map<String, LintOptions> _getRules(File? analysisOptionsFile) {
+  Map<String, Map<String, Object?>> _getRules(File? analysisOptionsFile) {
     if (analysisOptionsFile == null || !analysisOptionsFile.exists) {
       return {};
     }
@@ -87,29 +86,19 @@ class AnalysisOptionsLoader {
       return {};
     }
 
-    if (yaml is! Map) return {};
-
-    final rules = <String, LintOptions>{};
-
     if (yaml
         case {'plugins': {'solid_lints': {'diagnostics': final diagnostics?}}}
         when diagnostics is Map) {
-      for (final MapEntry(:key, :value) in diagnostics.entries) {
-        if (key is! String) continue;
-
-        final ruleName = key;
-
-        if (value is bool) {
-          rules[ruleName] = LintOptions.empty(enabled: value);
-        } else if (value is Map) {
-          rules[ruleName] = LintOptions.fromYaml(
-            Map<String, Object?>.from(value),
-            enabled: true,
-          );
-        }
-      }
+      return Map.fromEntries(
+        diagnostics.entries.where((e) => e.key is String && e.value is Map).map(
+              (e) => MapEntry(
+                e.key as String,
+                Map<String, Object?>.from(e.value as Map),
+              ),
+            ),
+      );
     }
 
-    return rules;
+    return {};
   }
 }
diff --git a/lib/src/common/parameter_parser/lint_options.dart b/lib/src/common/parameter_parser/lint_options.dart
deleted file mode 100644
index 7880b42d..00000000
--- a/lib/src/common/parameter_parser/lint_options.dart
+++ /dev/null
@@ -1,232 +0,0 @@
-//                                Apache License
-//                          Version 2.0, January 2004
-//                       http://www.apache.org/licenses/
-
-//  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-//  1. Definitions.
-
-//     "License" shall mean the terms and conditions for use, reproduction,
-//     and distribution as defined by Sections 1 through 9 of this document.
-
-//     "Licensor" shall mean the copyright owner or entity authorized by
-//     the copyright owner that is granting the License.
-
-//     "Legal Entity" shall mean the union of the acting entity and all
-//     other entities that control, are controlled by, or are under common
-//     control with that entity. For the purposes of this definition,
-//     "control" means (i) the power, direct or indirect, to cause the
-//     direction or management of such entity, whether by contract or
-//     otherwise, or (ii) ownership of fifty percent (50%) or more of the
-//     outstanding shares, or (iii) beneficial ownership of such entity.
-
-//     "You" (or "Your") shall mean an individual or Legal Entity
-//     exercising permissions granted by this License.
-
-//     "Source" form shall mean the preferred form for making modifications,
-//     including but not limited to software source code, documentation
-//     source, and configuration files.
-
-//     "Object" form shall mean any form resulting from mechanical
-//     transformation or translation of a Source form, including but
-//     not limited to compiled object code, generated documentation,
-//     and conversions to other media types.
-
-//     "Work" shall mean the work of authorship, whether in Source or
-//     Object form, made available under the License, as indicated by a
-//     copyright notice that is included in or attached to the work
-//     (an example is provided in the Appendix below).
-
-//     "Derivative Works" shall mean any work, whether in Source or Object
-//     form, that is based on (or derived from) the Work and for which the
-//     editorial revisions, annotations, elaborations, or other modifications
-//     represent, as a whole, an original work of authorship. For the purposes
-//     of this License, Derivative Works shall not include works that remain
-//     separable from, or merely link (or bind by name) to the interfaces of,
-//     the Work and Derivative Works thereof.
-
-//     "Contribution" shall mean any work of authorship, including
-//     the original version of the Work and any modifications or additions
-//     to that Work or Derivative Works thereof, that is intentionally
-//     submitted to Licensor for inclusion in the Work by the copyright owner
-//     or by an individual or Legal Entity authorized to submit on behalf of
-//     the copyright owner. For the purposes of this definition, "submitted"
-//     means any form of electronic, verbal, or written communication sent
-//     to the Licensor or its representatives, including but not limited to
-//     communication on electronic mailing lists, source code control systems,
-//     and issue tracking systems that are managed by, or on behalf of, the
-//     Licensor for the purpose of discussing and improving the Work, but
-//     excluding communication that is conspicuously marked or otherwise
-//     designated in writing by the copyright owner as "Not a Contribution."
-
-//     "Contributor" shall mean Licensor and any individual or Legal Entity
-//     on behalf of whom a Contribution has been received by Licensor and
-//     subsequently incorporated within the Work.
-
-//  2. Grant of Copyright License. Subject to the terms and conditions of
-//     this License, each Contributor hereby grants to You a perpetual,
-//     worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-//     copyright license to reproduce, prepare Derivative Works of,
-//     publicly display, publicly perform, sublicense, and distribute the
-//     Work and such Derivative Works in Source or Object form.
-
-//  3. Grant of Patent License. Subject to the terms and conditions of
-//     this License, each Contributor hereby grants to You a perpetual,
-//     worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-//     (except as stated in this section) patent license to make, have made,
-//     use, offer to sell, sell, import, and otherwise transfer the Work,
-//     where such license applies only to those patent claims licensable
-//     by such Contributor that are necessarily infringed by their
-//     Contribution(s) alone or by combination of their Contribution(s)
-//     with the Work to which such Contribution(s) was submitted. If You
-//     institute patent litigation against any entity (including a
-//     cross-claim or counterclaim in a lawsuit) alleging that the Work
-//     or a Contribution incorporated within the Work constitutes direct
-//     or contributory patent infringement, then any patent licenses
-//     granted to You under this License for that Work shall terminate
-//     as of the date such litigation is filed.
-
-//  4. Redistribution. You may reproduce and distribute copies of the
-//     Work or Derivative Works thereof in any medium, with or without
-//     modifications, and in Source or Object form, provided that You
-//     meet the following conditions:
-
-//     (a) You must give any other recipients of the Work or
-//         Derivative Works a copy of this License; and
-
-//     (b) You must cause any modified files to carry prominent notices
-//         stating that You changed the files; and
-
-//     (c) You must retain, in the Source form of any Derivative Works
-//         that You distribute, all copyright, patent, trademark, and
-//         attribution notices from the Source form of the Work,
-//         excluding those notices that do not pertain to any part of
-//         the Derivative Works; and
-
-//     (d) If the Work includes a "NOTICE" text file as part of its
-//         distribution, then any Derivative Works that You distribute must
-//         include a readable copy of the attribution notices contained
-//         within such NOTICE file, excluding those notices that do not
-//         pertain to any part of the Derivative Works, in at least one
-//         of the following places: within a NOTICE text file distributed
-//         as part of the Derivative Works; within the Source form or
-//         documentation, if provided along with the Derivative Works; or,
-//         within a display generated by the Derivative Works, if and
-//         wherever such third-party notices normally appear. The contents
-//         of the NOTICE file are for informational purposes only and
-//         do not modify the License. You may add Your own attribution
-//         notices within Derivative Works that You distribute, alongside
-//         or as an addendum to the NOTICE text from the Work, provided
-//         that such additional attribution notices cannot be construed
-//         as modifying the License.
-
-//     You may add Your own copyright statement to Your modifications and
-//     may provide additional or different license terms and conditions
-//     for use, reproduction, or distribution of Your modifications, or
-//     for any such Derivative Works as a whole, provided Your use,
-//     reproduction, and distribution of the Work otherwise complies with
-//     the conditions stated in this License.
-
-//  5. Submission of Contributions. Unless You explicitly state otherwise,
-//     any Contribution intentionally submitted for inclusion in the Work
-//     by You to the Licensor shall be under the terms and conditions of
-//     this License, without any additional terms or conditions.
-//     Notwithstanding the above, nothing herein shall supersede or modify
-//     the terms of any separate license agreement you may have executed
-//     with Licensor regarding such Contributions.
-
-//  6. Trademarks. This License does not grant permission to use the trade
-//     names, trademarks, service marks, or product names of the Licensor,
-//     except as required for reasonable and customary use in describing the
-//     origin of the Work and reproducing the content of the NOTICE file.
-
-//  7. Disclaimer of Warranty. Unless required by applicable law or
-//     agreed to in writing, Licensor provides the Work (and each
-//     Contributor provides its Contributions) on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-//     implied, including, without limitation, any warranties or conditions
-//     of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-//     PARTICULAR PURPOSE. You are solely responsible for determining the
-//     appropriateness of using or redistributing the Work and assume any
-//     risks associated with Your exercise of permissions under this License.
-
-//  8. Limitation of Liability. In no event and under no legal theory,
-//     whether in tort (including negligence), contract, or otherwise,
-//     unless required by applicable law (such as deliberate and grossly
-//     negligent acts) or agreed to in writing, shall any Contributor be
-//     liable to You for damages, including any direct, indirect, special,
-//     incidental, or consequential damages of any character arising as a
-//     result of this License or out of the use or inability to use the
-//     Work (including but not limited to damages for loss of goodwill,
-//     work stoppage, computer failure or malfunction, or any and all
-//     other commercial damages or losses), even if such Contributor
-//     has been advised of the possibility of such damages.
-
-//  9. Accepting Warranty or Additional Liability. While redistributing
-//     the Work or Derivative Works thereof, You may choose to offer,
-//     and charge a fee for, acceptance of support, warranty, indemnity,
-//     or other liability obligations and/or rights consistent with this
-//     License. However, in accepting such obligations, You may act only
-//     on Your own behalf and on Your sole responsibility, not on behalf
-//     of any other Contributor, and only if You agree to indemnify,
-//     defend, and hold each Contributor harmless for any liability
-//     incurred by, or claims asserted against, such Contributor by reason
-//     of your accepting any such warranty or additional liability.
-
-//  END OF TERMS AND CONDITIONS
-
-//  APPENDIX: How to apply the Apache License to your work.
-
-//     To apply the Apache License to your work, attach the following
-//     boilerplate notice, with the fields enclosed by brackets "[]"
-//     replaced with your own identifying information. (Don't include
-//     the brackets!)  The text should be enclosed in the appropriate
-//     comment syntax for the file format. We also recommend that a
-//     file or class name and description of purpose be included on the
-//     same "printed page" as the copyright notice for easier
-//     identification within third-party archives.
-
-//  Copyright 2020 Invertase Limited
-
-//  Licensed under the Apache License, Version 2.0 (the "License");
-//  you may not use this file except in compliance with the License.
-//  You may obtain a copy of the License at
-
-//      http://www.apache.org/licenses/LICENSE-2.0
-
-//  Unless required by applicable law or agreed to in writing, software
-//  distributed under the License is distributed on an "AS IS" BASIS,
-//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//  See the License for the specific language governing permissions and
-//  limitations under the License.
-
-import 'package:analyzer/analysis_rule/analysis_rule.dart';
-import 'package:collection/collection.dart';
-
-/// Option information for a specific [AnalysisRule].
-class LintOptions {
-  /// Whether the configuration enables/disables the lint rule.
-  final bool enabled;
-
-  /// Extra configurations for a [AnalysisRule].
-  final Map<String, Object?> json;
-
-  @override
-  int get hashCode => Object.hash(
-        enabled,
-        const MapEquality<String, Object?>().hash(json),
-      );
-
-  /// Options with no [json]
-  const LintOptions.empty({required this.enabled}) : json = const {};
-
-  /// Creates a [LintOptions] from YAML.
-  const LintOptions.fromYaml(Map<String, Object?> yaml, {required this.enabled})
-      : json = yaml;
-
-  @override
-  bool operator ==(Object other) =>
-      other is LintOptions &&
-      other.enabled == enabled &&
-      const MapEquality<String, Object?>().equals(other.json, json);
-}
diff --git a/lib/src/models/rule_config.dart b/lib/src/models/rule_config.dart
deleted file mode 100644
index 35c35b96..00000000
--- a/lib/src/models/rule_config.dart
+++ /dev/null
@@ -1,43 +0,0 @@
-import 'package:analyzer/error/error.dart' as error;
-import 'package:custom_lint_builder/custom_lint_builder.dart';
-
-/// Type definition of a value factory which allows us to map data from
-/// YAML configuration to an object of type [T].
-typedef RuleParameterParser<T> = T Function(Map<String, Object?> json);
-
-/// Type definition for a problem message factory after finding a problem
-/// by a given lint.
-typedef RuleProblemFactory<T> = String Function(T value);
-
-/// [RuleConfig] allows us to quickly parse a lint rule and
-/// declare basic configuration for it.
-class RuleConfig<T extends Object?> {
-  /// Constructor for [RuleConfig] model.
-  RuleConfig({
-    required this.name,
-    required CustomLintConfigs configs,
-    required RuleProblemFactory<T> problemMessage,
-    RuleParameterParser<T>? paramsParser,
-  })  : enabled = configs.rules[name]?.enabled ?? false,
-        parameters = paramsParser?.call(configs.rules[name]?.json ?? {}) as T,
-        _problemMessageFactory = problemMessage;
-
-  /// This lint rule represents the error.
-  final String name;
-
-  /// A flag which indicates whether this rule was enabled by the user.
-  final bool enabled;
-
-  /// Value with a configuration for a particular rule.
-  final T parameters;
-
-  /// Factory for generating error messages.
-  final RuleProblemFactory<T> _problemMessageFactory;
-
-  /// [LintCode] which is generated based on the provided data.
-  LintCode get lintCode => LintCode(
-        name: name,
-        problemMessage: _problemMessageFactory(parameters),
-        errorSeverity: error.DiagnosticSeverity.WARNING,
-      );
-}
diff --git a/lib/src/models/solid_lint_rule.dart b/lib/src/models/solid_lint_rule.dart
index a536eb4f..54f07fd5 100644
--- a/lib/src/models/solid_lint_rule.dart
+++ b/lib/src/models/solid_lint_rule.dart
@@ -1,16 +1,41 @@
-import 'package:custom_lint_builder/custom_lint_builder.dart';
-import 'package:solid_lints/src/models/rule_config.dart';
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:solid_lints/src/common/parameter_parser/analysis_options_loader.dart';
+
+/// A function that parses the rule parameters from analysis options json
+typedef RuleParametersParser<T> = T Function(Map<String, Object?>);
 
 /// A base class for emitting information about
 /// issues with user's `.dart` files.
-abstract class SolidLintRule<T extends Object?> extends DartLintRule {
+abstract class SolidLintRule<T extends Object?> extends AnalysisRule {
+  final AnalysisOptionsLoader? _analysisOptionsLoader;
+
+  final RuleParametersParser<T>? _parametersParser;
+
   /// Constructor for [SolidLintRule] model.
-  SolidLintRule(this.config) : super(code: config.lintCode);
+  SolidLintRule({
+    required super.name,
+    required super.description,
+    super.state,
+  })  : _analysisOptionsLoader = null,
+        _parametersParser = null;
+
+  /// Constructor for [SolidLintRule] model with parameters.
+  SolidLintRule.withParameters({
+    required AnalysisOptionsLoader analysisOptionsLoader,
+    required RuleParametersParser<T> parametersParser,
+    required super.name,
+    required super.description,
+    super.state,
+  })  : _analysisOptionsLoader = analysisOptionsLoader,
+        _parametersParser = parametersParser;
 
-  /// Configuration for a particular rule with all the
-  /// defined custom parameters.
-  final RuleConfig<T> config;
+  /// Reads the rule parameters from analysis options and parses them to [T]
+  T? getParametersForContext(RuleContext context) {
+    final unparsedParameters =
+        _analysisOptionsLoader?.getRuleOptions(context, name);
+    if (unparsedParameters == null) return null;
 
-  /// A flag which indicates whether this rule was enabled by the user.
-  bool get enabled => config.enabled;
+    return _parametersParser?.call(unparsedParameters);
+  }
 }
diff --git a/test/src/common/parameter_parser/analysis_options_loader_test.dart b/test/src/common/parameter_parser/analysis_options_loader_test.dart
index e7df2c4a..a727136f 100644
--- a/test/src/common/parameter_parser/analysis_options_loader_test.dart
+++ b/test/src/common/parameter_parser/analysis_options_loader_test.dart
@@ -70,7 +70,7 @@ plugins:
 
     _writeMockAnalysisOptionsYamlFile();
 
-    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+    analysisOptionsLoader.loadRulesOptionsFromContext(mockRuleContext);
   }
 
   void _writeMockAnalysisOptionsYamlFile() {
@@ -105,14 +105,14 @@ plugins:
       );
 
       expect(
-        currentPackageOptions?.json,
-        isNot(equals(otherPackageOptions?.json)),
+        currentPackageOptions,
+        isNot(equals(otherPackageOptions)),
       );
     }
   }
 
   void test_each_rule_gets_its_options() {
-    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+    analysisOptionsLoader.loadRulesOptionsFromContext(mockRuleContext);
 
     final mockRuleThatNeedsConfigOptions = analysisOptionsLoader.getRuleOptions(
       mockRuleContext,
@@ -128,12 +128,10 @@ plugins:
     );
 
     expect(mockRuleThatNeedsConfigOptions, isNotNull);
-    expect(mockRuleThatNeedsConfigOptions?.enabled, isTrue);
-    expect(mockRuleThatNeedsConfigOptions?.json, {'abc': 'def'});
+    expect(mockRuleThatNeedsConfigOptions, {'abc': 'def'});
 
     expect(mockRule2Options, isNotNull);
-    expect(mockRule2Options?.enabled, isTrue);
-    expect(mockRule2Options?.json, {
+    expect(mockRule2Options, {
       'foo': 'bar',
       'exclude': [
         {'class_name': 'MockClass', 'method_name': 'mockMethod'},
@@ -141,8 +139,7 @@ plugins:
     });
 
     expect(cyclomaticComplexityOptions, isNotNull);
-    expect(cyclomaticComplexityOptions?.enabled, isTrue);
-    expect(cyclomaticComplexityOptions?.json, {
+    expect(cyclomaticComplexityOptions, {
       'max_complexity': 10,
       'exclude': [
         {'class_name': 'MockClass', 'method_name': 'mockMethod'},
@@ -161,20 +158,20 @@ plugins:
       testPackageRootPath,
       _mockDifferentAnalysisOptionsContent,
     );
-    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+    analysisOptionsLoader.loadRulesOptionsFromContext(mockRuleContext);
 
     final updatedOptions = analysisOptionsLoader.getRuleOptions(
       mockRuleContext,
       _mockRuleThatNeedsConfigName,
     );
 
-    expect(initialOptions?.json, {'abc': 'def'});
-    expect(updatedOptions?.json, {'abc': 'ghi'});
+    expect(initialOptions, {'abc': 'def'});
+    expect(updatedOptions, {'abc': 'ghi'});
     expect(updatedOptions, isNot(same(initialOptions)));
   }
 
   void test_loads_and_parses_rule_options_from_yaml_file() {
-    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+    analysisOptionsLoader.loadRulesOptionsFromContext(mockRuleContext);
 
     final options = analysisOptionsLoader.getRuleOptions(
       mockRuleContext,
@@ -182,12 +179,11 @@ plugins:
     );
 
     expect(options, isNotNull);
-    expect(options?.enabled, isTrue);
-    expect(options?.json, {'abc': 'def'});
+    expect(options, {'abc': 'def'});
   }
 
   void test_returns_cached_response_for_same_rule_name() {
-    analysisOptionsLoader.loadRulesFromContext(mockRuleContext);
+    analysisOptionsLoader.loadRulesOptionsFromContext(mockRuleContext);
 
     final firstOptions = analysisOptionsLoader.getRuleOptions(
       mockRuleContext,

From 387f6f9b6d8af5f9fedb8c00b032085ce4156dec Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Thu, 4 Jun 2026 01:33:35 +0300
Subject: [PATCH 19/21] fix: use Map<String, Object?> for raw rule config

---
 lib/src/common/parameter_parser/cached_package_rules.dart | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/src/common/parameter_parser/cached_package_rules.dart b/lib/src/common/parameter_parser/cached_package_rules.dart
index dc1f1d07..a65201d9 100644
--- a/lib/src/common/parameter_parser/cached_package_rules.dart
+++ b/lib/src/common/parameter_parser/cached_package_rules.dart
@@ -1,12 +1,10 @@
-import 'package:solid_lints/src/common/parameter_parser/lint_options.dart';
-
 /// Cached rules for a dart package
 class CachedPackageRules {
   /// The last modification stamp of the analysis options file
   final int modificationStamp;
 
   /// Cached rules options by rule name for the package
-  final Map<String, LintOptions> rules;
+  final Map<String, Map<String, Object?>> rules;
 
   /// Creates an instance of [CachedPackageRules]
   const CachedPackageRules({

From 16b22b6bc59feb01b41d04464dadbf58be0c7a6b Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Thu, 4 Jun 2026 01:33:42 +0300
Subject: [PATCH 20/21] fix: method name

---
 lib/src/lints/avoid_global_state/avoid_global_state_rule.dart | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart b/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart
index 6586673f..a027f402 100644
--- a/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart
+++ b/lib/src/lints/avoid_global_state/avoid_global_state_rule.dart
@@ -66,7 +66,7 @@ class AvoidGlobalStateRule extends AnalysisRule {
   ) {
     final visitor = AvoidGlobalStateVisitor(this);
 
-    _analysisLoader.loadRulesFromContext(context);
+    _analysisLoader.loadRulesOptionsFromContext(context);
     // To get the options of the rule:
     // _analysisLoader.getRuleOptions(context, lintName);
 

From a12289803c44ddf82291f7d99b23444b035de712 Mon Sep 17 00:00:00 2001
From: Andrew Bekhiet <andrew.bekhiet@solid.software>
Date: Thu, 4 Jun 2026 01:34:14 +0300
Subject: [PATCH 21/21] fix: make sure rules options are loaded before getting
 parameters

---
 lib/src/models/solid_lint_rule.dart | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/src/models/solid_lint_rule.dart b/lib/src/models/solid_lint_rule.dart
index 54f07fd5..9f5bee56 100644
--- a/lib/src/models/solid_lint_rule.dart
+++ b/lib/src/models/solid_lint_rule.dart
@@ -32,6 +32,8 @@ abstract class SolidLintRule<T extends Object?> extends AnalysisRule {
 
   /// Reads the rule parameters from analysis options and parses them to [T]
   T? getParametersForContext(RuleContext context) {
+    _analysisOptionsLoader?.loadRulesOptionsFromContext(context);
+
     final unparsedParameters =
         _analysisOptionsLoader?.getRuleOptions(context, name);
     if (unparsedParameters == null) return null;