Adding option for --ignore-path (#1659)

belav · web-flow · commit e752f9ffdde6 · 2025-07-13T10:08:26.000-05:00
closes #1585
diff --git a/Src/CSharpier.Cli.Tests/CliTests.cs b/Src/CSharpier.Cli.Tests/CliTests.cs
@@ -105,6 +105,38 @@ public async Task Format_Should_Respect_Ignore_File_With_Subdirectory_When_Direc
             .Be(unformattedContent, $"The file at {filePath} should have been ignored");
     }
 
+    [Test]
+    public async Task Format_Should_Respect_Ignore_Path()
+    {
+        var unformattedContent = "public class Unformatted {     }";
+        var filePath = "IgnoredFile.cs";
+        await WriteFileAsync(filePath, unformattedContent);
+        await WriteFileAsync(".config/.csharpierignore", filePath);
+
+        await new CsharpierProcess()
+            .WithArguments("format . --ignore-path ./config/.csharpierignore")
+            .ExecuteAsync();
+        var fileContents = await ReadAllTextAsync(filePath);
+
+        fileContents
+            .Should()
+            .Be(unformattedContent, $"The file at {filePath} should have been ignored");
+    }
+
+    [Test]
+    public async Task Check_Should_Respect_Ignore_Path()
+    {
+        var unformattedContent = "public class Unformatted {     }";
+        var filePath = "IgnoredFile.cs";
+        await WriteFileAsync(filePath, unformattedContent);
+        await WriteFileAsync(".config/.csharpierignore", filePath);
+
+        var result = await new CsharpierProcess()
+            .WithArguments("check . --ignore-path .config/.csharpierignore")
+            .ExecuteAsync();
+        result.ExitCode.Should().Be(0);
+    }
+
     [TestCase(".git")]
     [TestCase("subdirectory/.git")]
     [TestCase("node_modules")]
diff --git a/Src/CSharpier.Cli/CommandLineFormatter.cs b/Src/CSharpier.Cli/CommandLineFormatter.cs
@@ -48,6 +48,7 @@ CancellationToken cancellationToken
                 var optionsProvider = await OptionsProvider.Create(
                     directoryPath,
                     commandLineOptions.ConfigPath,
+                    commandLineOptions.IgnorePath,
                     fileSystem,
                     logger,
                     cancellationToken
@@ -178,6 +179,7 @@ CancellationToken cancellationToken
             var optionsProvider = await OptionsProvider.Create(
                 directoryName,
                 commandLineOptions.ConfigPath,
+                commandLineOptions.IgnorePath,
                 fileSystem,
                 logger,
                 cancellationToken
diff --git a/Src/CSharpier.Cli/CommandLineOptions.cs b/Src/CSharpier.Cli/CommandLineOptions.cs
@@ -19,4 +19,5 @@ internal class CommandLineOptions
     public string? StandardInFileContents { get; init; }
     public string? ConfigPath { get; init; }
     public string[] OriginalDirectoryOrFilePaths { get; init; } = [];
+    public string? IgnorePath { get; init; }
 }
diff --git a/Src/CSharpier.Cli/FormattingCommands.cs b/Src/CSharpier.Cli/FormattingCommands.cs
@@ -35,6 +35,7 @@ public static Command CreateFormatCommand()
         formatCommand.AddOption(writeStdoutOption);
         formatCommand.AddOption(CompilationErrorsAsWarningsOption);
         formatCommand.AddOption(ConfigPathOption);
+        formatCommand.AddOption(IgnorePathOption);
         formatCommand.AddOption(LogFormatOption);
         formatCommand.AddOption(LogLevelOption);
 
@@ -51,6 +52,7 @@ public static Command CreateFormatCommand()
                 CompilationErrorsAsWarningsOption
             );
             var configPath = context.ParseResult.GetValueForOption(ConfigPathOption);
+            var ignorePath = context.ParseResult.GetValueForOption(IgnorePathOption);
             var logLevel = context.ParseResult.GetValueForOption(LogLevelOption);
             var logFormat = context.ParseResult.GetValueForOption(LogFormatOption);
             var token = context.GetCancellationToken();
@@ -66,6 +68,7 @@ public static Command CreateFormatCommand()
                 includeGenerated,
                 compilationErrorsAsWarnings,
                 configPath,
+                ignorePath,
                 logLevel,
                 logFormat,
                 token
@@ -84,6 +87,7 @@ public static Command CreateCheckCommand()
         var directoryOrFileArgument = AddDirectoryOrFileArgument(checkCommand);
 
         checkCommand.AddOption(ConfigPathOption);
+        checkCommand.AddOption(IgnorePathOption);
         checkCommand.AddOption(LogFormatOption);
         checkCommand.AddOption(LogLevelOption);
         checkCommand.AddOption(IncludeGeneratedOption);
