Copyright can now be specified on command line

The copyright text can now be specified on the command line by passing
in a file path that contains the relevant text.

Author: jaredpar

src/CodeFormatter/Program.cs

@@ -15,15 +15,19 @@ namespace CodeFormatter
 {
     internal static class Program
     {
+        private const string FileSwitch = "/file:";
+        private const string ConfigSwitch = "/c:";
+        private const string CopyrightSwitch = "/copyright:";
+
         private static int Main(string[] args)
         {
             if (args.Length < 1)
             {
-                Console.WriteLine("CodeFormatter <project or solution> [<rule types>] [/file:<filename>] [/nocopyright] [/c:<config1,config2>");
+                Console.WriteLine("CodeFormatter <project or solution> [<rule types>] [/file:<filename>] [/nocopyright] [/c:<config1,config2> [/copyright:file]");
                 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("    <configs>    - Additional preprocessor configurations the formatter")
+                Console.WriteLine("    <configs>    - Additional preprocessor configurations the formatter");
                 Console.WriteLine("                   should run under");
                 return -1;
             }
@@ -38,27 +42,41 @@ private static int Main(string[] args)
             var fileNamesBuilder = ImmutableArray.CreateBuilder<string>();
             var ruleTypeBuilder = ImmutableArray.CreateBuilder<string>();
             var configBuilder = ImmutableArray.CreateBuilder<string[]>();
+            var copyrightHeader = FormattingConstants.DefaultCopyrightHeader;
             var comparer = StringComparer.OrdinalIgnoreCase;
-            var disableCopyright = false;
 
             for (int i = 1; i < args.Length; i++)
             {
                 string arg = args[i];
-                if (arg.StartsWith("/file:", StringComparison.OrdinalIgnoreCase))
+                if (arg.StartsWith(FileSwitch, StringComparison.OrdinalIgnoreCase))
                 {
-                    var all = arg.Substring(6);
+                    var all = arg.Substring(FileSwitch.Length);
                     var files = all.Split(new[] { ','}, StringSplitOptions.RemoveEmptyEntries);
                     fileNamesBuilder.AddRange(files);
                 }
-                else if (arg.StartsWith("/c:", StringComparison.OrdinalIgnoreCase))
+                else if (arg.StartsWith(ConfigSwitch, StringComparison.OrdinalIgnoreCase))
                 {
-                    var all = arg.Substring(3);
+                    var all = arg.Substring(ConfigSwitch.Length);
                     var configs = all.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                     configBuilder.Add(configs);
                 }
+                else if (arg.StartsWith(CopyrightSwitch, StringComparison.OrdinalIgnoreCase))
+                {
+                    var fileName = arg.Substring(CopyrightSwitch.Length);
+                    try
+                    {
+                        copyrightHeader = ImmutableArray.CreateRange(File.ReadAllLines(fileName));
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.Error.WriteLine("Could not read {0}", fileName);
+                        Console.Error.WriteLine(ex.Message);
+                        return -1;
+                    }
+                }
                 else if (comparer.Equals(arg, "/nocopyright"))
                 {
-                    disableCopyright = true;
+                    copyrightHeader = ImmutableArray<string>.Empty;
                 }
                 else
                 {
@@ -76,7 +94,7 @@ private static int Main(string[] args)
                 ruleTypeBuilder.ToImmutableArray(),
                 fileNamesBuilder.ToImmutableArray(),
                 configBuilder.ToImmutableArray(),
-                disableCopyright, 
+                copyrightHeader,
                 ct).Wait(ct);
             Console.WriteLine("Completed formatting.");
             return 0;
@@ -87,18 +105,14 @@ private static async Task RunAsync(
             ImmutableArray<string> ruleTypes, 
             ImmutableArray<string> fileNames, 
             ImmutableArray<string[]> preprocessorConfigurations, 
-            bool disableCopright, 
+            ImmutableArray<string> copyrightHeader,
             CancellationToken cancellationToken)
         {
             var workspace = MSBuildWorkspace.Create();
             var engine = FormattingEngine.Create(ruleTypes);
             engine.PreprocessorConfigurations = preprocessorConfigurations;
             engine.FileNames = fileNames;
-
-            if (disableCopright)
-            {
-                engine.CopyrightHeader = ImmutableArray<string>.Empty;
-            }
+            engine.CopyrightHeader = copyrightHeader;
 
             string extension = Path.GetExtension(projectOrSolutionPath);
             if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln"))

src/Microsoft.DotNet.CodeFormatting/FormattingConstants.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.CodeFormatting
+{
+    public static class FormattingConstants
+    {
+        private static readonly string[] s_defaultCopyrightHeader =
+        {
+            "// Copyright (c) Microsoft. All rights reserved.",
+            "// Licensed under the MIT license. See LICENSE file in the project root for full license information."
+        };
+
+        public static readonly ImmutableArray<string> DefaultCopyrightHeader;
+
+        static FormattingConstants()
+        {
+            DefaultCopyrightHeader = ImmutableArray.CreateRange(s_defaultCopyrightHeader);
+        }
+    }
+}

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

@@ -74,6 +74,7 @@
     <Compile Include="Extensions.cs" />
     <Compile Include="Filters\FilenameFilter.cs" />
     <Compile Include="Filters\UsableFileFilter.cs" />
+    <Compile Include="FormattingConstants.cs" />
     <Compile Include="FormattingEngine.cs" />
     <Compile Include="FormattingEngineImplementation.cs" />
     <Compile Include="IFormatLogger.cs" />

src/Microsoft.DotNet.CodeFormatting/Options.cs

@@ -14,12 +14,6 @@ namespace Microsoft.DotNet.CodeFormatting
     [Export(typeof(Options))]
     internal sealed class Options
     {
-        private static readonly string[] s_defaultCopyrightHeader =
-        {
-            "// Copyright (c) Microsoft. All rights reserved.",
-            "// Licensed under the MIT license. See LICENSE file in the project root for full license information."
-        };
-
         internal ImmutableArray<string> CopyrightHeader { get; set; }
         internal ImmutableArray<string[]> PreprocessorConfigurations { get; set; }
 
@@ -33,7 +27,8 @@ internal sealed class Options
         [ImportingConstructor]
         internal Options()
         {
-            CopyrightHeader = ImmutableArray.Create(s_defaultCopyrightHeader);
+            CopyrightHeader = FormattingConstants.DefaultCopyrightHeader;
+            FileNames = ImmutableArray<string>.Empty;
             PreprocessorConfigurations = ImmutableArray<string[]>.Empty;
             FormatLogger = new ConsoleFormatLogger();
         }