Add rules to convert tests to xUnit and add a command line option to specify type of rules to run

Author: dsplaisted

src/CodeFormatter/Program.cs

@@ -1,21 +1,23 @@
 using System;
 using System.ComponentModel.Composition.Hosting;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using Microsoft.CodeAnalysis.MSBuild;
 using Microsoft.DotNet.CodeFormatting;
+using System.Collections.Generic;
 
 namespace CodeFormatter
 {
     internal static class Program
     {
         private static int Main(string[] args)
         {
-            if (args.Length != 1)
+            if (args.Length < 1)
             {
-                Console.Error.WriteLine("CodeFormatter <solution>");
+                Console.Error.WriteLine("CodeFormatter <solution> [<rule types>]");
                 return -1;
             }
 
@@ -26,23 +28,33 @@ private static int Main(string[] args)
                 return -1;
             }
 
+            var ruleTypes = args.Skip(1);
+
             var cts = new CancellationTokenSource();
             var ct = cts.Token;
 
             Console.CancelKeyPress += delegate { cts.Cancel(); };
 
-            RunAsync(solutionPath, ct).Wait(ct);
+            RunAsync(solutionPath, ruleTypes, ct).Wait(ct);
             Console.WriteLine("Completed formatting.");
             return 0;
         }
 
-        private static async Task RunAsync(string solutionFilePath, CancellationToken cancellationToken)
+        private static async Task RunAsync(string solutionFilePath, IEnumerable<string> ruleTypes, CancellationToken cancellationToken)
         {
-            var workspace = MSBuildWorkspace.Create();
-            await workspace.OpenSolutionAsync(solutionFilePath, cancellationToken);
+            try
+            {
+                var workspace = MSBuildWorkspace.Create();
+                await workspace.OpenSolutionAsync(solutionFilePath, cancellationToken);
 
-            var engine = FormattingEngine.Create();
-            await engine.RunAsync(workspace, cancellationToken);
+                var engine = FormattingEngine.Create(ruleTypes);
+                await engine.RunAsync(workspace, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.ToString());
+                throw;
+            }
         }
     }
 }

src/Microsoft.DotNet.CodeFormatting/Filters/TestFilter.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.DotNet.CodeFormatting.Filters
+{
+    //  Useful to restrict processing to a single file when testing code
+    [Export(typeof(IFormattingFilter))]
+    [PartMetadata(RuleTypeConstants.PartMetadataKey, "Test")]
+    internal sealed class TestFilter : IFormattingFilter
+    {
+        public Task<bool> ShouldBeProcessedAsync(Document document)
+        {
+            //if (document.FilePath.EndsWith("ActivationEventOrderingTests.cs"))
+            if (document.FilePath.EndsWith("PartBuilderOfTTests.cs"))
+            {
+                return Task.FromResult(true);
+            }
+            return Task.FromResult(false);
+        }
+    }
+}

src/Microsoft.DotNet.CodeFormatting/FormattingEngine.cs

@@ -1,16 +1,45 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under MIT. See LICENSE in the project root for license information.
 using System;
+using System.Linq;
 using System.ComponentModel.Composition.Hosting;
+using System.ComponentModel.Composition;
+using System.Collections.Generic;
 
 namespace Microsoft.DotNet.CodeFormatting
 {
     public static class FormattingEngine
     {
-        public static IFormattingEngine Create()
+        public static IFormattingEngine Create(IEnumerable<string> ruleTypes)
         {
             var catalog = new AssemblyCatalog(typeof(FormattingEngine).Assembly);
-            var container = new CompositionContainer(catalog);
+
+            var ruleTypesHash = new HashSet<string>(ruleTypes);
+            if (ruleTypesHash.Count == 0)
+            {
+                ruleTypesHash.Add(RuleTypeConstants.FormatCodeRuleType);
+            }
+
+            var filteredCatalog = new FilteredCatalog(catalog, cpd =>
+            {
+                if (cpd.ExportDefinitions.Any(em =>
+                    em.ContractName == AttributedModelServices.GetContractName(typeof(IFormattingRule)) ||
+                    em.ContractName == AttributedModelServices.GetContractName(typeof(IFormattingFilter))))
+                {
+                    object ruleType;
+                    if (cpd.Metadata.TryGetValue("RuleType", out ruleType))
+                    {
+                        if (ruleType is string && !ruleTypesHash.Contains((string)ruleType))
+                        {
+                            return false;
+                        }
+                    }
+                }
+
+                return true;
+            });
+
+            var container = new CompositionContainer(filteredCatalog);
             var engine = container.GetExportedValue<IFormattingEngine>();
             return engine;
         }

src/Microsoft.DotNet.CodeFormatting/Microsoft.DotNet.CodeFormatting.csproj

@@ -77,6 +77,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Filters\TestFilter.cs" />
     <Compile Include="FormattingEngine.cs" />
     <Compile Include="FormattingEngineImplementation.cs" />
     <Compile Include="IFormattingEngine.cs" />
@@ -99,6 +100,8 @@
     <Compile Include="Rules\IsFormattedFormattingRule.cs" />
     <Compile Include="Rules\IsSimplifiedFormattingRule.cs" />
     <Compile Include="Rules\RuleExtensions.cs" />
+    <Compile Include="Rules\UsesXunitForTests.cs" />
+    <Compile Include="RuleTypeConstants.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

src/Microsoft.DotNet.CodeFormatting/RuleTypeConstants.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.CodeFormatting
+{
+    static class RuleTypeConstants
+    {
+        public const string PartMetadataKey = "RuleType";
+
+        public const string FormatCodeRuleType = "FormatCode";
+        public const string ConvertTestsRuleType = "ConvertTests";        
+    }
+}