Fixed up command line handling

Change makes a couple of small updates:

1. Standardized the command line argument handling to be /option:data
vs. /option data.  I chose the colon version because it seemed more
consistent with other .Net tools out there.  I don't have a strong
opinion here though.

2. Changed FilenameFilter to go through Options vs. custom handling the
command line argument.

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -19,10 +19,12 @@ private static int Main(string[] args)
         {
             if (args.Length < 1)
             {
-                Console.WriteLine("CodeFormatter <project or solution> [<rule types>] [/file <filename>] [/nocopyright]");
+                Console.WriteLine("CodeFormatter <project or solution> [<rule types>] [/file:<filename>] [/nocopyright] [/c:<config1,config2>");
                 Console.WriteLine("    <rule types> - Rule types to use in addition to the default ones.");
                 Console.WriteLine("                   Use ConvertTests to convert MSTest tests to xUnit.");
-                Console.WriteLine("    <filename> - Only apply changes to files with specified name.");
+                Console.WriteLine("    <filename>   - Only apply changes to files with specified name.");
+                Console.WriteLine("    <configs>    - Additional preprocessor configurations the formatter")
+                Console.WriteLine("                   should run under");
                 return -1;
             }
 
@@ -33,37 +35,34 @@ private static int Main(string[] args)
                 return -1;
             }
 
-            var ruleTypes = new List<string>();
-            var filenames = new List<string>();
-            var disableCopyright = false;
+            var fileNamesBuilder = ImmutableArray.CreateBuilder<string>();
+            var ruleTypeBuilder = ImmutableArray.CreateBuilder<string>();
+            var configBuilder = ImmutableArray.CreateBuilder<string[]>();
             var comparer = StringComparer.OrdinalIgnoreCase;
-            var preprocessorConfigurations = new List<string[]>();
+            var disableCopyright = false;
 
             for (int i = 1; i < args.Length; i++)
             {
                 string arg = args[i];
-                if (comparer.Equals(arg, "/file"))
-                {
-                    if (i + 1 < args.Length)
-                    {
-                        string param = args[i + 1];
-                        filenames.Add(param);
-                        i++;
-                    }
-                }
-                else if (comparer.Equals(arg, "/nocopyright"))
+                if (arg.StartsWith("/file:", StringComparison.OrdinalIgnoreCase))
                 {
-                    disableCopyright = true;
+                    var all = arg.Substring(6);
+                    var files = all.Split(new[] { ','}, StringSplitOptions.RemoveEmptyEntries);
+                    fileNamesBuilder.AddRange(files);
                 }
                 else if (arg.StartsWith("/c:", StringComparison.OrdinalIgnoreCase))
                 {
                     var all = arg.Substring(3);
                     var configs = all.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
-                    preprocessorConfigurations.Add(configs);
+                    configBuilder.Add(configs);
+                }
+                else if (comparer.Equals(arg, "/nocopyright"))
+                {
+                    disableCopyright = true;
                 }
                 else
                 {
-                    ruleTypes.Add(arg);
+                    ruleTypeBuilder.Add(arg);
                 }
             }
 
@@ -72,16 +71,29 @@ private static int Main(string[] args)
 
             Console.CancelKeyPress += delegate { cts.Cancel(); };
 
-            RunAsync(projectOrSolutionPath, ruleTypes, filenames, disableCopyright, ImmutableArray.CreateRange(preprocessorConfigurations), ct).Wait(ct);
+            RunAsync(
+                projectOrSolutionPath, 
+                ruleTypeBuilder.ToImmutableArray(),
+                fileNamesBuilder.ToImmutableArray(),
+                configBuilder.ToImmutableArray(),
+                disableCopyright, 
+                ct).Wait(ct);
             Console.WriteLine("Completed formatting.");
             return 0;
         }
 
