From 244b46cf7f3252d6dc3884ce184be901d1d173e5 Mon Sep 17 00:00:00 2001 From: Sean Hall Date: Sun, 2 Sep 2018 16:12:29 -0500 Subject: Migrate WixCop into Tools from wix4. --- Tools.sln | 18 + src/WixToolset.BuildTasks/Common.cs | 41 -- src/WixToolset.BuildTasks/ConvertReferences.cs | 7 +- .../RefreshBundleGeneratedFile.cs | 9 +- src/WixToolset.BuildTasks/RefreshGeneratedFile.cs | 9 +- .../WixToolset.BuildTasks.csproj | 4 + .../ConsoleMessageListener.cs | 56 ++ .../WixToolset.Tools.Core.csproj | 28 + src/Wixtoolset.Tools.Core/ToolsCommon.cs | 39 ++ src/test/wixcop/ConverterFixture.cs | 418 ++++++++++++++ .../TestData/SingleFile/ConvertedSingleFile.wxs | 60 ++ src/test/wixcop/TestData/SingleFile/SingleFile.wxs | 61 ++ src/test/wixcop/WixCopFixture.cs | 107 ++++ src/test/wixcop/WixCopTests.csproj | 41 ++ src/wix/Program.cs | 48 +- src/wix/wix.csproj | 4 + src/wixcop/CommandLine/ConvertCommand.cs | 212 +++++++ src/wixcop/CommandLine/HelpCommand.cs | 25 + src/wixcop/CommandLine/WixCopCommandLineParser.cs | 132 +++++ src/wixcop/Converter.cs | 633 +++++++++++++++++++++ src/wixcop/Interfaces/IWixCopCommandLineParser.cs | 11 + src/wixcop/Program.cs | 67 +++ src/wixcop/WixCop.csproj | 32 ++ 23 files changed, 1957 insertions(+), 105 deletions(-) delete mode 100644 src/WixToolset.BuildTasks/Common.cs create mode 100644 src/WixToolset.Tools.Core/ConsoleMessageListener.cs create mode 100644 src/WixToolset.Tools.Core/WixToolset.Tools.Core.csproj create mode 100644 src/Wixtoolset.Tools.Core/ToolsCommon.cs create mode 100644 src/test/wixcop/ConverterFixture.cs create mode 100644 src/test/wixcop/TestData/SingleFile/ConvertedSingleFile.wxs create mode 100644 src/test/wixcop/TestData/SingleFile/SingleFile.wxs create mode 100644 src/test/wixcop/WixCopFixture.cs create mode 100644 src/test/wixcop/WixCopTests.csproj create mode 100644 src/wixcop/CommandLine/ConvertCommand.cs create mode 100644 src/wixcop/CommandLine/HelpCommand.cs create mode 100644 src/wixcop/CommandLine/WixCopCommandLineParser.cs create mode 100644 src/wixcop/Converter.cs create mode 100644 src/wixcop/Interfaces/IWixCopCommandLineParser.cs create mode 100644 src/wixcop/Program.cs create mode 100644 src/wixcop/WixCop.csproj diff --git a/Tools.sln b/Tools.sln index 63c7ea4e..ca2e23d6 100644 --- a/Tools.sln +++ b/Tools.sln @@ -18,6 +18,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution .editorconfig = .editorconfig EndProjectSection EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WixCop", "src\wixcop\WixCop.csproj", "{2E54120B-8958-40B1-A7FC-851446994CD8}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WixToolset.Tools.Core", "src\WixToolset.Tools.Core\WixToolset.Tools.Core.csproj", "{9C3B486F-AE0E-43BA-823A-30808B73C6B4}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WixCopTests", "src\test\wixcop\WixCopTests.csproj", "{F1A8112B-95A1-4AF7-81CB-523BE7DB8E5C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -44,6 +50,18 @@ Global {0DF5D4CF-8457-469D-8288-13775E984F70}.Debug|Any CPU.Build.0 = Debug|Any CPU {0DF5D4CF-8457-469D-8288-13775E984F70}.Release|Any CPU.ActiveCfg = Release|Any CPU {0DF5D4CF-8457-469D-8288-13775E984F70}.Release|Any CPU.Build.0 = Release|Any CPU + {2E54120B-8958-40B1-A7FC-851446994CD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2E54120B-8958-40B1-A7FC-851446994CD8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2E54120B-8958-40B1-A7FC-851446994CD8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2E54120B-8958-40B1-A7FC-851446994CD8}.Release|Any CPU.Build.0 = Release|Any CPU + {9C3B486F-AE0E-43BA-823A-30808B73C6B4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9C3B486F-AE0E-43BA-823A-30808B73C6B4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9C3B486F-AE0E-43BA-823A-30808B73C6B4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9C3B486F-AE0E-43BA-823A-30808B73C6B4}.Release|Any CPU.Build.0 = Release|Any CPU + {F1A8112B-95A1-4AF7-81CB-523BE7DB8E5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F1A8112B-95A1-4AF7-81CB-523BE7DB8E5C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F1A8112B-95A1-4AF7-81CB-523BE7DB8E5C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F1A8112B-95A1-4AF7-81CB-523BE7DB8E5C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/WixToolset.BuildTasks/Common.cs b/src/WixToolset.BuildTasks/Common.cs deleted file mode 100644 index 803e9d14..00000000 --- a/src/WixToolset.BuildTasks/Common.cs +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. - -namespace WixToolset -{ - using System; - using System.Globalization; - using System.Text; - using System.Text.RegularExpressions; - - /// - /// Common WixTasks utility methods and types. - /// - internal static class Common - { - /// Metadata key name to turn off harvesting of project references. - public const string DoNotHarvest = "DoNotHarvest"; - - private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled); - private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters - - /// - /// Return an identifier based on passed file/directory name - /// - /// File/directory name to generate identifer from - /// A version of the name that is a legal identifier. - /// This is duplicated from WiX's Common class. - internal static string GetIdentifierFromName(string name) - { - string result = IllegalIdentifierCharacters.Replace(name, "_"); // replace illegal characters with "_". - - // MSI identifiers must begin with an alphabetic character or an - // underscore. Prefix all other values with an underscore. - if (AddPrefix.IsMatch(name)) - { - result = String.Concat("_", result); - } - - return result; - } - } -} diff --git a/src/WixToolset.BuildTasks/ConvertReferences.cs b/src/WixToolset.BuildTasks/ConvertReferences.cs index fe137633..ef50c918 100644 --- a/src/WixToolset.BuildTasks/ConvertReferences.cs +++ b/src/WixToolset.BuildTasks/ConvertReferences.cs @@ -3,13 +3,10 @@ namespace WixToolset.BuildTasks { using System; - using System.Collections; using System.Collections.Generic; - using System.Globalization; - using System.IO; - using System.Xml; using Microsoft.Build.Framework; using Microsoft.Build.Utilities; + using WixToolset.Tools.Core; /// /// This task assigns Culture metadata to files based on the value of the Culture attribute on the @@ -62,7 +59,7 @@ namespace WixToolset.BuildTasks { Dictionary newItemMetadeta = new Dictionary(); - if (!String.IsNullOrEmpty(item.GetMetadata(Common.DoNotHarvest))) + if (!String.IsNullOrEmpty(item.GetMetadata(ToolsCommon.DoNotHarvest))) { continue; } diff --git a/src/WixToolset.BuildTasks/RefreshBundleGeneratedFile.cs b/src/WixToolset.BuildTasks/RefreshBundleGeneratedFile.cs index 5445e0cd..80305f59 100644 --- a/src/WixToolset.BuildTasks/RefreshBundleGeneratedFile.cs +++ b/src/WixToolset.BuildTasks/RefreshBundleGeneratedFile.cs @@ -6,19 +6,16 @@ namespace WixToolset.BuildTasks using System.Collections; using System.Globalization; using System.IO; - using System.Text.RegularExpressions; using System.Xml; using Microsoft.Build.Framework; using Microsoft.Build.Utilities; + using WixToolset.Tools.Core; /// /// This task refreshes the generated file for bundle projects. /// public class RefreshBundleGeneratedFile : Task { - private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled); - private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters - private ITaskItem[] generatedFiles; private ITaskItem[] projectReferencePaths; @@ -54,14 +51,14 @@ namespace WixToolset.BuildTasks { ITaskItem item = this.ProjectReferencePaths[i]; - if (!String.IsNullOrEmpty(item.GetMetadata(Common.DoNotHarvest))) + if (!String.IsNullOrEmpty(item.GetMetadata(ToolsCommon.DoNotHarvest))) { continue; } string projectPath = CreateProjectReferenceDefineConstants.GetProjectPath(this.ProjectReferencePaths, i); string projectName = Path.GetFileNameWithoutExtension(projectPath); - string referenceName = Common.GetIdentifierFromName(CreateProjectReferenceDefineConstants.GetReferenceName(item, projectName)); + string referenceName = ToolsCommon.GetIdentifierFromName(CreateProjectReferenceDefineConstants.GetReferenceName(item, projectName)); string[] pogs = item.GetMetadata("RefProjectOutputGroups").Split(';'); foreach (string pog in pogs) diff --git a/src/WixToolset.BuildTasks/RefreshGeneratedFile.cs b/src/WixToolset.BuildTasks/RefreshGeneratedFile.cs index fdfc4774..101b5363 100644 --- a/src/WixToolset.BuildTasks/RefreshGeneratedFile.cs +++ b/src/WixToolset.BuildTasks/RefreshGeneratedFile.cs @@ -6,10 +6,10 @@ namespace WixToolset.BuildTasks using System.Collections; using System.Globalization; using System.IO; - using System.Text.RegularExpressions; using System.Xml; using Microsoft.Build.Framework; using Microsoft.Build.Utilities; + using WixToolset.Tools.Core; /// /// This task refreshes the generated file that contains ComponentGroupRefs @@ -17,9 +17,6 @@ namespace WixToolset.BuildTasks /// public class RefreshGeneratedFile : Task { - private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled); - private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters - private ITaskItem[] generatedFiles; private ITaskItem[] projectReferencePaths; @@ -54,14 +51,14 @@ namespace WixToolset.BuildTasks { ITaskItem item = this.ProjectReferencePaths[i]; - if (!String.IsNullOrEmpty(item.GetMetadata(Common.DoNotHarvest))) + if (!String.IsNullOrEmpty(item.GetMetadata(ToolsCommon.DoNotHarvest))) { continue; } string projectPath = CreateProjectReferenceDefineConstants.GetProjectPath(this.ProjectReferencePaths, i); string projectName = Path.GetFileNameWithoutExtension(projectPath); - string referenceName = Common.GetIdentifierFromName(CreateProjectReferenceDefineConstants.GetReferenceName(item, projectName)); + string referenceName = ToolsCommon.GetIdentifierFromName(CreateProjectReferenceDefineConstants.GetReferenceName(item, projectName)); string[] pogs = item.GetMetadata("RefProjectOutputGroups").Split(';'); foreach (string pog in pogs) diff --git a/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj b/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj index 8a5c388d..39c8824c 100644 --- a/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj +++ b/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj @@ -27,6 +27,10 @@ + + + + diff --git a/src/WixToolset.Tools.Core/ConsoleMessageListener.cs b/src/WixToolset.Tools.Core/ConsoleMessageListener.cs new file mode 100644 index 00000000..5b1fb988 --- /dev/null +++ b/src/WixToolset.Tools.Core/ConsoleMessageListener.cs @@ -0,0 +1,56 @@ +using System; +using System.Globalization; +using System.Text; +using System.Threading; +using WixToolset.Data; +using WixToolset.Extensibility; + +namespace WixToolset.Tools.Core +{ + public sealed class ConsoleMessageListener : IMessageListener + { + public ConsoleMessageListener(string shortName, string longName) + { + this.ShortAppName = shortName; + this.LongAppName = longName; + + PrepareConsoleForLocalization(); + } + + public string LongAppName { get; } + + public string ShortAppName { get; } + + public void Write(Message message) + { + var filename = message.SourceLineNumbers?.FileName ?? this.LongAppName; + var line = message.SourceLineNumbers?.LineNumber ?? -1; + var type = message.Level.ToString().ToLowerInvariant(); + var output = message.Level >= MessageLevel.Warning ? Console.Out : Console.Error; + + if (line > 0) + { + filename = String.Concat(filename, "(", line, ")"); + } + + output.WriteLine("{0} : {1} {2}{3:0000}: {4}", filename, type, this.ShortAppName, message.Id, message.ToString()); + } + + public void Write(string message) + { + Console.Out.WriteLine(message); + } + + private static void PrepareConsoleForLocalization() + { + Thread.CurrentThread.CurrentUICulture = CultureInfo.CurrentUICulture.GetConsoleFallbackUICulture(); + + if (Console.OutputEncoding.CodePage != Encoding.UTF8.CodePage && + Console.OutputEncoding.CodePage != Thread.CurrentThread.CurrentUICulture.TextInfo.OEMCodePage && + Console.OutputEncoding.CodePage != Thread.CurrentThread.CurrentUICulture.TextInfo.ANSICodePage) + { + Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); + } + } + } +} diff --git a/src/WixToolset.Tools.Core/WixToolset.Tools.Core.csproj b/src/WixToolset.Tools.Core/WixToolset.Tools.Core.csproj new file mode 100644 index 00000000..8be70e6b --- /dev/null +++ b/src/WixToolset.Tools.Core/WixToolset.Tools.Core.csproj @@ -0,0 +1,28 @@ + + + + + + netstandard2.0 + Tools Core + WiX Toolset Tools Core + embedded + true + + + + + + + + + + + + + + + + + + diff --git a/src/Wixtoolset.Tools.Core/ToolsCommon.cs b/src/Wixtoolset.Tools.Core/ToolsCommon.cs new file mode 100644 index 00000000..37d89f3c --- /dev/null +++ b/src/Wixtoolset.Tools.Core/ToolsCommon.cs @@ -0,0 +1,39 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Tools.Core +{ + using System; + using System.Text.RegularExpressions; + + /// + /// Common WixTasks utility methods and types. + /// + public static class ToolsCommon + { + /// Metadata key name to turn off harvesting of project references. + public const string DoNotHarvest = "DoNotHarvest"; + + private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled); + private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters + + /// + /// Return an identifier based on passed file/directory name + /// + /// File/directory name to generate identifer from + /// A version of the name that is a legal identifier. + /// This is duplicated from WiX's Common class. + public static string GetIdentifierFromName(string name) + { + string result = IllegalIdentifierCharacters.Replace(name, "_"); // replace illegal characters with "_". + + // MSI identifiers must begin with an alphabetic character or an + // underscore. Prefix all other values with an underscore. + if (AddPrefix.IsMatch(name)) + { + result = String.Concat("_", result); + } + + return result; + } + } +} diff --git a/src/test/wixcop/ConverterFixture.cs b/src/test/wixcop/ConverterFixture.cs new file mode 100644 index 00000000..45ccc33e --- /dev/null +++ b/src/test/wixcop/ConverterFixture.cs @@ -0,0 +1,418 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixTest.WixUnitTest +{ + using System; + using System.IO; + using System.Text; + using System.Xml.Linq; + using WixCop; + using WixToolset; + using WixToolset.Data; + using WixToolset.Extensibility; + using WixToolset.Extensibility.Services; + using Xunit; + + public class ConverterFixture + { + private static readonly XNamespace Wix4Namespace = "http://wixtoolset.org/schemas/v4/wxs"; + + [Fact] + public void EnsuresDeclaration() + { + string parse = String.Join(Environment.NewLine, + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(1, errors); + Assert.Equal(expected, actual); + } + + [Fact] + public void EnsuresUtf8Declaration() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 4, null, null); + + int errors = converter.ConvertDocument(document); + + Assert.Equal(1, errors); + Assert.Equal("1.0", document.Declaration.Version); + Assert.Equal("utf-8", document.Declaration.Encoding); + } + + [Fact] + public void CanFixWhitespace() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + " ", + " ", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + " ", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 4, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(4, errors); + Assert.Equal(expected, actual); + } + + [Fact] + public void CanFixCdataWhitespace() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + " ", + " ", + " ", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + " ", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(2, errors); + Assert.Equal(expected, actual); + } + + [Fact] + public void CanConvertMainNamespace() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(1, errors); + //Assert.Equal(Wix4Namespace, document.Root.GetDefaultNamespace()); + Assert.Equal(expected, actual); + } + + [Fact] + public void CanConvertNamedMainNamespace() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(1, errors); + Assert.Equal(expected, actual); + Assert.Equal(Wix4Namespace, document.Root.GetNamespaceOfPrefix("w")); + } + + [Fact] + public void CanConvertNonWixDefaultNamespace() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + " ", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + " ", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(2, errors); + Assert.Equal(expected, actual); + Assert.Equal(Wix4Namespace, document.Root.GetNamespaceOfPrefix("w")); + Assert.Equal("http://wixtoolset.org/schemas/v4/wxs/util", document.Root.GetDefaultNamespace()); + } + + [Fact] + public void CanConvertExtensionNamespace() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(2, errors); + Assert.Equal(expected, actual); + Assert.Equal(Wix4Namespace, document.Root.GetDefaultNamespace()); + } + + [Fact] + public void CanConvertMissingNamespace() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(1, errors); + Assert.Equal(expected, actual); + Assert.Equal(Wix4Namespace, document.Root.GetDefaultNamespace()); + } + + [Fact] + public void CanConvertAnonymousFile() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(1, errors); + Assert.Equal(expected, actual); + } + + [Fact] + public void CanConvertSuppressSignatureValidationNo() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(1, errors); + Assert.Equal(expected, actual); + } + + [Fact] + public void CanConvertSuppressSignatureValidationYes() + { + string parse = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + string expected = String.Join(Environment.NewLine, + "", + "", + " ", + ""); + + XDocument document = XDocument.Parse(parse, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + + var messaging = new DummyMessaging(); + Converter converter = new Converter(messaging, 2, null, null); + + int errors = converter.ConvertDocument(document); + + string actual = UnformattedDocumentString(document); + + Assert.Equal(1, errors); + Assert.Equal(expected, actual); + } + + private static string UnformattedDocumentString(XDocument document) + { + StringBuilder sb = new StringBuilder(); + + using (StringWriter writer = new StringWriter(sb)) + { + document.Save(writer, SaveOptions.DisableFormatting | SaveOptions.OmitDuplicateNamespaces); + } + + return sb.ToString(); + } + + private class DummyMessaging : IMessaging + { + public bool EncounteredError { get; set; } + + public int LastErrorNumber { get; set; } + + public bool ShowVerboseMessages { get; set; } + public bool SuppressAllWarnings { get; set; } + public bool WarningsAsError { get; set; } + + public void ElevateWarningMessage(int warningNumber) + { + } + + public string FormatMessage(Message message) + { + return ""; + } + + public void SetListener(IMessageListener listener) + { + } + + public void SuppressWarningMessage(int warningNumber) + { + } + + public void Write(Message message) + { + } + + public void Write(string message, bool verbose = false) + { + } + } + } +} diff --git a/src/test/wixcop/TestData/SingleFile/ConvertedSingleFile.wxs b/src/test/wixcop/TestData/SingleFile/ConvertedSingleFile.wxs new file mode 100644 index 00000000..aacb68fa --- /dev/null +++ b/src/test/wixcop/TestData/SingleFile/ConvertedSingleFile.wxs @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/test/wixcop/TestData/SingleFile/SingleFile.wxs b/src/test/wixcop/TestData/SingleFile/SingleFile.wxs new file mode 100644 index 00000000..310ae811 --- /dev/null +++ b/src/test/wixcop/TestData/SingleFile/SingleFile.wxs @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/test/wixcop/WixCopFixture.cs b/src/test/wixcop/WixCopFixture.cs new file mode 100644 index 00000000..12863959 --- /dev/null +++ b/src/test/wixcop/WixCopFixture.cs @@ -0,0 +1,107 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using WixBuildTools.TestSupport; +using WixCop.CommandLine; +using WixCop.Interfaces; +using WixToolset.Core; +using WixToolset.Core.TestPackage; +using WixToolset.Extensibility; +using WixToolset.Extensibility.Services; +using Xunit; + +namespace WixCopTests +{ + public class WixCopFixture + { + [Fact] + public void CanConvertSingleFile() + { + const string beforeFileName = "SingleFile.wxs"; + const string afterFileName = "ConvertedSingleFile.wxs"; + var folder = TestData.Get(@"TestData\SingleFile"); + + using (var fs = new DisposableFileSystem()) + { + var baseFolder = fs.GetFolder(true); + var targetFile = Path.Combine(baseFolder, beforeFileName); + File.Copy(Path.Combine(folder, beforeFileName), Path.Combine(baseFolder, beforeFileName)); + + var runner = new WixCopRunner + { + FixErrors = true, + SearchPatterns = + { + targetFile, + }, + }; + + var result = runner.Execute(out var messages); + + Assert.Equal(2, result); + + var actualLines = File.ReadAllLines(targetFile); + var expectedLines = File.ReadAllLines(Path.Combine(folder, afterFileName)); + Assert.Equal(expectedLines, actualLines); + + var runner2 = new WixCopRunner + { + FixErrors = true, + SearchPatterns = + { + targetFile, + }, + }; + + var result2 = runner2.Execute(out var messages2); + + Assert.Equal(0, result2); + } + } + + private class WixCopRunner + { + public bool FixErrors { get; set; } + + public List SearchPatterns { get; } = new List(); + + public int Execute(out List messages) + { + var argList = new List(); + if (this.FixErrors) + { + argList.Add("-f"); + } + + foreach (string searchPattern in this.SearchPatterns) + { + argList.Add(searchPattern); + } + + return WixCopRunner.Execute(argList.ToArray(), out messages); + } + + public static int Execute(string[] args, out List messages) + { + var listener = new TestMessageListener(); + + var serviceProvider = new WixToolsetServiceProvider(); + serviceProvider.AddService((x, y) => listener); + serviceProvider.AddService((x, y) => new WixCopCommandLineParser(x)); + + var result = Execute(serviceProvider, args); + + var messaging = serviceProvider.GetService(); + messages = listener.Messages.Select(x => messaging.FormatMessage(x)).ToList(); + return result; + } + + public static int Execute(IServiceProvider serviceProvider, string[] args) + { + var wixcop = new WixCop.Program(); + return wixcop.Run(serviceProvider, args); + } + } + } +} diff --git a/src/test/wixcop/WixCopTests.csproj b/src/test/wixcop/WixCopTests.csproj new file mode 100644 index 00000000..0ae50dc8 --- /dev/null +++ b/src/test/wixcop/WixCopTests.csproj @@ -0,0 +1,41 @@ + + + + + + net461 + false + embedded + + + + + + + + PreserveNewest + + + PreserveNewest + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/wix/Program.cs b/src/wix/Program.cs index a95851ee..b0e3bb73 100644 --- a/src/wix/Program.cs +++ b/src/wix/Program.cs @@ -13,6 +13,7 @@ namespace WixToolset.Tools using WixToolset.Extensibility; using WixToolset.Extensibility.Data; using WixToolset.Extensibility.Services; + using WixToolset.Tools.Core; /// /// Wix Toolset Command-Line Interface. @@ -79,52 +80,5 @@ namespace WixToolset.Tools return extensionManager; } - - private class ConsoleMessageListener : IMessageListener - { - public ConsoleMessageListener(string shortName, string longName) - { - this.ShortAppName = shortName; - this.LongAppName = longName; - - PrepareConsoleForLocalization(); - } - - public string LongAppName { get; } - - public string ShortAppName { get; } - - public void Write(Message message) - { - var filename = message.SourceLineNumbers?.FileName ?? this.LongAppName; - var line = message.SourceLineNumbers?.LineNumber ?? -1; - var type = message.Level.ToString().ToLowerInvariant(); - var output = message.Level >= MessageLevel.Warning ? Console.Out : Console.Error; - - if (line > 0) - { - filename = String.Concat(filename, "(", line, ")"); - } - - output.WriteLine("{0} : {1} {2}{3:0000}: {4}", filename, type, this.ShortAppName, message.Id, message.ToString()); - } - - public void Write(string message) - { - Console.Out.WriteLine(message); - } - - private static void PrepareConsoleForLocalization() - { - Thread.CurrentThread.CurrentUICulture = CultureInfo.CurrentUICulture.GetConsoleFallbackUICulture(); - - if (Console.OutputEncoding.CodePage != Encoding.UTF8.CodePage && - Console.OutputEncoding.CodePage != Thread.CurrentThread.CurrentUICulture.TextInfo.OEMCodePage && - Console.OutputEncoding.CodePage != Thread.CurrentThread.CurrentUICulture.TextInfo.ANSICodePage) - { - Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); - } - } - } } } diff --git a/src/wix/wix.csproj b/src/wix/wix.csproj index 6ec22ec0..2cbcdf3a 100644 --- a/src/wix/wix.csproj +++ b/src/wix/wix.csproj @@ -16,6 +16,10 @@ NU1701 + + + + diff --git a/src/wixcop/CommandLine/ConvertCommand.cs b/src/wixcop/CommandLine/ConvertCommand.cs new file mode 100644 index 00000000..6af7d4ca --- /dev/null +++ b/src/wixcop/CommandLine/ConvertCommand.cs @@ -0,0 +1,212 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Xml; +using WixToolset.Extensibility.Data; +using WixToolset.Extensibility.Services; + +namespace WixCop.CommandLine +{ + internal class ConvertCommand : ICommandLineCommand + { + private const string SettingsFileDefault = "wixcop.settings.xml"; + + public ConvertCommand(IServiceProvider serviceProvider, bool fixErrors, int indentationAmount, List searchPatterns, bool subDirectories, string settingsFile1, string settingsFile2) + { + this.ErrorsAsWarnings = new HashSet(); + this.ExemptFiles = new HashSet(); + this.FixErrors = fixErrors; + this.IndentationAmount = indentationAmount; + this.IgnoreErrors = new HashSet(); + this.SearchPatternResults = new HashSet(); + this.SearchPatterns = searchPatterns; + this.ServiceProvider = serviceProvider; + this.SettingsFile1 = settingsFile1; + this.SettingsFile2 = settingsFile2; + this.SubDirectories = subDirectories; + } + + private HashSet ErrorsAsWarnings { get; } + + private HashSet ExemptFiles { get; } + + private bool FixErrors { get; } + + private int IndentationAmount { get; } + + private HashSet IgnoreErrors { get; } + + private HashSet SearchPatternResults { get; } + + private List SearchPatterns { get; } + + private IServiceProvider ServiceProvider { get; } + + private string SettingsFile1 { get; } + + private string SettingsFile2 { get; } + + private bool SubDirectories { get; } + + public int Execute() + { + // parse the settings if any were specified + if (null != this.SettingsFile1 || null != this.SettingsFile2) + { + this.ParseSettingsFiles(this.SettingsFile1, this.SettingsFile2); + } + else + { + if (File.Exists(ConvertCommand.SettingsFileDefault)) + { + this.ParseSettingsFiles(ConvertCommand.SettingsFileDefault, null); + } + } + + var messaging = this.ServiceProvider.GetService(); + var converter = new Converter(messaging, this.IndentationAmount, this.ErrorsAsWarnings, this.IgnoreErrors); + + var errors = this.InspectSubDirectories(converter, Path.GetFullPath(".")); + + foreach (string searchPattern in this.SearchPatterns) + { + if (!this.SearchPatternResults.Contains(searchPattern)) + { + Console.Error.WriteLine("Could not find file \"{0}\"", searchPattern); + errors++; + } + } + + return errors != 0 ? 2 : 0; + } + + /// + /// Get the files that match a search path pattern. + /// + /// The base directory at which to begin the search. + /// The search path pattern. + /// The files matching the pattern. + private static string[] GetFiles(string baseDir, string searchPath) + { + // convert alternate directory separators to the standard one + var filePath = searchPath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar); + var lastSeparator = filePath.LastIndexOf(Path.DirectorySeparatorChar); + string[] files = null; + + try + { + if (0 > lastSeparator) + { + files = Directory.GetFiles(baseDir, filePath); + } + else // found directory separator + { + var searchPattern = filePath.Substring(lastSeparator + 1); + + files = Directory.GetFiles(filePath.Substring(0, lastSeparator + 1), searchPattern); + } + } + catch (DirectoryNotFoundException) + { + // don't let this function throw the DirectoryNotFoundException. (this exception + // occurs for non-existant directories and invalid characters in the searchPattern) + } + + return files; + } + + /// + /// Inspect sub-directories. + /// + /// The directory whose sub-directories will be inspected. + /// The number of errors that were found. + private int InspectSubDirectories(Converter converter, string directory) + { + var errors = 0; + + foreach (var searchPattern in this.SearchPatterns) + { + foreach (var sourceFilePath in GetFiles(directory, searchPattern)) + { + var file = new FileInfo(sourceFilePath); + + if (!this.ExemptFiles.Contains(file.Name.ToUpperInvariant())) + { + this.SearchPatternResults.Add(searchPattern); + errors += converter.ConvertFile(file.FullName, this.FixErrors); + } + } + } + + if (this.SubDirectories) + { + foreach (var childDirectoryPath in Directory.GetDirectories(directory)) + { + errors += this.InspectSubDirectories(converter, childDirectoryPath); + } + } + + return errors; + } + + /// + /// Parse the primary and secondary settings files. + /// + /// The primary settings file. + /// The secondary settings file. + private void ParseSettingsFiles(string localSettingsFile1, string localSettingsFile2) + { + if (null == localSettingsFile1 && null != localSettingsFile2) + { + throw new ArgumentException("Cannot specify a secondary settings file (set2) without a primary settings file (set1).", "localSettingsFile2"); + } + + var settingsFile = localSettingsFile1; + while (null != settingsFile) + { + XmlTextReader reader = null; + try + { + reader = new XmlTextReader(settingsFile); + var doc = new XmlDocument(); + doc.Load(reader); + + // get the types of tests that will have their errors displayed as warnings + var testsIgnoredElements = doc.SelectNodes("/Settings/IgnoreErrors/Test"); + foreach (XmlElement test in testsIgnoredElements) + { + var key = test.GetAttribute("Id"); + this.IgnoreErrors.Add(key); + } + + // get the types of tests that will have their errors displayed as warnings + var testsAsWarningsElements = doc.SelectNodes("/Settings/ErrorsAsWarnings/Test"); + foreach (XmlElement test in testsAsWarningsElements) + { + var key = test.GetAttribute("Id"); + this.ErrorsAsWarnings.Add(key); + } + + // get the exempt files + var localExemptFiles = doc.SelectNodes("/Settings/ExemptFiles/File"); + foreach (XmlElement file in localExemptFiles) + { + var key = file.GetAttribute("Name").ToUpperInvariant(); + this.ExemptFiles.Add(key); + } + } + finally + { + if (null != reader) + { + reader.Close(); + } + } + + settingsFile = localSettingsFile2; + localSettingsFile2 = null; + } + } + } +} diff --git a/src/wixcop/CommandLine/HelpCommand.cs b/src/wixcop/CommandLine/HelpCommand.cs new file mode 100644 index 00000000..a75dac5c --- /dev/null +++ b/src/wixcop/CommandLine/HelpCommand.cs @@ -0,0 +1,25 @@ +using System; +using WixToolset.Extensibility.Data; + +namespace WixCop.CommandLine +{ + internal class HelpCommand : ICommandLineCommand + { + public int Execute() + { + Console.WriteLine(" usage: wixcop.exe sourceFile [sourceFile ...]"); + Console.WriteLine(); + Console.WriteLine(" -f fix errors automatically for writable files"); + Console.WriteLine(" -nologo suppress displaying the logo information"); + Console.WriteLine(" -s search for matching files in current dir and subdirs"); + Console.WriteLine(" -set1 primary settings file"); + Console.WriteLine(" -set2 secondary settings file (overrides primary)"); + Console.WriteLine(" -indent: indentation multiple (overrides default of 4)"); + Console.WriteLine(" -? this help information"); + Console.WriteLine(); + Console.WriteLine(" sourceFile may use wildcards like *.wxs"); + + return 0; + } + } +} diff --git a/src/wixcop/CommandLine/WixCopCommandLineParser.cs b/src/wixcop/CommandLine/WixCopCommandLineParser.cs new file mode 100644 index 00000000..53012cfd --- /dev/null +++ b/src/wixcop/CommandLine/WixCopCommandLineParser.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections.Generic; +using WixCop.Interfaces; +using WixToolset.Core; +using WixToolset.Extensibility.Data; +using WixToolset.Extensibility.Services; + +namespace WixCop.CommandLine +{ + public sealed class WixCopCommandLineParser : IWixCopCommandLineParser + { + private bool fixErrors; + private int indentationAmount; + private readonly List searchPatterns; + private readonly IServiceProvider serviceProvider; + private string settingsFile1; + private string settingsFile2; + private bool showHelp; + private bool showLogo; + private bool subDirectories; + + public WixCopCommandLineParser(IServiceProvider serviceProvider) + { + this.serviceProvider = serviceProvider; + + this.indentationAmount = 4; + this.searchPatterns = new List(); + this.showLogo = true; + } + + public ICommandLineArguments Arguments { get; set; } + + public ICommandLineCommand ParseWixCopCommandLine() + { + this.Parse(); + + if (this.showLogo) + { + AppCommon.DisplayToolHeader(); + Console.WriteLine(); + } + + if (this.showHelp) + { + return new HelpCommand(); + } + + return new ConvertCommand( + this.serviceProvider, + this.fixErrors, + this.indentationAmount, + this.searchPatterns, + this.subDirectories, + this.settingsFile1, + this.settingsFile2); + } + + private void Parse() + { + this.showHelp = 0 == this.Arguments.Arguments.Length; + var parser = this.Arguments.Parse(); + + while (!this.showHelp && + String.IsNullOrEmpty(parser.ErrorArgument) && + parser.TryGetNextSwitchOrArgument(out var arg)) + { + if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments. + { + continue; + } + + if (parser.IsSwitch(arg)) + { + if (!this.ParseArgument(parser, arg)) + { + parser.ErrorArgument = arg; + } + } + else + { + this.searchPatterns.Add(arg); + } + } + } + + private bool ParseArgument(IParseCommandLine parser, string arg) + { + var parameter = arg.Substring(1); + + switch (parameter.ToLowerInvariant()) + { + case "?": + this.showHelp = true; + return true; + case "f": + this.fixErrors = true; + return true; + case "nologo": + this.showLogo = false; + return true; + case "s": + this.subDirectories = true; + return true; + default: // other parameters + if (parameter.StartsWith("set1", StringComparison.Ordinal)) + { + this.settingsFile1 = parameter.Substring(4); + } + else if (parameter.StartsWith("set2", StringComparison.Ordinal)) + { + this.settingsFile2 = parameter.Substring(4); + } + else if (parameter.StartsWith("indent:", StringComparison.Ordinal)) + { + try + { + this.indentationAmount = Convert.ToInt32(parameter.Substring(7)); + } + catch + { + throw new ArgumentException("Invalid numeric argument.", parameter); + } + } + else + { + throw new ArgumentException("Invalid argument.", parameter); + } + return true; + } + } + } +} diff --git a/src/wixcop/Converter.cs b/src/wixcop/Converter.cs new file mode 100644 index 00000000..a204ebe0 --- /dev/null +++ b/src/wixcop/Converter.cs @@ -0,0 +1,633 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixCop +{ + using System; + using System.Collections.Generic; + using System.Globalization; + using System.IO; + using System.Linq; + using System.Xml; + using System.Xml.Linq; + using WixToolset.Data; + using WixToolset.Extensibility.Services; + using WixToolset.Tools.Core; + + /// + /// WiX source code converter. + /// + public class Converter + { + private const string XDocumentNewLine = "\n"; // XDocument normlizes "\r\n" to just "\n". + private static readonly XNamespace WixNamespace = "http://wixtoolset.org/schemas/v4/wxs"; + + private static readonly XName FileElementName = WixNamespace + "File"; + private static readonly XName ExePackageElementName = WixNamespace + "ExePackage"; + private static readonly XName MsiPackageElementName = WixNamespace + "MsiPackage"; + private static readonly XName MspPackageElementName = WixNamespace + "MspPackage"; + private static readonly XName MsuPackageElementName = WixNamespace + "MsuPackage"; + private static readonly XName PayloadElementName = WixNamespace + "Payload"; + private static readonly XName WixElementWithoutNamespaceName = XNamespace.None + "Wix"; + + private static readonly Dictionary OldToNewNamespaceMapping = new Dictionary() + { + { "http://schemas.microsoft.com/wix/BalExtension", "http://wixtoolset.org/schemas/v4/wxs/bal" }, + { "http://schemas.microsoft.com/wix/ComPlusExtension", "http://wixtoolset.org/schemas/v4/wxs/complus" }, + { "http://schemas.microsoft.com/wix/DependencyExtension", "http://wixtoolset.org/schemas/v4/wxs/dependency" }, + { "http://schemas.microsoft.com/wix/DifxAppExtension", "http://wixtoolset.org/schemas/v4/wxs/difxapp" }, + { "http://schemas.microsoft.com/wix/FirewallExtension", "http://wixtoolset.org/schemas/v4/wxs/firewall" }, + { "http://schemas.microsoft.com/wix/GamingExtension", "http://wixtoolset.org/schemas/v4/wxs/gaming" }, + { "http://schemas.microsoft.com/wix/IIsExtension", "http://wixtoolset.org/schemas/v4/wxs/iis" }, + { "http://schemas.microsoft.com/wix/MsmqExtension", "http://wixtoolset.org/schemas/v4/wxs/msmq" }, + { "http://schemas.microsoft.com/wix/NetFxExtension", "http://wixtoolset.org/schemas/v4/wxs/netfx" }, + { "http://schemas.microsoft.com/wix/PSExtension", "http://wixtoolset.org/schemas/v4/wxs/powershell" }, + { "http://schemas.microsoft.com/wix/SqlExtension", "http://wixtoolset.org/schemas/v4/wxs/sql" }, + { "http://schemas.microsoft.com/wix/TagExtension", "http://wixtoolset.org/schemas/v4/wxs/tag" }, + { "http://schemas.microsoft.com/wix/UtilExtension", "http://wixtoolset.org/schemas/v4/wxs/util" }, + { "http://schemas.microsoft.com/wix/VSExtension", "http://wixtoolset.org/schemas/v4/wxs/vs" }, + { "http://wixtoolset.org/schemas/thmutil/2010", "http://wixtoolset.org/schemas/v4/thmutil" }, + { "http://schemas.microsoft.com/wix/2009/Lux", "http://wixtoolset.org/schemas/v4/lux" }, + { "http://schemas.microsoft.com/wix/2006/wi", "http://wixtoolset.org/schemas/v4/wxs" }, + { "http://schemas.microsoft.com/wix/2006/localization", "http://wixtoolset.org/schemas/v4/wxl" }, + { "http://schemas.microsoft.com/wix/2006/libraries", "http://wixtoolset.org/schemas/v4/wixlib" }, + { "http://schemas.microsoft.com/wix/2006/objects", "http://wixtoolset.org/schemas/v4/wixobj" }, + { "http://schemas.microsoft.com/wix/2006/outputs", "http://wixtoolset.org/schemas/v4/wixout" }, + { "http://schemas.microsoft.com/wix/2007/pdbs", "http://wixtoolset.org/schemas/v4/wixpdb" }, + { "http://schemas.microsoft.com/wix/2003/04/actions", "http://wixtoolset.org/schemas/v4/wi/actions" }, + { "http://schemas.microsoft.com/wix/2006/tables", "http://wixtoolset.org/schemas/v4/wi/tables" }, + { "http://schemas.microsoft.com/wix/2006/WixUnit", "http://wixtoolset.org/schemas/v4/wixunit" }, + }; + + private Dictionary> ConvertElementMapping; + + /// + /// Instantiate a new Converter class. + /// + /// Indentation value to use when validating leading whitespace. + /// Test errors to display as warnings. + /// Test errors to ignore. + public Converter(IMessaging messaging, int indentationAmount, IEnumerable errorsAsWarnings = null, IEnumerable ignoreErrors = null) + { + // workaround IDE0009 bug + /*this.ConvertElementMapping = new Dictionary>() + { + { Converter.FileElementName, this.ConvertFileElement }, + { Converter.ExePackageElementName, this.ConvertSuppressSignatureValidation }, + { Converter.MsiPackageElementName, this.ConvertSuppressSignatureValidation }, + { Converter.MspPackageElementName, this.ConvertSuppressSignatureValidation }, + { Converter.MsuPackageElementName, this.ConvertSuppressSignatureValidation }, + { Converter.PayloadElementName, this.ConvertSuppressSignatureValidation }, + { Converter.WixElementWithoutNamespaceName, this.ConvertWixElementWithoutNamespace }, + };*/ + this.ConvertElementMapping = new Dictionary>(); + this.ConvertElementMapping.Add(Converter.FileElementName, this.ConvertFileElement); + this.ConvertElementMapping.Add(Converter.ExePackageElementName, this.ConvertSuppressSignatureValidation); + this.ConvertElementMapping.Add(Converter.MsiPackageElementName, this.ConvertSuppressSignatureValidation); + this.ConvertElementMapping.Add(Converter.MspPackageElementName, this.ConvertSuppressSignatureValidation); + this.ConvertElementMapping.Add(Converter.MsuPackageElementName, this.ConvertSuppressSignatureValidation); + this.ConvertElementMapping.Add(Converter.PayloadElementName, this.ConvertSuppressSignatureValidation); + this.ConvertElementMapping.Add(Converter.WixElementWithoutNamespaceName, this.ConvertWixElementWithoutNamespace); + + this.Messaging = messaging; + + this.IndentationAmount = indentationAmount; + + this.ErrorsAsWarnings = new HashSet(this.YieldConverterTypes(errorsAsWarnings)); + + this.IgnoreErrors = new HashSet(this.YieldConverterTypes(ignoreErrors)); + } + + private int Errors { get; set; } + + private HashSet ErrorsAsWarnings { get; set; } + + private HashSet IgnoreErrors { get; set; } + + private IMessaging Messaging { get; } + + private int IndentationAmount { get; set; } + + private string SourceFile { get; set; } + + /// + /// Convert a file. + /// + /// The file to convert. + /// Option to save the converted errors that are found. + /// The number of errors found. + public int ConvertFile(string sourceFile, bool saveConvertedFile) + { + XDocument document; + + // Set the instance info. + this.Errors = 0; + this.SourceFile = sourceFile; + + try + { + document = XDocument.Load(this.SourceFile, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); + } + catch (XmlException e) + { + this.OnError(ConverterTestType.XmlException, (XObject)null, "The xml is invalid. Detail: '{0}'", e.Message); + + return this.Errors; + } + + this.ConvertDocument(document); + + // Fix errors if requested and necessary. + if (saveConvertedFile && 0 < this.Errors) + { + try + { + using (StreamWriter writer = File.CreateText(this.SourceFile)) + { + document.Save(writer, SaveOptions.DisableFormatting | SaveOptions.OmitDuplicateNamespaces); + } + } + catch (UnauthorizedAccessException) + { + this.OnError(ConverterTestType.UnauthorizedAccessException, (XObject)null, "Could not write to file."); + } + } + + return this.Errors; + } + + /// + /// Convert a document. + /// + /// The document to convert. + /// The number of errors found. + public int ConvertDocument(XDocument document) + { + XDeclaration declaration = document.Declaration; + + // Convert the declaration. + if (null != declaration) + { + if (!String.Equals("utf-8", declaration.Encoding, StringComparison.OrdinalIgnoreCase)) + { + if (this.OnError(ConverterTestType.DeclarationEncodingWrong, document.Root, "The XML declaration encoding is not properly set to 'utf-8'.")) + { + declaration.Encoding = "utf-8"; + } + } + } + else // missing declaration + { + if (this.OnError(ConverterTestType.DeclarationMissing, (XNode)null, "This file is missing an XML declaration on the first line.")) + { + document.Declaration = new XDeclaration("1.0", "utf-8", null); + document.Root.AddBeforeSelf(new XText(XDocumentNewLine)); + } + } + + // Start converting the nodes at the top. + this.ConvertNode(document.Root, 0); + + return this.Errors; + } + + /// + /// Convert a single xml node. + /// + /// The node to convert. + /// The depth level of the node. + /// The converted node. + private void ConvertNode(XNode node, int level) + { + // Convert this node's whitespace. + if ((XmlNodeType.Comment == node.NodeType && 0 > ((XComment)node).Value.IndexOf(XDocumentNewLine, StringComparison.Ordinal)) || + XmlNodeType.CDATA == node.NodeType || XmlNodeType.Element == node.NodeType || XmlNodeType.ProcessingInstruction == node.NodeType) + { + this.ConvertWhitespace(node, level); + } + + // Convert this node if it is an element. + XElement element = node as XElement; + + if (null != element) + { + this.ConvertElement(element); + + // Convert all children of this element. + IEnumerable children = element.Nodes().ToList(); + + foreach (XNode child in children) + { + this.ConvertNode(child, level + 1); + } + } + } + + private void ConvertElement(XElement element) + { + // Gather any deprecated namespaces, then update this element tree based on those deprecations. + Dictionary deprecatedToUpdatedNamespaces = new Dictionary(); + + foreach (XAttribute declaration in element.Attributes().Where(a => a.IsNamespaceDeclaration)) + { + XNamespace ns; + + if (Converter.OldToNewNamespaceMapping.TryGetValue(declaration.Value, out ns)) + { + if (this.OnError(ConverterTestType.XmlnsValueWrong, declaration, "The namespace '{0}' is out of date. It must be '{1}'.", declaration.Value, ns.NamespaceName)) + { + deprecatedToUpdatedNamespaces.Add(declaration.Value, ns); + } + } + } + + if (deprecatedToUpdatedNamespaces.Any()) + { + Converter.UpdateElementsWithDeprecatedNamespaces(element.DescendantsAndSelf(), deprecatedToUpdatedNamespaces); + } + + // Convert the node in much greater detail. + Action convert; + + if (this.ConvertElementMapping.TryGetValue(element.Name, out convert)) + { + convert(element); + } + } + + private void ConvertFileElement(XElement element) + { + if (null == element.Attribute("Id")) + { + XAttribute attribute = element.Attribute("Name"); + + if (null == attribute) + { + attribute = element.Attribute("Source"); + } + + if (null != attribute) + { + string name = Path.GetFileName(attribute.Value); + + if (this.OnError(ConverterTestType.AssignAnonymousFileId, element, "The file id is being updated to '{0}' to ensure it remains the same as the default", name)) + { + IEnumerable attributes = element.Attributes().ToList(); + element.RemoveAttributes(); + element.Add(new XAttribute("Id", ToolsCommon.GetIdentifierFromName(name))); + element.Add(attributes); + } + } + } + } + + private void ConvertSuppressSignatureValidation(XElement element) + { + XAttribute suppressSignatureValidation = element.Attribute("SuppressSignatureValidation"); + + if (null != suppressSignatureValidation) + { + if (this.OnError(ConverterTestType.SuppressSignatureValidationDeprecated, element, "The chain package element contains deprecated '{0}' attribute. Use the 'EnableSignatureValidation' instead.", suppressSignatureValidation)) + { + if ("no" == suppressSignatureValidation.Value) + { + element.Add(new XAttribute("EnableSignatureValidation", "yes")); + } + } + + suppressSignatureValidation.Remove(); + } + } + + /// + /// Converts a Wix element. + /// + /// The Wix element to convert. + /// The converted element. + private void ConvertWixElementWithoutNamespace(XElement element) + { + if (this.OnError(ConverterTestType.XmlnsMissing, element, "The xmlns attribute is missing. It must be present with a value of '{0}'.", WixNamespace.NamespaceName)) + { + element.Name = WixNamespace.GetName(element.Name.LocalName); + + element.Add(new XAttribute("xmlns", WixNamespace.NamespaceName)); // set the default namespace. + + foreach (XElement elementWithoutNamespace in element.Elements().Where(e => XNamespace.None == e.Name.Namespace)) + { + elementWithoutNamespace.Name = WixNamespace.GetName(elementWithoutNamespace.Name.LocalName); + } + } + } + + /// + /// Convert the whitespace adjacent to a node. + /// + /// The node to convert. + /// The depth level of the node. + private void ConvertWhitespace(XNode node, int level) + { + // Fix the whitespace before this node. + XText whitespace = node.PreviousNode as XText; + + if (null != whitespace) + { + if (XmlNodeType.CDATA == node.NodeType) + { + if (this.OnError(ConverterTestType.WhitespacePrecedingCDATAWrong, node, "There should be no whitespace preceding a CDATA node.")) + { + whitespace.Remove(); + } + } + else + { + // TODO: this code complains about whitespace even after the file has been fixed. + if (!Converter.IsLegalWhitespace(this.IndentationAmount, level, whitespace.Value)) + { + if (this.OnError(ConverterTestType.WhitespacePrecedingNodeWrong, node, "The whitespace preceding this node is incorrect.")) + { + Converter.FixWhitespace(this.IndentationAmount, level, whitespace); + } + } + } + } + + // Fix the whitespace after CDATA nodes. + XCData cdata = node as XCData; + + if (null != cdata) + { + whitespace = cdata.NextNode as XText; + + if (null != whitespace) + { + if (this.OnError(ConverterTestType.WhitespaceFollowingCDATAWrong, node, "There should be no whitespace following a CDATA node.")) + { + whitespace.Remove(); + } + } + } + else + { + // Fix the whitespace inside and after this node (except for Error which may contain just whitespace). + XElement element = node as XElement; + + if (null != element && "Error" != element.Name.LocalName) + { + if (!element.HasElements && !element.IsEmpty && String.IsNullOrEmpty(element.Value.Trim())) + { + if (this.OnError(ConverterTestType.NotEmptyElement, element, "This should be an empty element since it contains nothing but whitespace.")) + { + element.RemoveNodes(); + } + } + + whitespace = node.NextNode as XText; + + if (null != whitespace) + { + // TODO: this code crashes when level is 0, + // complains about whitespace even after the file has been fixed, + // and the error text doesn't match the error. + if (!Converter.IsLegalWhitespace(this.IndentationAmount, level - 1, whitespace.Value)) + { + if (this.OnError(ConverterTestType.WhitespacePrecedingEndElementWrong, whitespace, "The whitespace preceding this end element is incorrect.")) + { + Converter.FixWhitespace(this.IndentationAmount, level - 1, whitespace); + } + } + } + } + } + } + + private IEnumerable YieldConverterTypes(IEnumerable types) + { + if (null != types) + { + foreach (string type in types) + { + ConverterTestType itt; + + if (Enum.TryParse(type, true, out itt)) + { + yield return itt; + } + else // not a known ConverterTestType + { + this.OnError(ConverterTestType.ConverterTestTypeUnknown, (XObject)null, "Unknown error type: '{0}'.", type); + } + } + } + } + + private static void UpdateElementsWithDeprecatedNamespaces(IEnumerable elements, Dictionary deprecatedToUpdatedNamespaces) + { + foreach (XElement element in elements) + { + XNamespace ns; + + if (deprecatedToUpdatedNamespaces.TryGetValue(element.Name.Namespace, out ns)) + { + element.Name = ns.GetName(element.Name.LocalName); + } + + // Remove all the attributes and add them back to with their namespace updated (as necessary). + IEnumerable attributes = element.Attributes().ToList(); + element.RemoveAttributes(); + + foreach (XAttribute attribute in attributes) + { + XAttribute convertedAttribute = attribute; + + if (attribute.IsNamespaceDeclaration) + { + if (deprecatedToUpdatedNamespaces.TryGetValue(attribute.Value, out ns)) + { + convertedAttribute = ("xmlns" == attribute.Name.LocalName) ? new XAttribute(attribute.Name.LocalName, ns.NamespaceName) : new XAttribute(XNamespace.Xmlns + attribute.Name.LocalName, ns.NamespaceName); + } + } + else if (deprecatedToUpdatedNamespaces.TryGetValue(attribute.Name.Namespace, out ns)) + { + convertedAttribute = new XAttribute(ns.GetName(attribute.Name.LocalName), attribute.Value); + } + + element.Add(convertedAttribute); + } + } + } + + /// + /// Determine if the whitespace preceding a node is appropriate for its depth level. + /// + /// Indentation value to use when validating leading whitespace. + /// The depth level that should match this whitespace. + /// The whitespace to validate. + /// true if the whitespace is legal; false otherwise. + private static bool IsLegalWhitespace(int indentationAmount, int level, string whitespace) + { + // strip off leading newlines; there can be an arbitrary number of these + while (whitespace.StartsWith(XDocumentNewLine, StringComparison.Ordinal)) + { + whitespace = whitespace.Substring(XDocumentNewLine.Length); + } + + // check the length + if (whitespace.Length != level * indentationAmount) + { + return false; + } + + // check the spaces + foreach (char character in whitespace) + { + if (' ' != character) + { + return false; + } + } + + return true; + } + + /// + /// Fix the whitespace in a Whitespace node. + /// + /// Indentation value to use when validating leading whitespace. + /// The depth level of the desired whitespace. + /// The whitespace node to fix. + private static void FixWhitespace(int indentationAmount, int level, XText whitespace) + { + int newLineCount = 0; + + for (int i = 0; i + 1 < whitespace.Value.Length; ++i) + { + if (XDocumentNewLine == whitespace.Value.Substring(i, 2)) + { + ++i; // skip an extra character + ++newLineCount; + } + } + + if (0 == newLineCount) + { + newLineCount = 1; + } + + // reset the whitespace value + whitespace.Value = String.Empty; + + // add the correct number of newlines + for (int i = 0; i < newLineCount; ++i) + { + whitespace.Value = String.Concat(whitespace.Value, XDocumentNewLine); + } + + // add the correct number of spaces based on configured indentation amount + whitespace.Value = String.Concat(whitespace.Value, new string(' ', level * indentationAmount)); + } + + /// + /// Output an error message to the console. + /// + /// The type of converter test. + /// The node that caused the error. + /// Detailed error message. + /// Additional formatted string arguments. + /// Returns true indicating that action should be taken on this error, and false if it should be ignored. + private bool OnError(ConverterTestType converterTestType, XObject node, string message, params object[] args) + { + if (this.IgnoreErrors.Contains(converterTestType)) // ignore the error + { + return false; + } + + // Increase the error count. + this.Errors++; + + SourceLineNumber sourceLine = (null == node) ? new SourceLineNumber(this.SourceFile ?? "wixcop.exe") : new SourceLineNumber(this.SourceFile, ((IXmlLineInfo)node).LineNumber); + bool warning = this.ErrorsAsWarnings.Contains(converterTestType); + string display = String.Format(CultureInfo.CurrentCulture, message, args); + + var msg = new Message(sourceLine, warning ? MessageLevel.Warning : MessageLevel.Error, (int)converterTestType, "{0} ({1})", display, converterTestType.ToString()); + + this.Messaging.Write(msg); + + return true; + } + + /// + /// Converter test types. These are used to condition error messages down to warnings. + /// + private enum ConverterTestType + { + /// + /// Internal-only: displayed when a string cannot be converted to an ConverterTestType. + /// + ConverterTestTypeUnknown, + + /// + /// Displayed when an XML loading exception has occurred. + /// + XmlException, + + /// + /// Displayed when a file cannot be accessed; typically when trying to save back a fixed file. + /// + UnauthorizedAccessException, + + /// + /// Displayed when the encoding attribute in the XML declaration is not 'UTF-8'. + /// + DeclarationEncodingWrong, + + /// + /// Displayed when the XML declaration is missing from the source file. + /// + DeclarationMissing, + + /// + /// Displayed when the whitespace preceding a CDATA node is wrong. + /// + WhitespacePrecedingCDATAWrong, + + /// + /// Displayed when the whitespace preceding a node is wrong. + /// + WhitespacePrecedingNodeWrong, + + /// + /// Displayed when an element is not empty as it should be. + /// + NotEmptyElement, + + /// + /// Displayed when the whitespace following a CDATA node is wrong. + /// + WhitespaceFollowingCDATAWrong, + + /// + /// Displayed when the whitespace preceding an end element is wrong. + /// + WhitespacePrecedingEndElementWrong, + + /// + /// Displayed when the xmlns attribute is missing from the document element. + /// + XmlnsMissing, + + /// + /// Displayed when the xmlns attribute on the document element is wrong. + /// + XmlnsValueWrong, + + /// + /// Assign an identifier to a File element when on Id attribute is specified. + /// + AssignAnonymousFileId, + + /// + /// SuppressSignatureValidation attribute is deprecated and replaced with EnableSignatureValidation. + /// + SuppressSignatureValidationDeprecated, + } + } +} diff --git a/src/wixcop/Interfaces/IWixCopCommandLineParser.cs b/src/wixcop/Interfaces/IWixCopCommandLineParser.cs new file mode 100644 index 00000000..2093f5d8 --- /dev/null +++ b/src/wixcop/Interfaces/IWixCopCommandLineParser.cs @@ -0,0 +1,11 @@ +using WixToolset.Extensibility.Data; + +namespace WixCop.Interfaces +{ + public interface IWixCopCommandLineParser + { + ICommandLineArguments Arguments { get; set; } + + ICommandLineCommand ParseWixCopCommandLine(); + } +} diff --git a/src/wixcop/Program.cs b/src/wixcop/Program.cs new file mode 100644 index 00000000..b26bd6c9 --- /dev/null +++ b/src/wixcop/Program.cs @@ -0,0 +1,67 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixCop +{ + using System; + using WixCop.CommandLine; + using WixCop.Interfaces; + using WixToolset.Core; + using WixToolset.Extensibility; + using WixToolset.Extensibility.Data; + using WixToolset.Extensibility.Services; + using WixToolset.Tools.Core; + + /// + /// Wix source code style inspector and converter. + /// + public sealed class Program + { + /// + /// The main entry point for the application. + /// + /// The commandline arguments. + /// The number of errors that were found. + [STAThread] + public static int Main(string[] args) + { + var serviceProvider = new WixToolsetServiceProvider(); + var listener = new ConsoleMessageListener("WXCP", "wixcop.exe"); + + serviceProvider.AddService((x, y) => listener); + serviceProvider.AddService((x, y) => new WixCopCommandLineParser(x)); + + var program = new Program(); + return program.Run(serviceProvider, args); + } + + /// + /// Run the application with the given arguments. + /// + /// Service provider to use throughout this execution. + /// The commandline arguments. + /// The number of errors that were found. + public int Run(IServiceProvider serviceProvider, string[] args) + { + try + { + var listener = serviceProvider.GetService(); + var messaging = serviceProvider.GetService(); + messaging.SetListener(listener); + + var arguments = serviceProvider.GetService(); + arguments.Populate(args); + + var commandLine = serviceProvider.GetService(); + commandLine.Arguments = arguments; + var command = commandLine.ParseWixCopCommandLine(); + return command?.Execute() ?? 1; + } + catch (Exception e) + { + Console.Error.WriteLine("wixcop.exe : fatal error WXCP0001 : {0}\r\n\n\nStack Trace:\r\n{1}", e.Message, e.StackTrace); + + return 1; + } + } + } +} diff --git a/src/wixcop/WixCop.csproj b/src/wixcop/WixCop.csproj new file mode 100644 index 00000000..9bcae177 --- /dev/null +++ b/src/wixcop/WixCop.csproj @@ -0,0 +1,32 @@ + + + + + + net461;netcoreapp2.1 + Exe + Converter + WiX Error Correction Tool + embedded + true + + + + + NU1701 + + + + + + + + + + + + + + + + -- cgit v1.2.3-55-g6feb