Allow copyright header customization

This change adds internal support for customizing the copyright header
the formatter adds.  This still needs to get an official command line
option but that can be added later.

The CombinationTests suite now passes again as well.  When the test was
first written the copyright rule was disabled as Roslyn used a different
copyright.  When I re-enabled that rule I forgot to run the test and
hence it ended up in a broken state.

Author: jaredpar

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

@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Xunit;
+using System.Collections.Immutable;
 
 namespace Microsoft.DotNet.CodeFormatting.Tests
 {
@@ -21,6 +22,11 @@ static CombinationTest()
             s_formattingEngine = (FormattingEngineImplementation)FormattingEngine.Create(Enumerable.Empty<string>(), Enumerable.Empty<string>());
         }
 
+        public CombinationTest()
+        {
+            s_formattingEngine.CopyrightHeader = ImmutableArray.Create("", "// header");
+        }
+
         protected override async Task<Document> RewriteDocumentAsync(Document document)
         {
             var solution = await s_formattingEngine.FormatCoreAsync(
@@ -43,6 +49,8 @@ void M() {
 }";
 
             var expected = @"
+// header
+
 internal class C
 {
     private int _field;
@@ -59,6 +67,7 @@ private void M()
         [Fact]
         public void FieldAssignment()
         {
+
             var text = @"
 class C {
     int field;
@@ -69,6 +78,8 @@ void M() {
 }";
 
             var expected = @"
+// header
+
 internal class C
 {
     private int _field;

src/Microsoft.DotNet.CodeFormatting/FormattingEngineImplementation.cs

@@ -20,26 +20,35 @@ namespace Microsoft.DotNet.CodeFormatting
     [Export(typeof(IFormattingEngine))]
     internal sealed class FormattingEngineImplementation : IFormattingEngine
     {
+        private readonly Options _options;
         private readonly IEnumerable<IFormattingFilter> _filters;
         private readonly IEnumerable<ISyntaxFormattingRule> _syntaxRules;
         private readonly IEnumerable<ILocalSemanticFormattingRule> _localSemanticRules;
         private readonly IEnumerable<IGlobalSemanticFormattingRule> _globalSemanticRules;
         private readonly Stopwatch _watch = new Stopwatch();
         private bool _verbose;
 
+        public ImmutableArray<string> CopyrightHeader
+        {
+            get { return _options.CopyrightHeader; }
+            set { _options.CopyrightHeader = value; }
+        }
+
         public bool Verbose
         {
             get { return _verbose; }
             set { _verbose = value; }
         }
 
         [ImportingConstructor]
-        public FormattingEngineImplementation(
+        internal FormattingEngineImplementation(
+            Options options,
             [ImportMany] IEnumerable<IFormattingFilter> filters,
             [ImportMany] IEnumerable<Lazy<ISyntaxFormattingRule, IOrderMetadata>> syntaxRules,
             [ImportMany] IEnumerable<Lazy<ILocalSemanticFormattingRule, IOrderMetadata>> localSemanticRules,
             [ImportMany] IEnumerable<Lazy<IGlobalSemanticFormattingRule, IOrderMetadata>> globalSemanticRules)
         {
+            _options = options;
             _filters = filters;
             _syntaxRules = syntaxRules.OrderBy(r => r.Metadata.Order).Select(r => r.Value).ToList();
             _localSemanticRules = localSemanticRules.OrderBy(r => r.Metadata.Order).Select(r => r.Value).ToList();

src/Microsoft.DotNet.CodeFormatting/IFormattingEngine.cs

@@ -6,11 +6,13 @@
 using System.Threading.Tasks;
 
 using Microsoft.CodeAnalysis;
+using System.Collections.Immutable;
 
 namespace Microsoft.DotNet.CodeFormatting
 {
     public interface IFormattingEngine
     {
+        ImmutableArray<string> CopyrightHeader { get; set; }
         bool Verbose { get; set; }
         Task FormatSolutionAsync(Solution solution, CancellationToken cancellationToken);
         Task FormatProjectAsync(Project porject, CancellationToken cancellationToken);

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

@@ -78,6 +78,7 @@
     <Compile Include="IFormattingFilter.cs" />
     <Compile Include="IFormattingRule.cs" />
     <Compile Include="Filters\IgnoreDesignerGeneratedCodeFilter.cs" />
+    <Compile Include="Options.cs" />
     <Compile Include="RuleOrderAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="IOrderMetadata.cs" />

src/Microsoft.DotNet.CodeFormatting/Options.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.CodeFormatting
+{
+    /// <summary>
+    /// This is a MEF importable type which contains all of the options for formatting
+    /// </summary>
+    [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; }
+
+        [ImportingConstructor]
+        internal Options()
+        {
+            CopyrightHeader = ImmutableArray.Create(s_defaultCopyrightHeader);
+        }
+    }
+}

src/Microsoft.DotNet.CodeFormatting/Rules/HasCopyrightHeaderFormattingRule.cs

@@ -16,11 +16,13 @@ namespace Microsoft.DotNet.CodeFormatting.Rules
     [SyntaxRuleOrder(SyntaxRuleOrder.HasCopyrightHeaderFormattingRule)]
     internal sealed class HasCopyrightHeaderFormattingRule : ISyntaxFormattingRule
     {
-        private static readonly string[] s_copyrightHeader =
+        private readonly Options _options;
+
+        [ImportingConstructor]
+        internal HasCopyrightHeaderFormattingRule(Options options)
         {
-            "// Copyright (c) Microsoft. All rights reserved.",
-            "// Licensed under the MIT license. See LICENSE file in the project root for full license information."
-        };
+            _options = options;
+        }
 
         public SyntaxNode Process(SyntaxNode syntaxNode)
         {
@@ -30,26 +32,27 @@ public SyntaxNode Process(SyntaxNode syntaxNode)
             return AddCopyrightHeader(syntaxNode);
         }
 
-        private static bool HasCopyrightHeader(SyntaxNode syntaxNode)
+        private bool HasCopyrightHeader(SyntaxNode syntaxNode)
         {
             var leadingComments = syntaxNode.GetLeadingTrivia().Where(t => t.CSharpKind() == SyntaxKind.SingleLineCommentTrivia).ToArray();
-            if (leadingComments.Length < s_copyrightHeader.Length)
+            var header = _options.CopyrightHeader;
+            if (leadingComments.Length < header.Length)
                 return false;
 
-            return leadingComments.Take(s_copyrightHeader.Length)
+            return leadingComments.Take(header.Length)
                                   .Select(t => t.ToFullString())
-                                  .SequenceEqual(s_copyrightHeader);
+                                  .SequenceEqual(header);
         }
 
-        private static SyntaxNode AddCopyrightHeader(SyntaxNode syntaxNode)
+        private SyntaxNode AddCopyrightHeader(SyntaxNode syntaxNode)
         {
             var newTrivia = GetCopyrightHeader().Concat(syntaxNode.GetLeadingTrivia());
             return syntaxNode.WithLeadingTrivia(newTrivia);
         }
 
-        private static IEnumerable<SyntaxTrivia> GetCopyrightHeader()
+        private IEnumerable<SyntaxTrivia> GetCopyrightHeader()
         {
-            foreach (var headerLine in s_copyrightHeader)
+            foreach (var headerLine in _options.CopyrightHeader)
             {
                 yield return SyntaxFactory.Comment(headerLine);
                 yield return SyntaxFactory.CarriageReturnLineFeed;