Take lists of files with elements to exclude, instead of directly passing list of elements to exclude.

Author: carlossanlop

src/Compatibility/ApiDiff/Microsoft.DotNet.ApiDiff.Tool/GenAPIDiffConfigurationBinder.cs

@@ -17,9 +17,9 @@ internal class GenAPIDiffConfigurationBinder : BinderBase<DiffConfiguration>
     private readonly Option<string> _optionBeforeFriendlyName;
     private readonly Option<string> _optionAfterFriendlyName;
     private readonly Option<string> _optionTableOfContentsTitle;
-    private readonly Option<string[]?> _optionAssembliesToExclude;
-    private readonly Option<string[]?> _optionAttributesToExclude;
-    private readonly Option<string[]?> _optionApisToExclude;
+    private readonly Option<FileInfo[]?> _optionFilesWithAssembliesToExclude;
+    private readonly Option<FileInfo[]?> _optionFilesWithAttributesToExclude;
+    private readonly Option<FileInfo[]?> _optionFilesWithApisToExclude;
     private readonly Option<bool> _optionAddPartialModifier;
     private readonly Option<bool> _optionAttachDebugger;
 
@@ -31,9 +31,9 @@ internal GenAPIDiffConfigurationBinder(Option<string> optionBeforeAssembliesFold
                                            Option<string> optionBeforeFriendlyName,
                                            Option<string> optionAfterFriendlyName,
                                            Option<string> optionTableOfContentsTitle,
-                                           Option<string[]?> optionAssembliesToExclude,
-                                           Option<string[]?> optionAttributesToExclude,
-                                           Option<string[]?> optionApisToExclude,
+                                           Option<FileInfo[]?> optionFilesWithAssembliesToExclude,
+                                           Option<FileInfo[]?> optionFilesWithAttributesToExclude,
+                                           Option<FileInfo[]?> optionFilesWithApisToExclude,
                                            Option<bool> optionAddPartialModifier,
                                            Option<bool> optionAttachDebugger)
     {
@@ -45,9 +45,9 @@ internal GenAPIDiffConfigurationBinder(Option<string> optionBeforeAssembliesFold
         _optionBeforeFriendlyName = optionBeforeFriendlyName;
         _optionAfterFriendlyName = optionAfterFriendlyName;
         _optionTableOfContentsTitle = optionTableOfContentsTitle;
-        _optionAssembliesToExclude = optionAssembliesToExclude;
-        _optionAttributesToExclude = optionAttributesToExclude;
-        _optionApisToExclude = optionApisToExclude;
+        _optionFilesWithAssembliesToExclude = optionFilesWithAssembliesToExclude;
+        _optionFilesWithAttributesToExclude = optionFilesWithAttributesToExclude;
+        _optionFilesWithApisToExclude = optionFilesWithApisToExclude;
         _optionAddPartialModifier = optionAddPartialModifier;
         _optionAttachDebugger = optionAttachDebugger;
     }
@@ -62,9 +62,9 @@ protected override DiffConfiguration GetBoundValue(BindingContext bindingContext
             BeforeFriendlyName: bindingContext.ParseResult.GetValueForOption(_optionBeforeFriendlyName) ?? throw new NullReferenceException("Null before friendly name"),
             AfterFriendlyName: bindingContext.ParseResult.GetValueForOption(_optionAfterFriendlyName) ?? throw new NullReferenceException("Null after friendly name"),
             TableOfContentsTitle: bindingContext.ParseResult.GetValueForOption(_optionTableOfContentsTitle) ?? throw new NullReferenceException("Null table of contents title"),
-            AssembliesToExclude: bindingContext.ParseResult.GetValueForOption(_optionAssembliesToExclude),
-            AttributesToExclude: bindingContext.ParseResult.GetValueForOption(_optionAttributesToExclude),
-            ApisToExclude: bindingContext.ParseResult.GetValueForOption(_optionApisToExclude),
+            FilesWithAssembliesToExclude: bindingContext.ParseResult.GetValueForOption(_optionFilesWithAssembliesToExclude),
+            FilesWithAttributesToExclude: bindingContext.ParseResult.GetValueForOption(_optionFilesWithAttributesToExclude),
+            FilesWithApisToExclude: bindingContext.ParseResult.GetValueForOption(_optionFilesWithApisToExclude),
             AddPartialModifier: bindingContext.ParseResult.GetValueForOption(_optionAddPartialModifier),
             AttachDebugger: bindingContext.ParseResult.GetValueForOption(_optionAttachDebugger)
         );

src/Compatibility/ApiDiff/Microsoft.DotNet.ApiDiff.Tool/Program.cs

@@ -73,23 +73,23 @@ public static async Task Main(string[] args)
             IsRequired = true
         };
 
