Update to WixOutput file structure to fix embedded file handling

7 files changed, 60 insertions, 76 deletions

diff --git a/src/WixToolset.Core/Bind/ExpectedExtractFile.cs b/src/WixToolset.Core/Bind/ExpectedExtractFile.cs
index afad12fc..b27cdfee 100644
--- a/src/WixToolset.Core/Bind/ExpectedExtractFile.cs
+++ b/src/WixToolset.Core/Bind/ExpectedExtractFile.cs
@@ -1,4 +1,4 @@
-// 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.
+// 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.Bind
 {
@@ -9,7 +9,7 @@ namespace WixToolset.Core.Bind
     {
         public Uri Uri { get; set; }
 
-        public int EmbeddedFileIndex { get; set; }
+        public string EmbeddedFileId { get; set; }
 
         public string OutputPath { get; set; }
     }
diff --git a/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs b/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
index 644e5c63..35c8a2f0 100644
--- a/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
+++ b/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
@@ -15,7 +15,7 @@ namespace WixToolset.Core.Bind
     /// </summary>
     internal class ExtractEmbeddedFiles
     {
-        private Dictionary<Uri, SortedList<int, string>> filesWithEmbeddedFiles = new Dictionary<Uri, SortedList<int, string>>();
+        private readonly Dictionary<Uri, SortedList<string, string>> filesWithEmbeddedFiles = new Dictionary<Uri, SortedList<string, string>>();
 
         public IEnumerable<Uri> Uris => this.filesWithEmbeddedFiles.Keys;
 
@@ -23,28 +23,28 @@ namespace WixToolset.Core.Bind
         /// Adds an embedded file index to track and returns the path where the embedded file will be extracted. Duplicates will return the same extract path.
         /// </summary>
         /// <param name="uri">Uri to file containing the embedded files.</param>
-        /// <param name="embeddedFileIndex">Index of the embedded file to extract.</param>
-        /// <param name="tempPath">Path where temporary files should be placed.</param>
+        /// <param name="embeddedFileId">Id of the embedded file to extract.</param>
+        /// <param name="extractFolder">Folder where extracted files should be placed.</param>
         /// <returns>The extract path for the embedded file.</returns>
-        public string AddEmbeddedFileIndex(Uri uri, int embeddedFileIndex, string tempPath)
+        public string AddEmbeddedFileToExtract(Uri uri, string embeddedFileId, string extractFolder)
         {
             // If the uri to the file that contains the embedded file does not already have embedded files
             // being extracted, create the dictionary to track that.
             if (!this.filesWithEmbeddedFiles.TryGetValue(uri, out var extracts))
             {
-                extracts = new SortedList<int, string>();
+                extracts = new SortedList<string, string>(StringComparer.OrdinalIgnoreCase);
                 this.filesWithEmbeddedFiles.Add(uri, extracts);
             }
 
             // If the embedded file is not already tracked in the dictionary of extracts, add it.
-            if (!extracts.TryGetValue(embeddedFileIndex, out var extractPath))
+            if (!extracts.TryGetValue(embeddedFileId, out var extractPath))
             {
-                string localFileNameWithoutExtension = Path.GetFileNameWithoutExtension(uri.LocalPath);
-                string unique = this.HashUri(uri.AbsoluteUri);
-                string extractedName = String.Format(CultureInfo.InvariantCulture, @"{0}_{1}\{2}", localFileNameWithoutExtension, unique, embeddedFileIndex);
+                var localFileNameWithoutExtension = Path.GetFileNameWithoutExtension(uri.LocalPath);
+                var unique = this.HashUri(uri.AbsoluteUri);
+                var extractedName = String.Format(CultureInfo.InvariantCulture, @"{0}_{1}\{2}", localFileNameWithoutExtension, unique, embeddedFileId);
 
-                extractPath = Path.Combine(tempPath, extractedName);
-                extracts.Add(embeddedFileIndex, extractPath);
+                extractPath = Path.GetFullPath(Path.Combine(extractFolder, extractedName));
+                extracts.Add(embeddedFileId, extractPath);
             }
 
             return extractPath;
@@ -52,35 +52,39 @@ namespace WixToolset.Core.Bind
 
         public IEnumerable<ExpectedExtractFile> GetExpectedEmbeddedFiles()
         {
+            var files = new List<ExpectedExtractFile>();
+
             foreach (var uriWithExtracts in this.filesWithEmbeddedFiles)
             {
                 foreach (var extracts in uriWithExtracts.Value)
                 {
-                    yield return new ExpectedExtractFile
+                    files.Add(new ExpectedExtractFile
                     {
                         Uri = uriWithExtracts.Key,
-                        EmbeddedFileIndex = extracts.Key,
+                        EmbeddedFileId = extracts.Key,
                         OutputPath = extracts.Value,
-                    };
+                    });
                 }
             }
+
+            return files;
         }
 
         public IEnumerable<ExpectedExtractFile> GetExtractFilesForUri(Uri uri)
         {
             if (!this.filesWithEmbeddedFiles.TryGetValue(uri, out var extracts))
             {
-                extracts = new SortedList<int, string>();
+                extracts = new SortedList<string, string>(StringComparer.OrdinalIgnoreCase);
             }
 
-            return extracts.Select(e => new ExpectedExtractFile() { Uri = uri, EmbeddedFileIndex = e.Key, OutputPath = e.Value });
+            return extracts.Select(e => new ExpectedExtractFile { Uri = uri, EmbeddedFileId = e.Key, OutputPath = e.Value });
         }
 
         private string HashUri(string uri)
         {
             using (SHA1 sha1 = new SHA1CryptoServiceProvider())
             {
-                byte[] hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(uri));
+                var hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(uri));
                 return Convert.ToBase64String(hash).TrimEnd('=').Replace('+', '-').Replace('/', '_');
             }
         }
