Improved yaml parser and added the analysis_options loader

Author: Dariaa14

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(),
     );

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);
   }
 }

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),
+      );
+}