@@ -99,6 +103,7 @@ public static Command CreateCheckCommand()
                 CompilationErrorsAsWarningsOption
             );
             var configPath = context.ParseResult.GetValueForOption(ConfigPathOption);
+            var ignorePath = context.ParseResult.GetValueForOption(IgnorePathOption);
             var logLevel = context.ParseResult.GetValueForOption(LogLevelOption);
             var logFormat = context.ParseResult.GetValueForOption(LogFormatOption);
             var token = context.GetCancellationToken();
@@ -114,6 +119,7 @@ public static Command CreateCheckCommand()
                 includeGenerated,
                 compilationErrorsAsWarnings,
                 configPath,
+                ignorePath,
                 logLevel,
                 logFormat,
                 token
@@ -134,6 +140,7 @@ private static async Task<int> FormatOrCheck(
         bool includeGenerated,
         bool compilationErrorsAsWarnings,
         string? configPath,
+        string? ignorePath,
         LogLevel logLevel,
         LogFormat logFormat,
         CancellationToken cancellationToken
@@ -179,6 +186,7 @@ CancellationToken cancellationToken
             WriteStdout = writeStdout || standardInFileContents != null,
             IncludeGenerated = includeGenerated,
             ConfigPath = configPath,
+            IgnorePath = ignorePath,
             CompilationErrorsAsWarnings = compilationErrorsAsWarnings,
             LogFormat = logFormat,
         };
@@ -218,6 +226,11 @@ private static Argument<string[]> AddDirectoryOrFileArgument(Command command)
         "Path to the CSharpier configuration file"
     );
 