-        Option<string[]?> optionAssembliesToExclude = new(["--assembliesToExclude", "-eas"], () => null)
+        Option<FileInfo[]?> optionFilesWithAssembliesToExclude = new(["--assembliesToExclude", "-eas"], () => null)
         {
-            Description = "Assemblies from both before and after to exclude from the diff.",
+            Description = "An optional array of filepaths, each containing a list of assemblies that should be excluded from the diff. Each file should contain one assembly name per line, with no extensions.",
             Arity = ArgumentArity.ZeroOrMore,
             IsRequired = false,
         };
 
-        Option<string[]?> optionAttributesToExclude = new(["--attributesToExclude", "-eattrs"], () => null)
+        Option<FileInfo[]?> optionFilesWithAttributesToExclude = new(["--attributesToExclude", "-eattrs"], () => null)
         {
-            Description = "Attributes to exclude from the diff.",
+            Description = "An optional array of filepaths, each containing a list of attributes to exclude from the diff. Each file should contain one API full name per line.",
             Arity = ArgumentArity.ZeroOrMore,
             IsRequired = false
         };
 
-        Option<string[]?> optionApisToExclude = new(["--apisToExclude", "-eapis"], () => null)
+        Option<FileInfo[]?> optionFilesWithApisToExclude = new(["--apisToExclude", "-eapis"], () => null)
         {
-            Description = "APIs to exclude from the diff.",
+            Description = "An optional array of filepaths, each containing a list of APIs to exclude from the diff. Each file should contain one API full name per line.",
             Arity = ArgumentArity.ZeroOrMore,
             IsRequired = false
         };
@@ -113,9 +113,9 @@ public static async Task Main(string[] args)
         rootCommand.Add(optionBeforeFriendlyName);
         rootCommand.Add(optionAfterFriendlyName);
         rootCommand.Add(optionTableOfContentsTitle);
-        rootCommand.Add(optionAssembliesToExclude);
-        rootCommand.Add(optionAttributesToExclude);
-        rootCommand.Add(optionApisToExclude);
+        rootCommand.Add(optionFilesWithAssembliesToExclude);
+        rootCommand.Add(optionFilesWithAttributesToExclude);
+        rootCommand.Add(optionFilesWithApisToExclude);
         rootCommand.Add(optionAddPartialModifier);
         rootCommand.Add(optionAttachDebugger);
 
@@ -127,9 +127,9 @@ public static async Task Main(string[] args)
                                               optionBeforeFriendlyName,
                                               optionAfterFriendlyName,
                                               optionTableOfContentsTitle,
-                                              optionAssembliesToExclude,
-                                              optionAttributesToExclude,
-                                              optionApisToExclude,
+                                              optionFilesWithAssembliesToExclude,
+                                              optionFilesWithAttributesToExclude,
+                                              optionFilesWithApisToExclude,
                                               optionAddPartialModifier,
                                               optionAttachDebugger);
 
