Complete folder and glob pattern support with documentation

Co-authored-by: eNeRGy164 <[email protected]>

Author: Copilot

README.md

@@ -28,7 +28,20 @@ dotnet tool install --global DendroDocs.Tool
 Example usage:
 
 ```shell
+# Analyze a solution file
 dendrodocs-analyze --solution G:\DendroDocs\dotnet-shared-lib\DendroDocs.Shared.sln --output shared.json --pretty --verbose --exclude G:\DendroDocs\dotnet-shared-lib\build\_build.csproj
+
+# Analyze a single project file
+dendrodocs-analyze --project MyProject.csproj --output project.json --pretty
+
+# Analyze all projects in a folder
+dendrodocs-analyze --folder /path/to/projects --output folder.json --pretty
+
+# Use glob patterns to select specific projects
+dendrodocs-analyze --folder "src/**/*.csproj" --output matched.json --pretty
+
+# Exclude specific projects when analyzing a folder
+dendrodocs-analyze --folder /path/to/projects --exclude /path/to/unwanted.csproj,/path/to/test.csproj --output filtered.json
 ```
 
 ## Output

src/DendroDocs.Tool/AnalyzerSetup.cs

@@ -86,59 +86,70 @@ private static IEnumerable<string> DiscoverProjectFiles(string folderPathOrPatte
             return Directory.GetFiles(folderPathOrPattern, "*.csproj", SearchOption.AllDirectories);
         }
 
-        // Treat as a glob pattern
+        // Handle glob patterns
         var matcher = new Matcher();
 
-        // If the pattern doesn't contain wildcards, assume it's a folder and add /**/*.csproj
+        // If the pattern doesn't contain wildcards, assume it's a folder that doesn't exist
         if (!folderPathOrPattern.Contains('*') && !folderPathOrPattern.Contains('?'))
         {
-            var basePath = folderPathOrPattern;
-            if (!basePath.EndsWith(Path.DirectorySeparatorChar))
-            {
-                basePath += Path.DirectorySeparatorChar;
-            }
-            matcher.AddInclude($"**/*.csproj");
-            
-            // Use current directory as base if path doesn't exist as a directory
-            var baseDirectory = Directory.Exists(folderPathOrPattern) ? folderPathOrPattern : Directory.GetCurrentDirectory();
-            var result = matcher.Execute(new DirectoryInfoWrapper(new DirectoryInfo(baseDirectory)));
-            return result.Files.Select(f => Path.Combine(baseDirectory, f.Path));
+            throw new DirectoryNotFoundException($"Folder not found: {folderPathOrPattern}");
+        }
+
+        // Handle as a glob pattern
+        string baseDirectory;
+        string pattern;
+        
+        // Check if pattern is absolute or relative
+        if (Path.IsPathRooted(folderPathOrPattern))
+        {
+            // Absolute path - extract base directory and relative pattern
+            var parts = SplitAbsolutePattern(folderPathOrPattern);
+            baseDirectory = parts.BaseDirectory;
+            pattern = parts.Pattern;
         }
         else
         {
-            // Handle as a true glob pattern
-            matcher.AddInclude(folderPathOrPattern);
-            
-            // Determine base directory from the pattern
-            var baseDirectory = GetBasDirectoryFromPattern(folderPathOrPattern);
-            var result = matcher.Execute(new DirectoryInfoWrapper(new DirectoryInfo(baseDirectory)));
-            return result.Files.Select(f => Path.Combine(baseDirectory, f.Path));
+            // Relative path
+            baseDirectory = Directory.GetCurrentDirectory();
+            pattern = folderPathOrPattern;
         }
+
+        matcher.AddInclude(pattern);
+        var result = matcher.Execute(new DirectoryInfoWrapper(new DirectoryInfo(baseDirectory)));
+        return result.Files.Select(f => Path.Combine(baseDirectory, f.Path));
     }
 
