Add the /list option

jaredpar · jaredpar · commit f33ede443d07 · 2015-06-14T14:30:26.000-07:00
This change adds the /list option which prints out all of the rule names
and their description.
diff --git a/src/CodeFormatter/Program.cs b/src/CodeFormatter/Program.cs
@@ -44,12 +44,20 @@ Use ConvertTests to convert MSTest tests to xUnit.
     /nounicode   - Do not convert unicode strings to escape sequences
     /simple      - Only run simple formatters (default)
     /agressive   - Run agressive form
+    /list        - List the available rules
     /verbose     - Verbose output
 ");
                 return -1;
             }
 
+            var comparer = StringComparer.OrdinalIgnoreCase;
             var projectOrSolutionPath = args[0];
+            if (comparer.Equals(projectOrSolutionPath, "/list"))
+            {
+                RunListRules();
+                return 0;
+            }
+
             if (!File.Exists(projectOrSolutionPath))
             {
                 Console.Error.WriteLine("Project, solution or response file {0} doesn't exist.", projectOrSolutionPath);
@@ -64,7 +72,6 @@ Use ConvertTests to convert MSTest tests to xUnit.
             var convertUnicode = true;
             var allowTables = false;
             var verbose = false;
-            var comparer = StringComparer.OrdinalIgnoreCase;
             var formattingLevel = FormattingLevel.Simple;
 
             for (int i = 1; i < args.Length; i++)
@@ -167,6 +174,17 @@ Use ConvertTests to convert MSTest tests to xUnit.
             }
         }
 
+        private static void RunListRules()
+        {
+            var rules = FormattingEngine.GetFormattingRules();
+            Console.WriteLine("{0,-20} {1}", "Name", "Description");
+            Console.WriteLine("==============================================");
+            foreach (var rule in rules)
+            {
+                Console.WriteLine("{0,-20} :{1}", rule.Name, rule.Description);
+            }
+        }
+
         private static async Task RunAsync(
             string projectSolutionOrRspPath,
             ImmutableArray<string> ruleTypes,
diff --git a/src/Microsoft.DotNet.CodeFormatting/FormattingEngine.cs b/src/Microsoft.DotNet.CodeFormatting/FormattingEngine.cs
@@ -16,11 +16,35 @@ public static class FormattingEngine
     {
         public static IFormattingEngine Create(ImmutableArray<string> ruleTypes)
         {
-            var catalog = new AssemblyCatalog(typeof(FormattingEngine).Assembly);
-            var container = new CompositionContainer(catalog);
+            var container = CreateCompositionContainer();
             var engine = container.GetExportedValue<IFormattingEngine>();
             var consoleFormatLogger = new ConsoleFormatLogger();
             return engine;
         }
+
+        public static List<IRuleMetadata> GetFormattingRules()
+        {
+            var container = CreateCompositionContainer();
+            var list = new List<IRuleMetadata>();
+            AppendRules<ISyntaxFormattingRule>(list, container);
+            AppendRules<ILocalSemanticFormattingRule>(list, container);
+            AppendRules<IGlobalSemanticFormattingRule>(list, container);
+            return list;
+        }
+
+        private static void AppendRules<T>(List<IRuleMetadata> list, CompositionContainer container)
+            where T : IFormattingRule
+        {
+            foreach (var rule in container.GetExports<T, IRuleMetadata>())
+            {
+                list.Add(rule.Metadata);
+            }
+        }
+
+        private static CompositionContainer CreateCompositionContainer()
+        {
+            var catalog = new AssemblyCatalog(typeof(FormattingEngine).Assembly);
+            return new CompositionContainer(catalog);
+        }
     }
 }
diff --git a/src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs b/src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs
@@ -20,6 +20,6 @@ public interface IFormattingEngine
         bool Verbose { get; set; }
         FormattingLevel FormattingLevel { get; set; }
         Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);