@@ -141,9 +141,9 @@ private static Task HandleCommandAsync(DiffConfiguration diffConfig)
     {
         var log = new ConsoleLog(MessageImportance.Normal);
 
-        string assembliesToExclude = string.Join(", ", diffConfig.AssembliesToExclude ?? []);
-        string attributesToExclude = string.Join(", ", diffConfig.AttributesToExclude ?? []);
-        string apisToExclude = string.Join(", ", diffConfig.ApisToExclude ?? []);
+        string assembliesToExclude = string.Join(", ", diffConfig.FilesWithAssembliesToExclude?.Select(a => a.FullName) ?? []);
+        string attributesToExclude = string.Join(", ", diffConfig.FilesWithAttributesToExclude?.Select(a => a.FullName) ?? []);
+        string apisToExclude = string.Join(", ", diffConfig.FilesWithApisToExclude?.Select(a => a.FullName) ?? []);
 
         // Custom ordering to match help menu.
         log.LogMessage("Selected options:");
@@ -152,9 +152,9 @@ private static Task HandleCommandAsync(DiffConfiguration diffConfig)
         log.LogMessage($" - 'Before' reference assemblies:      {diffConfig.BeforeAssemblyReferencesFolderPath}");
         log.LogMessage($" - 'After'  reference assemblies:      {diffConfig.AfterAssemblyReferencesFolderPath}");
         log.LogMessage($" - Output:                             {diffConfig.OutputFolderPath}");
-        log.LogMessage($" - Assemblies to exclude:              {assembliesToExclude}");
-        log.LogMessage($" - Attributes to exclude:              {attributesToExclude}");
-        log.LogMessage($" - APIs to exclude:                    {apisToExclude}");
+        log.LogMessage($" - Files with assemblies to exclude:   {assembliesToExclude}");
+        log.LogMessage($" - Files with attributes to exclude:   {attributesToExclude}");
+        log.LogMessage($" - Files with APIs to exclude:         {apisToExclude}");
         log.LogMessage($" - 'Before' friendly name:             {diffConfig.BeforeFriendlyName}");
         log.LogMessage($" - 'After' friendly name:              {diffConfig.AfterFriendlyName}");
         log.LogMessage($" - Table of contents title:            {diffConfig.TableOfContentsTitle}");
@@ -176,9 +176,9 @@ private static Task HandleCommandAsync(DiffConfiguration diffConfig)
                                                                    diffConfig.BeforeFriendlyName,
                                                                    diffConfig.AfterFriendlyName,
                                                                    diffConfig.TableOfContentsTitle,
-                                                                   diffConfig.AssembliesToExclude,
-                                                                   diffConfig.AttributesToExclude,
-                                                                   diffConfig.ApisToExclude,
+                                                                   diffConfig.FilesWithAssembliesToExclude,
+                                                                   diffConfig.FilesWithAttributesToExclude,
+                                                                   diffConfig.FilesWithApisToExclude,
                                                                    diffConfig.AddPartialModifier,
                                                                    writeToDisk: true,
                                                                    diagnosticOptions: null // TODO: If needed, add CLI option to pass specific diagnostic options

src/Compatibility/ApiDiff/Microsoft.DotNet.ApiDiff/DiffConfiguration.cs

@@ -15,9 +15,9 @@ public record DiffConfiguration(
     string BeforeFriendlyName,
     string AfterFriendlyName,
     string TableOfContentsTitle,
-    string[]? AssembliesToExclude,
-    string[]? AttributesToExclude,
-    string[]? ApisToExclude,
+    FileInfo[]? FilesWithAssembliesToExclude,
+    FileInfo[]? FilesWithAttributesToExclude,
+    FileInfo[]? FilesWithApisToExclude,
     bool AddPartialModifier,
     bool AttachDebugger
 );

src/Compatibility/ApiDiff/Microsoft.DotNet.ApiDiff/DiffGeneratorFactory.cs

@@ -42,9 +42,9 @@ public static class DiffGeneratorFactory
     /// <param name="beforeFriendlyName">The friendly name for the assemblies before the change.</param>
     /// <param name="afterFriendlyName">The friendly name for the assemblies after the change.</param>
     /// <param name="tableOfContentsTitle">The title for the table of contents in the generated diff.</param>
-    /// <param name="assembliesToExclude">An optional list of assemblies to avoid showing in the diff. If <see langword="null"/>, no assemblies are excluded.</param>
-    /// <param name="attributesToExclude">An optional list of attributes to avoid showing in the diff. If <see langword="null"/>, the default list of attributes to exclude <see cref="DiffGeneratorFactory.DefaultAttributesToExclude"/> is used. If an empty list, no attributes are excluded.</param>
-    /// <param name="apisToExclude">An optional list of APIs to avoid showing in the diff.</param>
+    /// <param name="filesWithAssembliesToExclude">An optional array of filepaths each containing a list of assemblies to avoid showing in the diff. If <see langword="null"/>, no assemblies are excluded.</param>
+    /// <param name="filesWithAttributesToExclude">An optional array of filepaths each containing a list of  attributes to avoid showing in the diff. If <see langword="null"/>, the default list of attributes to exclude <see cref="DiffGeneratorFactory.DefaultAttributesToExclude"/> is used. If an empty list, no attributes are excluded.</param>
+    /// <param name="filesWithApisToExclude">An optional array of filepaths each containing a list of  APIs to avoid showing in the diff.</param>
     /// <param name="addPartialModifier">Indicates whether to add the partial modifier to types.</param>
     /// <param name="writeToDisk">If <see langword="true"/>, when calling <see cref="IDiffGenerator.RunAsync"/>, the generated markdown files get written to disk, and no item is added to the <see cref="IDiffGenerator.RunAsync"/> dictionary. If <see langword="false"/>, when calling <see cref="IDiffGenerator.RunAsync"/>, the generated markdown files get added to the <see cref="IDiffGenerator.RunAsync"/> dictionary (with the file path as the dictionary key) and none of them is written to disk. This is meant for testing purposes.</param>
     /// <param name="diagnosticOptions">An optional list of diagnostic options to use when generating the diff.</param>
@@ -59,9 +59,9 @@ public static IDiffGenerator Create(ILog log,
                                         string beforeFriendlyName,
                                         string afterFriendlyName,
                                         string tableOfContentsTitle,
-                                        string[]? assembliesToExclude,
-                                        string[]? attributesToExclude,
-                                        string[]? apisToExclude,
+                                        FileInfo[]? filesWithAssembliesToExclude,
+                                        FileInfo[]? filesWithAttributesToExclude,
+                                        FileInfo[]? filesWithApisToExclude,
                                         bool addPartialModifier,
                                         bool writeToDisk,
                                         IEnumerable<KeyValuePair<string, ReportDiagnostic>>? diagnosticOptions = null)
@@ -75,9 +75,9 @@ public static IDiffGenerator Create(ILog log,
                                            beforeFriendlyName,
                                            afterFriendlyName,
                                            tableOfContentsTitle,
-                                           assembliesToExclude,
-                                           attributesToExclude,
-                                           apisToExclude,
+                                           filesWithAssembliesToExclude,
+                                           filesWithAttributesToExclude,
+                                           filesWithApisToExclude,
                                            addPartialModifier,
                                            writeToDisk,
                                            diagnosticOptions);