-    private static string GetBasDirectoryFromPattern(string pattern)
+    private static (string BaseDirectory, string Pattern) SplitAbsolutePattern(string absolutePattern)
     {
-        // Find the first occurrence of wildcards and take the directory part before it
+        // Find the first wildcard
         var wildcardIndex = Math.Min(
-            pattern.IndexOf('*') >= 0 ? pattern.IndexOf('*') : int.MaxValue,
-            pattern.IndexOf('?') >= 0 ? pattern.IndexOf('?') : int.MaxValue
+            absolutePattern.IndexOf('*') >= 0 ? absolutePattern.IndexOf('*') : int.MaxValue,
+            absolutePattern.IndexOf('?') >= 0 ? absolutePattern.IndexOf('?') : int.MaxValue
         );
 
         if (wildcardIndex == int.MaxValue)
         {
-            // No wildcards, use the pattern as is if it's a directory
-            return Directory.Exists(pattern) ? pattern : Directory.GetCurrentDirectory();
+            // No wildcards found, treat as directory
+            return (absolutePattern, "**/*.csproj");
         }
 
-        var basePart = pattern.Substring(0, wildcardIndex);
+        // Find the last directory separator before the wildcard
+        var basePart = absolutePattern.Substring(0, wildcardIndex);
         var lastSeparator = basePart.LastIndexOf(Path.DirectorySeparatorChar);
 
         if (lastSeparator >= 0)
         {
             var baseDir = basePart.Substring(0, lastSeparator);
-            return Directory.Exists(baseDir) ? baseDir : Directory.GetCurrentDirectory();
+            var relativePattern = absolutePattern.Substring(lastSeparator + 1);
+            
+            // Ensure base directory exists
+            if (Directory.Exists(baseDir))
+            {
+                return (baseDir, relativePattern);
+            }
         }
 
-        return Directory.GetCurrentDirectory();
+        // Fallback to current directory
+        return (Directory.GetCurrentDirectory(), absolutePattern);
     }
 }

src/DendroDocs.Tool/Options.cs

@@ -10,7 +10,7 @@ public class Options
         [Option("project", Required = true, SetName = "project", HelpText = "The project to analyze.")]
         public string? ProjectPath { get; set; }
 
-        [Option("folder", Required = true, SetName = "folder", HelpText = "The folder to search for projects, or a glob pattern to match project files.")]
+        [Option("folder", Required = true, SetName = "folder", HelpText = "The folder to search for projects recursively, or a glob pattern to match specific project files (e.g., 'src/**/*.csproj').")]
         public string? FolderPath { get; set; }
 
         [Option("exclude", Required = false, Separator = ',', HelpText = "Any projects to exclude from analysis.")]

src/DendroDocs.Tool/README.md

@@ -22,7 +22,20 @@ dotnet tool install --global DendroDocs.Tool
 ## Example usage
 
 ```shell
+# Analyze a solution file
 dendrodocs-analyze --solution G:\DendroDocs\dotnet-shared-lib\DendroDocs.Shared.sln --output shared.json --pretty --verbose --exclude G:\DendroDocs\dotnet-shared-lib\build\_build.csproj
+
+# Analyze a single project file
+dendrodocs-analyze --project MyProject.csproj --output project.json --pretty
+
+# Analyze all projects in a folder
+dendrodocs-analyze --folder /path/to/projects --output folder.json --pretty
+
+# Use glob patterns to select specific projects
+dendrodocs-analyze --folder "src/**/*.csproj" --output matched.json --pretty
+
+# Exclude specific projects when analyzing a folder
+dendrodocs-analyze --folder /path/to/projects --exclude /path/to/unwanted.csproj,/path/to/test.csproj --output filtered.json
 ```
 
 ## Output

tests/DendroDocs.Tool.Tests/AnalyzerSetup/AnalyzerSetupTests.cs

@@ -147,6 +147,37 @@ public void FolderShouldFilterExcludedProjects()
         analyzerSetup.Projects.ShouldAllBe(p => p.FilePath != null && p.FilePath.EndsWith("Project.csproj"));
     }
 
+    [TestMethod]
+    public void GlobPatternShouldFindMatchingProjects()
+    {
+        // Arrange
+        var basePath = GetBasePath();
+        var originalDir = Directory.GetCurrentDirectory();
+
+        try
+        {
+            // Change to the test base directory to make relative patterns work
+            Directory.SetCurrentDirectory(basePath);
+            var globPattern = "AnalyzerSetupVerification/**/*.csproj";
+
+            // Act
+            using var analyzerSetup = AnalyzerSetup.BuildFolderAnalyzer(globPattern);
+
+            // Assert
+            // Should find the 3 non-test projects that match the pattern (excludes TestProject due to test references)
+            analyzerSetup.Projects.Count().ShouldBe(3);
+            
+            var projectPaths = analyzerSetup.Projects.Select(p => p.FilePath).ToList();
+            projectPaths.ShouldContain(path => path != null && path.EndsWith("Project.csproj"));
+            projectPaths.ShouldContain(path => path != null && path.EndsWith("OtherProject.csproj"));
+            projectPaths.ShouldContain(path => path != null && path.EndsWith("AnotherProject.csproj"));
+        }
+        finally
+        {
+            Directory.SetCurrentDirectory(originalDir);
+        }
+    }
+
     private static string GetSolutionPath()
     {
         var currentDirectory = Directory.GetCurrentDirectory().AsSpan();