+    private static readonly Option<string> IgnorePathOption = new(
+        ["--ignore-path"],
+        "Path to the CSharpier ignore file"
+    );
+
     private static readonly Option<LogFormat> LogFormatOption = new(
         ["--log-format"],
         () => LogFormat.Console,
diff --git a/Src/CSharpier.Cli/IgnoreFile.cs b/Src/CSharpier.Cli/IgnoreFile.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using System.IO.Abstractions;
 using System.Text.RegularExpressions;
 using CSharpier.Core;
@@ -49,46 +50,61 @@ public bool IsIgnored(string filePath)
     public static async Task<IgnoreFile?> CreateAsync(
         string baseDirectoryPath,
         IFileSystem fileSystem,
+        string? ignorePath,
         CancellationToken cancellationToken
     )
     {
+        async Task<IgnoreWithBasePath> CreateIgnore(string ignoreFilePath, string? overrideBasePath)
+        {
+            var ignore = new IgnoreWithBasePath(
+                overrideBasePath ?? Path.GetDirectoryName(ignoreFilePath)!
+            );
+            AddDefaultRules(ignore);
+
+            var content = await fileSystem.File.ReadAllTextAsync(ignoreFilePath, cancellationToken);
+
+            var (positives, negatives) = GitignoreParserNet.GitignoreParser.Parse(content, true);
+
+            ignore.AddPositives(positives.Merged);
+            ignore.AddNegatives(negatives.Merged);
+
+            return ignore;
+        }
+
         return await SharedFunc<IgnoreFile?>
             .GetOrAddAsync(
                 baseDirectoryPath,
                 async () =>
                 {
                     DebugLogger.Log("Creating ignore file for " + baseDirectoryPath);
-                    var ignoreFilePaths = FindIgnorePaths(baseDirectoryPath, fileSystem);
-                    if (ignoreFilePaths.Count == 0)
+                    if (ignorePath is not null)
                     {
-                        var ignore = new IgnoreWithBasePath(baseDirectoryPath);
-                        AddDefaultRules(ignore);
-                        return new IgnoreFile([ignore]);
-                    }
+                        if (!fileSystem.File.Exists(ignorePath))
+                        {
+                            throw new Exception("There was no ignore file found at " + ignorePath);
+                        }
 
-                    var ignores = new List<IgnoreWithBasePath>();
-                    foreach (var ignoreFilePath in ignoreFilePaths)
+                        DebugLogger.Log("Using ignorePath: " + ignorePath);
+                        return new IgnoreFile([await CreateIgnore(ignorePath, baseDirectoryPath)]);
+                    }
+                    else
                     {
-                        var ignore = new IgnoreWithBasePath(Path.GetDirectoryName(ignoreFilePath)!);
-                        AddDefaultRules(ignore);
-
-                        var content = await fileSystem.File.ReadAllTextAsync(
-                            ignoreFilePath,
-                            cancellationToken
-                        );
-
-                        var (positives, negatives) = GitignoreParserNet.GitignoreParser.Parse(
-                            content,
-                            true
-                        );
-
-                        ignore.AddPositives(positives.Merged);
-                        ignore.AddNegatives(negatives.Merged);
-
-                        ignores.Add(ignore);
+                        var ignoreFilePaths = FindIgnorePaths(baseDirectoryPath, fileSystem);
+                        if (ignoreFilePaths.Count == 0)
+                        {
+                            var ignore = new IgnoreWithBasePath(baseDirectoryPath);
+                            AddDefaultRules(ignore);
+                            return new IgnoreFile([ignore]);
+                        }
+
+                        var ignores = new List<IgnoreWithBasePath>();
+                        foreach (var ignoreFilePath in ignoreFilePaths)
+                        {
+                            ignores.Add(await CreateIgnore(ignoreFilePath, null));
+                        }
+
+                        return new IgnoreFile(ignores);
                     }
-
-                    return new IgnoreFile(ignores);
                 },
                 cancellationToken
             )
@@ -164,6 +180,8 @@ private class IgnoreWithBasePath(string basePath)
 
         public (bool hasMatchingRule, bool isIgnored) IsIgnored(string path)
         {
+            DebugLogger.Log("path: " + path);
+            DebugLogger.Log("basePath: " + basePath);
             if (!path.StartsWith(basePath, StringComparison.Ordinal))
             {
                 return (false, false);
diff --git a/Src/CSharpier.Cli/Options/OptionsProvider.cs b/Src/CSharpier.Cli/Options/OptionsProvider.cs
@@ -37,6 +37,7 @@ ILogger logger
     public static async Task<OptionsProvider> Create(
         string directoryName,
         string? configPath,
+        string? ignorePath,
         IFileSystem fileSystem,
         ILogger logger,
         CancellationToken cancellationToken
@@ -55,7 +56,12 @@ CancellationToken cancellationToken
             ? CSharpierConfigParser.Create(csharpierConfigPath, fileSystem, logger)
             : null;
 
-        var ignoreFile = await IgnoreFile.CreateAsync(directoryName, fileSystem, cancellationToken);
+        var ignoreFile = await IgnoreFile.CreateAsync(
+            directoryName,
+            fileSystem,
+            ignorePath,
+            cancellationToken
+        );
 
         if (ignoreFile is null)
         {
@@ -196,7 +202,7 @@ CancellationToken cancellationToken
                     Path.Combine(searchingDirectory, ".csharpierignore")
                 ),
             (searchingDirectory) =>
-                IgnoreFile.CreateAsync(searchingDirectory, this.fileSystem, cancellationToken)
+                IgnoreFile.CreateAsync(searchingDirectory, this.fileSystem, null, cancellationToken)
         );
 
         if (ignoreFile is null)
diff --git a/Src/CSharpier.Cli/Server/CSharpierServiceImplementation.cs b/Src/CSharpier.Cli/Server/CSharpierServiceImplementation.cs
@@ -45,6 +45,7 @@ CancellationToken cancellationToken
             var optionsProvider = await OptionsProvider.Create(
                 directoryName,
                 configPath: null,
+                ignorePath: null,
                 this.fileSystem,
                 logger,
                 cancellationToken
diff --git a/Src/CSharpier.Tests/OptionsProviderTests.cs b/Src/CSharpier.Tests/OptionsProviderTests.cs
@@ -821,6 +821,7 @@ string filePath
             var provider = await OptionsProvider.Create(
                 directoryName,
                 null,
+                null,
                 this.fileSystem,
                 NullLogger.Instance,
                 CancellationToken.None
diff --git a/docs/CLI.md b/docs/CLI.md
@@ -33,9 +33,16 @@ If a list of paths is not supplied, then stdin is read as a file, formatted and
     dotnet csharpier format . --config-path "./config/csharpier.yaml"
 
     # allows passing in a path to an editorconfig
-    dotnet csharpier . --config-path "./config/.editorconfig"
+    dotnet csharpier format . --config-path "./config/.editorconfig"
     ```
 
+- `--ignore-path`
+
+  If your ignore file lives in a location that CSharpier would not normally resolve it (such as in a config folder)
+  you can pass the path for the ignore file to CSharpier.
+    ```bash
+    dotnet csharpier format . --ignore-path "./config/.csharpierignore"
+    ```
 
 - `--log-format`
 

Original file line number	Diff line number	Diff line change
`@@ -19,4 +19,5 @@ internal class CommandLineOptions`
`19`	`19`	`public string? StandardInFileContents { get; init; }`
`20`	`20`	`public string? ConfigPath { get; init; }`
`21`	`21`	`public string[] OriginalDirectoryOrFilePaths { get; init; } = [];`
	`22`	`+ public string? IgnorePath { get; init; }`
`22`	`23`	`}`