diff --git a/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs b/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
index d82609db..683c3c50 100644
--- a/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
+++ b/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
@@ -2,10 +2,9 @@
 
 namespace WixToolset.Core.Bind
 {
+    using System;
     using System.Collections.Generic;
-    using System.IO;
     using System.Linq;
-    using System.Reflection;
     using WixToolset.Data;
     using WixToolset.Extensibility.Data;
 
@@ -26,41 +25,18 @@ namespace WixToolset.Core.Bind
             {
                 var baseUri = expectedEmbeddedFileByUri.Key;
 
-                Stream stream = null;
-                try
+                using (var wixout = WixOutput.Read(baseUri))
                 {
-                    // If the embedded files are stored in an assembly resource stream (usually
-                    // a .wixlib embedded in a WixExtension).
-                    if ("embeddedresource" == baseUri.Scheme)
-                    {
-                        var assemblyPath = Path.GetFullPath(baseUri.LocalPath);
-                        var resourceName = baseUri.Fragment.TrimStart('#');
-
-                        var assembly = Assembly.LoadFile(assemblyPath);
-                        stream = assembly.GetManifestResourceStream(resourceName);
-                    }
-                    else // normal file (usually a binary .wixlib on disk).
-                    {
-                        stream = File.OpenRead(baseUri.LocalPath);
-                    }
+                    var uniqueIds = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
 
-                    using (var fs = FileStructure.Read(stream))
+                    foreach (var embeddedFile in expectedEmbeddedFileByUri)
                     {
-                        var uniqueIndicies = new SortedSet<int>();
-
-                        foreach (var embeddedFile in expectedEmbeddedFileByUri)
+                        if (uniqueIds.Add(embeddedFile.EmbeddedFileId))
                         {
-                            if (uniqueIndicies.Add(embeddedFile.EmbeddedFileIndex))
-                            {
-                                fs.ExtractEmbeddedFile(embeddedFile.EmbeddedFileIndex, embeddedFile.OutputPath);
-                            }
+                            wixout.ExtractEmbeddedFile(embeddedFile.EmbeddedFileId, embeddedFile.OutputPath);
                         }
                     }
                 }
-                finally
-                {
-                    stream?.Close();
-                }
             }
         }
     }
diff --git a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
index 2c213402..19a26915 100644
--- a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
+++ b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
@@ -98,9 +98,9 @@ namespace WixToolset.Core.Bind
 #endif
 
                             // File is embedded and path to it was not modified above.
-                            if (objectField.EmbeddedFileIndex.HasValue && isDefault)
+                            if (isDefault && objectField.Embed)
                             {
-                                var extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.BaseUri, objectField.EmbeddedFileIndex.Value, this.IntermediateFolder);
+                                var extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileToExtract(objectField.BaseUri, objectField.Path, this.IntermediateFolder);
 
                                 // Set the path to the embedded file once where it will be extracted.
                                 field.Set(extractPath);
