Integrate simplified message handling

1 files changed, 194 insertions, 0 deletions

diff --git a/src/WixToolset.Core/ExtensibilityServices/Messaging.cs b/src/WixToolset.Core/ExtensibilityServices/Messaging.cs
new file mode 100644
index 00000000..4510f264
--- /dev/null
+++ b/src/WixToolset.Core/ExtensibilityServices/Messaging.cs
@@ -0,0 +1,194 @@
+// 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.Core.ExtensibilityServices
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Text;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Extensibility.Services;
+
+    internal class Messaging : IMessaging
+    {
+        private IMessageListener listener;
+        private HashSet<int> suppressedWarnings = new HashSet<int>();
+        private HashSet<int> warningsAsErrors = new HashSet<int>();
+
+        public bool EncounteredError { get; private set; }
+
+        public int LastErrorNumber { get; private set; }
+
+        public bool ShowVerboseMessages { get; set; }
+
+        public bool SuppressAllWarnings { get; set; }
+
+        public bool WarningsAsError { get; set; }
+
+        public void ElevateWarningMessage(int warningNumber)
+        {
+            this.warningsAsErrors.Add(warningNumber);
+        }
+
+        public void SetListener(IMessageListener listener)
+        {
+            this.listener = listener;
+        }
+
+        public void SuppressWarningMessage(int warningNumber)
+        {
+            this.suppressedWarnings.Add(warningNumber);
+        }
+
+        public string FormatMessage(Message message)
+        {
+            var level = CalculateMessageLevel(message);
+
+            if (level == MessageLevel.Nothing)
+            {
+                return String.Empty;
+            }
+
+            var shortAppName = String.IsNullOrEmpty(this.listener?.ShortAppName) ? "WIX" : this.listener.ShortAppName;
+            var longAppName = String.IsNullOrEmpty(this.listener?.LongAppName) ? "WIX" : this.listener.LongAppName;
+
+            var fileNames = new List<string>();
+            var errorFileName = longAppName;
+            for (var sln = message.SourceLineNumbers; null != sln; sln = sln.Parent)
+            {
+                if (String.IsNullOrEmpty(sln.FileName))
+                {
+                    continue;
+                }
+                else if (sln.LineNumber.HasValue)
+                {
+                    if (fileNames.Count == 0)
+                    {
+                        errorFileName = String.Format(CultureInfo.CurrentUICulture, WixStrings.Format_FirstLineNumber, sln.FileName, sln.LineNumber);
+                    }
+
+                    fileNames.Add(String.Format(CultureInfo.CurrentUICulture, WixStrings.Format_LineNumber, sln.FileName, sln.LineNumber));
+                }
+                else
+                {
+                    if (fileNames.Count == 0)
+                    {
+                        errorFileName = sln.FileName;
+                    }
+
+                    fileNames.Add(sln.FileName);
+                }
+            }
+
+            var levelString = String.Empty;
+            if (MessageLevel.Warning == level)
+            {
+                levelString = WixStrings.MessageType_Warning;
+            }
+            else if (MessageLevel.Error == level)
+            {
+                levelString = WixStrings.MessageType_Error;
+            }
+
+            string formatted;
+            if (message.ResourceManager == null)
+            {
+                formatted = String.Format(CultureInfo.InvariantCulture, message.ResourceNameOrFormat, message.MessageArgs);
+            }
+            else
+            {
+                formatted = String.Format(CultureInfo.InvariantCulture, message.ResourceManager.GetString(message.ResourceNameOrFormat), message.MessageArgs);
+            }
+
+            var builder = new StringBuilder();
+            if (level == MessageLevel.Information || level == MessageLevel.Verbose)
+            {
+                builder.AppendFormat(WixStrings.Format_InfoMessage, formatted);
+            }
+            else
+            {
+                builder.AppendFormat(WixStrings.Format_NonInfoMessage, errorFileName, levelString, shortAppName, message.Id, formatted);
+            }
+
+            if (fileNames.Count > 1)
+            {
+                builder.AppendFormat(WixStrings.INF_SourceTrace, Environment.NewLine);
+
+                foreach (var fileName in fileNames)
+                {
+                    builder.AppendFormat(WixStrings.INF_SourceTraceLocation, fileName, Environment.NewLine);
+                }
+
+                builder.AppendLine();
+            }
+
+            return builder.ToString();
+        }
+
+        public void Write(Message message)
+        {
+            var level = CalculateMessageLevel(message);
+
+            if (level == MessageLevel.Nothing)
+            {
+                return;
+            }
+
+            if (level == MessageLevel.Error)
+            {
+                this.EncounteredError = true;
+                this.LastErrorNumber = message.Id;
+            }
+
+            if (this.listener != null)
+            {
+                this.listener.Write(message);
+            }
+            else if (level == MessageLevel.Error)
+            {
+                throw new WixException(message);
+            }
+        }
+
+        public void Write(string message, bool verbose = false)
+        {
+            if (!verbose || this.ShowVerboseMessages)
+            {
+                this.listener?.Write(message);
+            }
+        }
+
+        /// <summary>
+        /// Determines the level of this message, when taking into account warning-as-error, 
+        /// warning level, verbosity level and message suppressed by the caller.
+        /// </summary>
+        /// <param name="message">Event arguments for the message.</param>
+        /// <returns>MessageLevel representing the level of this message.</returns>
+        private MessageLevel CalculateMessageLevel(Message message)
+        {
+            var level = message.Level;
+
+            if (level == MessageLevel.Verbose)
+            {
+                if (!this.ShowVerboseMessages)
+                {
+                    level = MessageLevel.Nothing;
+                }
+            }
+            else if (level == MessageLevel.Warning)
+            {
+                if (this.SuppressAllWarnings || this.suppressedWarnings.Contains(message.Id))
+                {
+                    level = MessageLevel.Nothing;
+                }
+                else if (this.WarningsAsError || this.warningsAsErrors.Contains(message.Id))
+                {
+                    level = MessageLevel.Error;
+                }
+            }
+
+            return level;
+        }
+    }
+}