-        private static async Task RunAsync(string projectOrSolutionPath, IEnumerable<string> ruleTypes, IEnumerable<string> filenames, bool disableCopright, ImmutableArray<string[]> preprocessorConfigurations, CancellationToken cancellationToken)
+        private static async Task RunAsync(
+            string projectOrSolutionPath, 
+            ImmutableArray<string> ruleTypes, 
+            ImmutableArray<string> fileNames, 
+            ImmutableArray<string[]> preprocessorConfigurations, 
+            bool disableCopright, 
+            CancellationToken cancellationToken)
         {
             var workspace = MSBuildWorkspace.Create();
-            var engine = FormattingEngine.Create(ruleTypes, filenames);
+            var engine = FormattingEngine.Create(ruleTypes);
             engine.PreprocessorConfigurations = preprocessorConfigurations;
+            engine.FileNames = fileNames;
 
             if (disableCopright)
             {

src/Microsoft.DotNet.CodeFormatting.Tests/Rules/CombinationTest.cs

@@ -19,7 +19,7 @@ public sealed class CombinationTest : CodeFormattingTestBase
 
         static CombinationTest()
         {
-            s_formattingEngine = (FormattingEngineImplementation)FormattingEngine.Create(Enumerable.Empty<string>(), Enumerable.Empty<string>());
+            s_formattingEngine = (FormattingEngineImplementation)FormattingEngine.Create(ImmutableArray<string>.Empty);
         }
 
         public CombinationTest()

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

@@ -12,27 +12,29 @@
 
 namespace Microsoft.DotNet.CodeFormatting.Filters
 {
+    [Export(typeof(IFormattingFilter))]
     internal sealed class FilenameFilter : IFormattingFilter
     {
-        private IEnumerable<string> _filenames;
+        private readonly Options _options;
 
-        public FilenameFilter(IEnumerable<string> filenames)
+        [ImportingConstructor]
+        public FilenameFilter(Options options)
         {
-            _filenames = filenames;
+            _options = options;
         }
 
         public bool ShouldBeProcessed(Document document)
         {
-            if (!_filenames.Any())
+            var fileNames = _options.FileNames;
+            if (fileNames.IsDefaultOrEmpty)
             {
                 return true;
             }
 
             string docFilename = Path.GetFileName(document.FilePath);
-
-            foreach (var filename in _filenames)
+            foreach (var filename in fileNames)
             {
-                if (filename.Equals(docFilename, StringComparison.InvariantCultureIgnoreCase))
+                if (filename.Equals(docFilename, StringComparison.OrdinalIgnoreCase))
                 {
                     return true;
                 }

src/Microsoft.DotNet.CodeFormatting/FormattingEngine.cs

@@ -8,12 +8,13 @@
 using System.Collections.Generic;
 using Microsoft.DotNet.CodeFormatting.Rules;
 using Microsoft.DotNet.CodeFormatting.Filters;
+using System.Collections.Immutable;
 
 namespace Microsoft.DotNet.CodeFormatting
 {
     public static class FormattingEngine
     {
-        public static IFormattingEngine Create(IEnumerable<string> ruleTypes, IEnumerable<string> filenames)
+        public static IFormattingEngine Create(ImmutableArray<string> ruleTypes)
         {
             var catalog = new AssemblyCatalog(typeof(FormattingEngine).Assembly);
 
@@ -46,12 +47,6 @@ public static IFormattingEngine Create(IEnumerable<string> ruleTypes, IEnumerabl
             });
 
             var container = new CompositionContainer(filteredCatalog);
-
-            if (filenames.Any())
-            {
-                container.ComposeExportedValue<IFormattingFilter>(new FilenameFilter(filenames));
-            }
-
             var engine = container.GetExportedValue<IFormattingEngine>();
             var consoleFormatLogger = new ConsoleFormatLogger();
 

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -42,6 +42,12 @@ public ImmutableArray<string[]> PreprocessorConfigurations
             set { _options.PreprocessorConfigurations = value; }
         }
 
+        public ImmutableArray<string> FileNames
+        {
+            get { return _options.FileNames; }
+            set { _options.FileNames = value; }
+        }
+
         public IFormatLogger FormatLogger
         {
             get { return _options.FormatLogger; }

src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs

@@ -14,6 +14,7 @@ public interface IFormattingEngine
     {
         ImmutableArray<string> CopyrightHeader { get; set; }
         ImmutableArray<string[]> PreprocessorConfigurations { get; set; }
+        ImmutableArray<string> FileNames { get; set; }
         Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);
         Task FormatProjectAsync(Project porject, CancellationToken cancellationToken);
     }

src/Microsoft.DotNet.CodeFormatting/Options.cs

@@ -22,6 +22,12 @@ internal sealed class Options
 
         internal ImmutableArray<string> CopyrightHeader { get; set; }
         internal ImmutableArray<string[]> PreprocessorConfigurations { get; set; }
+
+        /// <summary>
+        /// When non-empty the formatter will only process files with the specified name.
+        /// </summary>
+        internal ImmutableArray<string> FileNames { get; set; }
+
         internal IFormatLogger FormatLogger { get; set; }
 
         [ImportingConstructor]