diff --git a/src/WixToolset.Core/CommandLine/BuildCommand.cs b/src/WixToolset.Core/CommandLine/BuildCommand.cs
index 972258fe..5ee60984 100644
--- a/src/WixToolset.Core/CommandLine/BuildCommand.cs
+++ b/src/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -100,29 +100,38 @@ namespace WixToolset.Core.CommandLine
 
             if (this.OutputType == OutputType.Library)
             {
-                var wixlib = this.LibraryPhase(wixobjs, wxls, this.commandLine.BindFiles, this.commandLine.BindPaths);
-
-                if (!this.Messaging.EncounteredError)
+                using (new IntermediateFieldContext("wix.lib"))
                 {
-                    wixlib.Save(this.commandLine.OutputFile);
+                    var wixlib = this.LibraryPhase(wixobjs, wxls, this.commandLine.BindFiles, this.commandLine.BindPaths);
+
+                    if (!this.Messaging.EncounteredError)
+                    {
+                        wixlib.Save(this.commandLine.OutputFile);
+                    }
                 }
             }
             else
             {
-                if (wixipl == null)
-                {
-                    wixipl = this.LinkPhase(wixobjs, this.commandLine.LibraryFilePaths, creator);
-                }
-
-                if (!this.Messaging.EncounteredError)
+                using (new IntermediateFieldContext("wix.link"))
                 {
-                    if (this.OutputType == OutputType.IntermediatePostLink)
+                    if (wixipl == null)
                     {
-                        wixipl.Save(this.commandLine.OutputFile);
+                        wixipl = this.LinkPhase(wixobjs, this.commandLine.LibraryFilePaths, creator);
                     }
-                    else
+
+                    if (!this.Messaging.EncounteredError)
                     {
-                        this.BindPhase(wixipl, wxls, filterCultures, this.commandLine.CabCachePath, this.commandLine.BindPaths, this.commandLine.BurnStubPath);
+                        if (this.OutputType == OutputType.IntermediatePostLink)
+                        {
+                            wixipl.Save(this.commandLine.OutputFile);
+                        }
+                        else
+                        {
+                            using (new IntermediateFieldContext("wix.bind"))
+                            {
+                                this.BindPhase(wixipl, wxls, filterCultures, this.commandLine.CabCachePath, this.commandLine.BindPaths, this.commandLine.BurnStubPath);
+                            }
+                        }
                     }
                 }
             }
@@ -469,6 +478,7 @@ namespace WixToolset.Core.CommandLine
                             break;
                         }
 
+                        case "bf":
                         case "bindfiles":
                             this.BindFiles = true;
                             return true;
diff --git a/src/WixToolset.Core/Librarian.cs b/src/WixToolset.Core/Librarian.cs
index 3c1810ac..5c0fb302 100644
--- a/src/WixToolset.Core/Librarian.cs
+++ b/src/WixToolset.Core/Librarian.cs
@@ -56,14 +56,14 @@ namespace WixToolset.Core
                     return null;
                 }
 
-                var embedFilePaths = this.ResolveFilePathsToEmbed(context, sections);
+                this.ResolveFilePathsToEmbed(context, sections);
 
                 foreach (var section in sections)
                 {
                     section.LibraryId = context.LibraryId;
                 }
 
-                library = new Intermediate(context.LibraryId, sections, localizationsByCulture, embedFilePaths);
+                library = new Intermediate(context.LibraryId, sections, localizationsByCulture);
 
                 this.Validate(library);
             }
@@ -78,10 +78,8 @@ namespace WixToolset.Core
             return this.Messaging.EncounteredError ? null : library;
         }
 
-        private List<string> ResolveFilePathsToEmbed(ILibraryContext context, IEnumerable<IntermediateSection> sections)
+        private void ResolveFilePathsToEmbed(ILibraryContext context, IEnumerable<IntermediateSection> sections)
         {
-            var embedFilePaths = new List<string>();
-
             // Resolve paths to files that are to be embedded in the library.
             if (context.BindFiles)
             {
@@ -104,9 +102,7 @@ namespace WixToolset.Core
                             if (!String.IsNullOrEmpty(file))
                             {
                                 // File was successfully resolved so track the embedded index as the embedded file index.
-                                field.Set(new IntermediateFieldPathValue { EmbeddedFileIndex = embedFilePaths.Count });
-
-                                embedFilePaths.Add(file);
+                                field.Set(new IntermediateFieldPathValue { Embed = true, Path = file });
                             }
                             else
                             {
@@ -116,8 +112,6 @@ namespace WixToolset.Core
                     }
                 }
             }
-
-            return embedFilePaths;
         }
 
         private void Validate(Intermediate library)
diff --git a/src/WixToolset.Core/Linker.cs b/src/WixToolset.Core/Linker.cs
index 81696840..6ef252b7 100644
--- a/src/WixToolset.Core/Linker.cs
+++ b/src/WixToolset.Core/Linker.cs
@@ -564,7 +564,7 @@ namespace WixToolset.Core
                 var collate = new CollateLocalizationsCommand(this.Messaging, localizations);
                 var localizationsByCulture = collate.Execute();
 
-                intermediate = new Intermediate(resolvedSection.Id, new[] { resolvedSection }, localizationsByCulture, null);
+                intermediate = new Intermediate(resolvedSection.Id, new[] { resolvedSection }, localizationsByCulture);
 
 #if MOVE_TO_BACKEND
                 this.CheckOutputConsistency(output);