1 files changed, 202 insertions, 0 deletions

diff --git a/src/tools/heat/Extensibility/BaseMutatorExtension.cs b/src/tools/heat/Extensibility/BaseMutatorExtension.cs
new file mode 100644
index 00000000..c36a8ed1
--- /dev/null
+++ b/src/tools/heat/Extensibility/BaseMutatorExtension.cs
@@ -0,0 +1,202 @@
+// 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.Harvesters.Extensibility
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Text;
+    using Wix = WixToolset.Harvesters.Serialize;
+
+    /// <summary>
+    /// The base mutator extension.  Any of these methods can be overridden to change
+    /// the behavior of the mutator.
+    /// </summary>
+    public abstract class BaseMutatorExtension : IMutatorExtension
+    {
+        /// <summary>
+        /// Gets or sets the mutator core for the extension.
+        /// </summary>
+        /// <value>The mutator core for the extension.</value>
+        public IHarvesterCore Core { get; set; }
+
+        /// <summary>
+        /// Gets the sequence of the extension.
+        /// </summary>
+        /// <value>The sequence of the extension.</value>
+        public abstract int Sequence { get; }
+
+        /// <summary>
+        /// Mutate a WiX document.
+        /// </summary>
+        /// <param name="wix">The Wix document element.</param>
+        public virtual void Mutate(Wix.Wix wix)
+        {
+        }
+
+        /// <summary>
+        /// Mutate a WiX document as a string.
+        /// </summary>
+        /// <param name="wixString">The Wix document element as a string.</param>
+        /// <returns>The mutated Wix document as a string.</returns>
+        public virtual string Mutate(string wixString)
+        {
+            return wixString;
+        }
+
+        /// <summary>
+        /// Generate unique MSI identifiers.
+        /// </summary>
+        protected class IdentifierGenerator
+        {
+            /// <summary>
+            /// 
+            /// </summary>
+            public const int MaxProductIdentifierLength = 72;
+
+            /// <summary>
+            /// 
+            /// </summary>
+            public const int MaxModuleIdentifierLength = 35;
+
+            private string baseName;
+            private int maxLength;
+            private Dictionary<string, object> existingIdentifiers;
+            private Dictionary<string, object> possibleIdentifiers;
+            private IHarvesterCore harvesterCore;
+
+            /// <summary>
+            /// Instantiate a new IdentifierGenerator.
+            /// </summary>
+            /// <param name="baseName">The base resource name to use if a resource name contains no usable characters.</param>
+            /// <param name="harvesterCore"></param>
+            public IdentifierGenerator(string baseName, IHarvesterCore harvesterCore)
+            {
+                this.baseName = baseName;
+                this.maxLength = IdentifierGenerator.MaxProductIdentifierLength;
+                this.existingIdentifiers = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                this.possibleIdentifiers = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                this.harvesterCore = harvesterCore;
+            }
+
+            /// <summary>
+            /// Gets or sets the maximum length for generated identifiers.
+            /// </summary>
+            /// <value>Maximum length for generated identifiers. (Default is 72.)</value>
+            public int MaxIdentifierLength
+            {
+                get { return this.maxLength; }
+                set { this.maxLength = value; }
+            }
+
+            /// <summary>
+            /// Index an existing identifier for collision detection.
+            /// </summary>
+            /// <param name="identifier">The identifier.</param>
+            public void IndexExistingIdentifier(string identifier)
+            {
+                if (null == identifier)
+                {
+                    throw new ArgumentNullException("identifier");
+                }
+
+                this.existingIdentifiers[identifier] = null;
+            }
+
+            /// <summary>
+            /// Index a resource name for collision detection.
+            /// </summary>
+            /// <param name="name">The resource name.</param>
+            public void IndexName(string name)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                string identifier = this.CreateIdentifier(name, 0);
+
+                if (this.possibleIdentifiers.ContainsKey(identifier))
+                {
+                    this.possibleIdentifiers[identifier] = String.Empty;
+                }
+                else
+                {
+                    this.possibleIdentifiers.Add(identifier, null);
+                }
+            }
+
+            /// <summary>
+            /// Get the identifier for the given resource name.
+            /// </summary>
+            /// <param name="name">The resource name.</param>
+            /// <returns>A legal MSI identifier.</returns>
+            public string GetIdentifier(string name)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                for (int i = 0; i <= Int32.MaxValue; i++)
+                {
+                    string identifier = this.CreateIdentifier(name, i);
+
+                    if (this.existingIdentifiers.ContainsKey(identifier) || // already used
+                        (0 == i && 0 != this.possibleIdentifiers.Count && null != this.possibleIdentifiers[identifier]) || // needs an index because its duplicated
+                        (0 != i && this.possibleIdentifiers.ContainsKey(identifier))) // collides with another possible identifier
+                    {
+                        continue;
+                    }
+                    else // use this identifier
+                    {
+                        this.existingIdentifiers.Add(identifier, null);
+
+                        return identifier;
+                    }
+                }
+
+                throw new InvalidOperationException("Could not find a unique identifier for the given resource name.");
+            }
+
+            /// <summary>
+            /// Create a legal MSI identifier from a resource name and an index.
+            /// </summary>
+            /// <param name="name">The name of the resource for which an identifier should be created.</param>
+            /// <param name="index">An index to append to the end of the identifier to make it unique.</param>
+            /// <returns>A legal MSI identifier.</returns>
+            public string CreateIdentifier(string name, int index)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                StringBuilder identifier = new StringBuilder();
+
+                // Convert the name to a standard MSI identifier
+                identifier.Append(this.harvesterCore.CreateIdentifierFromFilename(name));
+
+                // no legal identifier characters were found, use the base id instead
+                if (0 == identifier.Length)
+                {
+                    identifier.Append(this.baseName);
+                }
+
+                // truncate the identifier if it's too long (reserve 3 characters for up to 99 collisions)
+                int adjustedMaxLength = this.MaxIdentifierLength - (index != 0 ? 3 : 0);
+                if (adjustedMaxLength < identifier.Length)
+                {
+                    identifier.Length = adjustedMaxLength;
+                }
+
+                // if the index is not zero, then append it to the identifier name
+                if (0 != index)
+                {
+                    identifier.AppendFormat("_{0}", index);
+                }
+
+                return identifier.ToString();
+            }
+        }
+    }
+}