-        Task FormatProjectAsync(Project porject, CancellationToken cancellationToken);
+        Task FormatProjectAsync(Project project, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Microsoft.DotNet.CodeFormatting/IRuleMetadata.cs b/src/Microsoft.DotNet.CodeFormatting/IRuleMetadata.cs
@@ -7,6 +7,12 @@ namespace Microsoft.DotNet.CodeFormatting
 {
     public interface IRuleMetadata
     {
+        [DefaultValue("")]
+        string Name { get; }
+
+        [DefaultValue("")]
+        string Description { get; }
+
         [DefaultValue(int.MaxValue)]
         int Order { get; }
 
diff --git a/src/Microsoft.DotNet.CodeFormatting/RuleAttribute.cs b/src/Microsoft.DotNet.CodeFormatting/RuleAttribute.cs
@@ -15,12 +15,20 @@ namespace Microsoft.DotNet.CodeFormatting
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     internal sealed class SyntaxRuleAttribute : ExportAttribute, IRuleMetadata
     {
-        public SyntaxRuleAttribute(int order)
+        public SyntaxRuleAttribute(string name, string description, int order)
             : base(typeof(ISyntaxFormattingRule))
         {
+            Name = name;
+            Description = description;
             Order = order;
         }
 
+        [DefaultValue("")]
+        public string Name { get; private set; }
+
+        [DefaultValue("")]
+        public string Description { get; private set; }
+
         [DefaultValue(int.MaxValue)]
         public int Order { get; private set; }
 
@@ -32,12 +40,20 @@ public SyntaxRuleAttribute(int order)
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     internal sealed class LocalSemanticRuleAttribute : ExportAttribute, IRuleMetadata
     {
-        public LocalSemanticRuleAttribute(int order)
+        public LocalSemanticRuleAttribute(string name, string description, int order)
             : base(typeof(ILocalSemanticFormattingRule))
         {
+            Name = name;
+            Description = description;
             Order = order;
         }
 
+        [DefaultValue("")]
+        public string Name { get; private set; }
+
+        [DefaultValue("")]
+        public string Description { get; private set; }
+
         [DefaultValue(int.MaxValue)]
         public int Order { get; private set; }
 
@@ -49,12 +65,20 @@ public LocalSemanticRuleAttribute(int order)
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     internal sealed class GlobalSemanticRuleAttribute : ExportAttribute, IRuleMetadata
     {
-        public GlobalSemanticRuleAttribute(int order)
+        public GlobalSemanticRuleAttribute(string name, string description, int order)
             : base(typeof(IGlobalSemanticFormattingRule))
         {
+            Name = name;
+            Description = description;
             Order = order;
         }
 
+        [DefaultValue("")]
+        public string Name { get; private set; }
+
+        [DefaultValue("")]
+        public string Description { get; private set; }
+
         [DefaultValue(int.MaxValue)]
         public int Order { get; private set; }
 
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/BraceNewLineRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/BraceNewLineRule.cs
@@ -13,9 +13,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [SyntaxRule(SyntaxRuleOrder.BraceNewLineRule)]
+    [SyntaxRule(BraceNewLineRule.Name, BraceNewLineRule.Description, SyntaxRuleOrder.BraceNewLineRule)]
     internal sealed class BraceNewLineRule : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
+        internal const string Name = "BraceNewLine";
+        internal const string Description = "Ensure all braces occur on a new line";
+
         private enum NewLineKind
         {
             WhitespaceAndNewLine,
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/CopyrightHeaderRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/CopyrightHeaderRule.cs
@@ -12,9 +12,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [SyntaxRule(SyntaxRuleOrder.CopyrightHeaderRule)]
+    [SyntaxRule(CopyrightHeaderRule.Name, CopyrightHeaderRule.Description, SyntaxRuleOrder.CopyrightHeaderRule)]
     internal sealed partial class CopyrightHeaderRule : SyntaxFormattingRule, ISyntaxFormattingRule
     {
+        internal const string Name = "Copyright";
+        internal const string Description = "Insert the copyright header into every file";
+
         private abstract class CommonRule
         {
             /// <summary>
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitThisRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitThisRule.cs
@@ -14,9 +14,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [LocalSemanticRule(LocalSemanticRuleOrder.RemoveExplicitThisRule)]
+    [LocalSemanticRule(ExplicitThisRule.Name, ExplicitThisRule.Description, LocalSemanticRuleOrder.RemoveExplicitThisRule)]
     internal sealed class ExplicitThisRule : CSharpOnlyFormattingRule, ILocalSemanticFormattingRule
     {
+        internal const string Name = "ExplicitThis";
+        internal const string Description = "Remove explicit this/Me prefixes on expressions except where necessary";
+
         private sealed class ExplicitThisRewriter : CSharpSyntaxRewriter
         {
             private readonly Document _document;
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitVisibilityRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/ExplicitVisibilityRule.cs
@@ -14,9 +14,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [LocalSemanticRule(LocalSemanticRuleOrder.ExplicitVisibilityRule)]
+    [LocalSemanticRule(ExplicitVisibilityRule.Name, ExplicitVisibilityRule.Description, LocalSemanticRuleOrder.ExplicitVisibilityRule)]
     internal sealed partial class ExplicitVisibilityRule : ILocalSemanticFormattingRule
     {
+        internal const string Name = "ExplicitVisibility";
+        internal const string Description = "Ensure all members have an explicit visibility modifier";
+
         public bool SupportsLanguage(string languageName)
         {
             return
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/FormatDocumentFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/FormatDocumentFormattingRule.cs
@@ -17,9 +17,11 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [LocalSemanticRule(LocalSemanticRuleOrder.IsFormattedFormattingRule)]
+    [LocalSemanticRule(FormatDocumentFormattingRule.Name, FormatDocumentFormattingRule.Description, LocalSemanticRuleOrder.IsFormattedFormattingRule)]
     internal sealed class FormatDocumentFormattingRule : ILocalSemanticFormattingRule
     {
+        internal const string Name = "FormatDocument";
+        internal const string Description = "Run the language specific formatter on every document";
         private readonly Options _options;
 
         [ImportingConstructor]
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoCustomCopyrightHeaderFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoCustomCopyrightHeaderFormattingRule.cs
@@ -15,9 +15,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [SyntaxRule(SyntaxRuleOrder.HasNoCustomCopyrightHeaderFormattingRule)]
+    [SyntaxRule(HasNoCustomCopyrightHeaderFormattingRule.Name, HasNoCustomCopyrightHeaderFormattingRule.Description, SyntaxRuleOrder.HasNoCustomCopyrightHeaderFormattingRule)]
     internal sealed class HasNoCustomCopyrightHeaderFormattingRule : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
+        internal const string Name = "CustomCopyright";
+        internal const string Description = "Remove any custom copyright header from the file";
+
         private static string RulerMarker { get; set; }
         private static string StartMarker { get; set; }
         private static string EndMarker { get; set; }
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoIllegalHeadersFormattingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/HasNoIllegalHeadersFormattingRule.cs
@@ -15,9 +15,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [LocalSemanticRule(LocalSemanticRuleOrder.HasNoIllegalHeadersFormattingRule)]
+    [LocalSemanticRule(HasNoIllegalHeadersFormattingRule.Name, HasNoIllegalHeadersFormattingRule.Description, LocalSemanticRuleOrder.HasNoIllegalHeadersFormattingRule)]
     internal sealed class HasNoIllegalHeadersFormattingRule : CSharpOnlyFormattingRule, ILocalSemanticFormattingRule
     {
+        internal const string Name = "IllegalHeaders";
+        internal const string Description = "Remove illegal headers from files";
+
         // We are going to replace this header with the actual filename of the document being processed
         private const string FileNameIllegalHeader = "<<<filename>>>";
 
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/MarkReadonlyFieldsRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/MarkReadonlyFieldsRule.cs
@@ -16,10 +16,12 @@ namespace Microsoft.DotNet.CodeFormatting.Rules
     /// <summary>
     /// Mark any fields that can provably be marked as readonly.
     /// </summary>
-    [GlobalSemanticRule(GlobalSemanticRuleOrder.MarkReadonlyFieldsRule,
-        FormattingLevel = FormattingLevel.Agressive)]
+    [GlobalSemanticRule(MarkReadonlyFieldsRule.Name, MarkReadonlyFieldsRule.Description, GlobalSemanticRuleOrder.MarkReadonlyFieldsRule, FormattingLevel = FormattingLevel.Agressive)]
     internal sealed class MarkReadonlyFieldsRule : IGlobalSemanticFormattingRule
     {
+        internal const string Name = "ReadonlyFields";
+        internal const string Description = "Mark fields which can be readonly as readonly";
+
         private readonly SemaphoreSlim _processUsagesLock = new SemaphoreSlim(1, 1);
         private ConcurrentDictionary<IFieldSymbol, bool> _unwrittenWritableFields;
 
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/NewLineAboveRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/NewLineAboveRule.cs
@@ -18,9 +18,12 @@ namespace Microsoft.DotNet.CodeFormatting.Rules
     /// <summary>
     /// Ensure there is a blank line above the first using and namespace in the file. 
     /// </summary>
-    [SyntaxRule(SyntaxRuleOrder.NewLineAboveFormattingRule)]
+    [SyntaxRule(NewLineAboveRule.Name, NewLineAboveRule.Description, SyntaxRuleOrder.NewLineAboveFormattingRule)]
     internal sealed class NewLineAboveRule : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
+        internal const string Name = "NewLineAbove";
+        internal const string Description = "Ensure there is a new line above the first namespace and using in the file";
+
         public SyntaxNode Process(SyntaxNode syntaxRoot, string languageName)
         {
             syntaxRoot = ProcessUsing(syntaxRoot);
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/NonAsciiCharactersAreEscapedInLiteralsRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/NonAsciiCharactersAreEscapedInLiteralsRule.cs
@@ -14,9 +14,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [SyntaxRule(SyntaxRuleOrder.NonAsciiChractersAreEscapedInLiterals)]
+    [SyntaxRule(NonAsciiCharactersAreEscapedInLiterals.Name, NonAsciiCharactersAreEscapedInLiterals.Description, SyntaxRuleOrder.NonAsciiChractersAreEscapedInLiterals)]
     internal sealed class NonAsciiCharactersAreEscapedInLiterals : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
+        internal const string Name = "UnicodeLiterals";
+        internal const string Description = "Use unicode escape sequence instead of unicode literals";
+
         private readonly Options _options;
 
         [ImportingConstructor]
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/PrivateFieldNamingRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/PrivateFieldNamingRule.cs
@@ -15,9 +15,12 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Rules
 {
-    [GlobalSemanticRule(GlobalSemanticRuleOrder.PrivateFieldNamingRule)]
+    [GlobalSemanticRule(PrivateFieldNamingRule.Name, PrivateFieldNamingRule.Description, GlobalSemanticRuleOrder.PrivateFieldNamingRule)]
     internal partial class PrivateFieldNamingRule : IGlobalSemanticFormattingRule
     {
+        internal const string Name = "FieldNames";
+        internal const string Description = "Prefix private fields with _ and statics with s_";
+
         #region CommonRule
 
         private abstract class CommonRule
diff --git a/src/Microsoft.DotNet.CodeFormatting/Rules/UsingLocationRule.cs b/src/Microsoft.DotNet.CodeFormatting/Rules/UsingLocationRule.cs
@@ -16,9 +16,12 @@ namespace Microsoft.DotNet.CodeFormatting.Rules
     /// <summary>
     /// This will ensure that using directives are placed outside of the namespace.
     /// </summary>
-    [SyntaxRule(SyntaxRuleOrder.UsingLocationFormattingRule)]
+    [SyntaxRule(UsingLocationRule.Name, UsingLocationRule.Description, SyntaxRuleOrder.UsingLocationFormattingRule)]
     internal sealed class UsingLocationRule : CSharpOnlyFormattingRule, ISyntaxFormattingRule
     {
+        internal const string Name = "UsingLocation";
+        internal const string Description = "Place using directives outside namespace declarations";
+
         public SyntaxNode Process(SyntaxNode syntaxNode, string languageName)
         {
             var root = syntaxNode as CompilationUnitSyntax;

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,6 @@ public interface IFormattingEngine`
`20`	`20`	`bool Verbose { get; set; }`
`21`	`21`	`FormattingLevel FormattingLevel { get; set; }`
`22`	`22`	`Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);`
`23`		`- Task FormatProjectAsync(Project porject, CancellationToken cancellationToken);`
	`23`	`+ Task FormatProjectAsync(Project project, CancellationToken cancellationToken);`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,12 @@ namespace Microsoft.DotNet.CodeFormatting`
`7`	`7`	`{`
`8`	`8`	`public interface IRuleMetadata`
`9`	`9`	`{`
	`10`	`+ [DefaultValue("")]`
	`11`	`+ string Name { get; }`
	`12`	`+`
	`13`	`+ [DefaultValue("")]`
	`14`	`+ string Description { get; }`
	`15`	`+`
`10`	`16`	`[DefaultValue(int.MaxValue)]`
`11`	`17`	`int Order { get; }`
`12`	`18`
Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,12 @@`
`13`	`13`
`14`	`14`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`15`	`15`	`{`
`16`		`- [SyntaxRule(SyntaxRuleOrder.BraceNewLineRule)]`
	`16`	`+ [SyntaxRule(BraceNewLineRule.Name, BraceNewLineRule.Description, SyntaxRuleOrder.BraceNewLineRule)]`
`17`	`17`	`internal sealed class BraceNewLineRule : CSharpOnlyFormattingRule, ISyntaxFormattingRule`
`18`	`18`	`{`
	`19`	`+ internal const string Name = "BraceNewLine";`
	`20`	`+ internal const string Description = "Ensure all braces occur on a new line";`
	`21`	`+`
`19`	`22`	`private enum NewLineKind`
`20`	`23`	`{`
`21`	`24`	`WhitespaceAndNewLine,`
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,12 @@`
`12`	`12`
`13`	`13`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`14`	`14`	`{`
`15`		`- [SyntaxRule(SyntaxRuleOrder.CopyrightHeaderRule)]`
	`15`	`+ [SyntaxRule(CopyrightHeaderRule.Name, CopyrightHeaderRule.Description, SyntaxRuleOrder.CopyrightHeaderRule)]`
`16`	`16`	`internal sealed partial class CopyrightHeaderRule : SyntaxFormattingRule, ISyntaxFormattingRule`
`17`	`17`	`{`
	`18`	`+ internal const string Name = "Copyright";`
	`19`	`+ internal const string Description = "Insert the copyright header into every file";`
	`20`	`+`
`18`	`21`	`private abstract class CommonRule`
`19`	`22`	`{`
`20`	`23`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,12 @@`
`14`	`14`
`15`	`15`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`16`	`16`	`{`
`17`		`- [LocalSemanticRule(LocalSemanticRuleOrder.RemoveExplicitThisRule)]`
	`17`	`+ [LocalSemanticRule(ExplicitThisRule.Name, ExplicitThisRule.Description, LocalSemanticRuleOrder.RemoveExplicitThisRule)]`
`18`	`18`	`internal sealed class ExplicitThisRule : CSharpOnlyFormattingRule, ILocalSemanticFormattingRule`
`19`	`19`	`{`
	`20`	`+ internal const string Name = "ExplicitThis";`
	`21`	`+ internal const string Description = "Remove explicit this/Me prefixes on expressions except where necessary";`
	`22`	`+`
`20`	`23`	`private sealed class ExplicitThisRewriter : CSharpSyntaxRewriter`
`21`	`24`	`{`
`22`	`25`	`private readonly Document _document;`
Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,11 @@`
`17`	`17`
`18`	`18`	`namespace Microsoft.DotNet.CodeFormatting.Rules`
`19`	`19`	`{`
`20`		`- [LocalSemanticRule(LocalSemanticRuleOrder.IsFormattedFormattingRule)]`
	`20`	`+ [LocalSemanticRule(FormatDocumentFormattingRule.Name, FormatDocumentFormattingRule.Description, LocalSemanticRuleOrder.IsFormattedFormattingRule)]`
`21`	`21`	`internal sealed class FormatDocumentFormattingRule : ILocalSemanticFormattingRule`
`22`	`22`	`{`
	`23`	`+ internal const string Name = "FormatDocument";`
	`24`	`+ internal const string Description = "Run the language specific formatter on every document";`
`23`	`25`	`private readonly Options _options;`
`24`	`26`
`25`	`27`	`[ImportingConstructor]`