feat: add SonarLint configuration and improve dependency analysis logic

Author: glebournault

.sonarlint/CodeLineCounter.json

@@ -0,0 +1,4 @@
+{
+    "sonarCloudOrganization": "magic5644",
+    "projectKey": "magic5644_codeLineCounter"
+}

CodeLineCounter/Services/DependencyAnalyzer.cs

@@ -125,8 +125,8 @@ public static void AnalyzeFile(string filePath, string sourceCode)
                             .Usings.FirstOrDefault()?
                             .Name?.ToString() ?? "",
                         TargetClass = dependency.Split('.')[(dependency.Split('.').Length - 1)],
-                        TargetNamespace = dependency.Contains(".") ? dependency.Substring(0, dependency.LastIndexOf('.')) : "",
-                        TargetAssembly = dependency.Contains(".") ? dependency.Substring(0, dependency.LastIndexOf('.')) : "",
+                        TargetNamespace = dependency.Contains('.') ? dependency.Substring(0, dependency.LastIndexOf('.')) : "",
+                        TargetAssembly = dependency.Contains('.') ? dependency.Substring(0, dependency.LastIndexOf('.')) : "",
                         FilePath = filePath,
                         StartLine = classDeclaration.GetLocation().GetLineSpan().StartLinePosition.Line
                     };
@@ -150,7 +150,7 @@ public static void AnalyzeFile(string filePath, string sourceCode)
             });
         }
 
-        private static IEnumerable<string> ExtractDependencies(ClassDeclarationSyntax classDeclaration)
+        private static HashSet<string> ExtractDependencies(ClassDeclarationSyntax classDeclaration)
         {
             var dependencies = new HashSet<string>();
             var usings = GetUsingsWithCurrentNamespace(classDeclaration);
@@ -278,15 +278,15 @@ private static string GetFullTypeNameFromSymbol(string typeName, IEnumerable<str
             if (string.IsNullOrEmpty(typeName))
                 return typeName;
 
-            if (!typeName.Contains("<"))
+            if (!typeName.Contains('<'))
                 return ResolveSimpleTypeName(typeName, usings);
 
             return HandleGenericType(typeName, usings);
         }
 
         private static string ResolveSimpleTypeName(string typeName, IEnumerable<string?> usings)
         {
-            if (typeName.Contains("."))
+            if (typeName.Contains('.'))
                 return typeName;
 
             return FindTypeInUsings(typeName, usings);
@@ -308,7 +308,7 @@ private static string FindTypeInUsings(string typeName, IEnumerable<string?> usi
         private static string HandleGenericType(string typeName, IEnumerable<string?> usings)
         {
             var parts = SplitGenericType(typeName);
-            return string.Join("", parts.Select(p => p.Contains("<")
+            return string.Join("", parts.Select(p => p.Contains('<')
                 ? p
                 : GetFullTypeNameFromSymbol(p, usings)));
         }

CodeLineCounter/Services/DependencyGraphGenerator.cs

@@ -118,30 +118,36 @@ private static void GroupByNamespace(Dictionary<string, (int incoming, int outgo
             }
 
             // Group by namespace
-            if (!namespaceGroups.ContainsKey(dep.SourceNamespace))
+            if (!namespaceGroups.TryGetValue(dep.SourceNamespace, out var sourceNamespaceList))
             {
-                namespaceGroups[dep.SourceNamespace] = new List<string>();
+                sourceNamespaceList = [];
+                namespaceGroups[dep.SourceNamespace] = sourceNamespaceList;
+
             }
-            if (!namespaceGroups.ContainsKey(dep.TargetNamespace))
+            if (!sourceNamespaceList.Contains(dep.SourceClass))
             {
-                namespaceGroups[dep.TargetNamespace] = new List<string>();
+                sourceNamespaceList.Add(dep.SourceClass);
             }
 
-            if (!namespaceGroups[dep.SourceNamespace].Contains(dep.SourceClass))
+            if (!namespaceGroups.TryGetValue(dep.TargetNamespace, out var targetNamespaceList))
             {
-                namespaceGroups[dep.SourceNamespace].Add(dep.SourceClass);
+                targetNamespaceList = [];
+                namespaceGroups[dep.TargetNamespace] = targetNamespaceList;
             }
-            if (!namespaceGroups[dep.TargetNamespace].Contains(dep.TargetClass))
+  
+            if (!targetNamespaceList.Contains(dep.TargetClass))
             {
-                namespaceGroups[dep.TargetNamespace].Add(dep.TargetClass);
+                targetNamespaceList.Add(dep.TargetClass);
             }
         }
 
         private static async Task CompileGraphAndWriteToFile(string outputPath, DotGraph graph)
         {
             await using var writer = new StringWriter();
-            var options = new CompilationOptions();
-            options.Indented = true;
+            var options = new CompilationOptions
+            {
+                Indented = true
+            };
             var context = new CompilationContext(writer, options);
             graph.Directed = true;
             context.DirectedGraph = true;

CodeLineCounter/Utils/CoreUtils.cs

@@ -49,7 +49,7 @@ public static (bool Verbose, string? DirectoryPath, bool Help, ExportFormat form
                             }
                             else
                             {
-                                Console.WriteLine($"Invalid format: {formatString}. Valid formats are: {string.Join(", ", Enum.GetNames(typeof(ExportFormat)))}. Using default format {format}");
+                                Console.WriteLine($"Invalid format: {formatString}. Valid formats are: {string.Join(", ", Enum.GetNames<ExportFormat>())}. Using default format {format}");
                             }
                         }
                         break;

CodeLineCounter/Utils/DataExporter.cs

@@ -15,18 +15,17 @@ public static class DataExporter
 
         public static void Export<T>(string filePath, T data, CoreUtils.ExportFormat format) where T : class
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
 
-            ExportCollection(filePath, new List<T> { data }, format);
+            ExportCollection(filePath, [data], format);
         }
 
         public static void ExportCollection<T>(string filePath, IEnumerable<T> data, CoreUtils.ExportFormat format) where T : class
         {
             if (string.IsNullOrEmpty(filePath))
                 throw new ArgumentException("File path cannot be null or empty", nameof(filePath));
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            
+            ArgumentNullException.ThrowIfNull(data);
 
             try
             {