fixes #523 allow for property overrides to be passed in

ElectronNET.CLI/Commands/BuildCommand.cs

@@ -21,6 +21,7 @@ public class BuildCommand : ICommand
                                                  "Optional: '/absolute-path to specify and absolute path for output." + Environment.NewLine +
                                                  "Optional: '/package-json' to specify a custom package.json file." + Environment.NewLine +
                                                  "Optional: '/install-modules' to force node module install. Implied by '/package-json'" + Environment.NewLine +
+                                                 "Optional: '/p:[property]' or '/property:[property]' to pass in dotnet publish properties.  Example: '/property:Version=1.0.0' to override the FileVersion" + Environment.NewLine +
                                                  "Full example for a 32bit debug build with electron prune: build /target custom win7-x86;win32 /dotnet-configuration Debug /electron-arch ia32  /electron-params \"--prune=true \"";
 
         public static IList<CommandOption> CommandOptions { get; set; } = new List<CommandOption>();
@@ -95,28 +96,18 @@ public Task<bool> ExecuteAsync()
                 string tempBinPath = Path.Combine(tempPath, "bin");
 
                 Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration...");
+
+                var dotNetPublishFlags = GetDotNetPublishFlags(parser);
 
-                string publishReadyToRun = "/p:PublishReadyToRun=";
-                if (parser.Arguments.ContainsKey(_paramPublishReadyToRun))
-                {
-                    publishReadyToRun += parser.Arguments[_paramPublishReadyToRun][0];
-                }
-                else
-                {
-                    publishReadyToRun += "true";
-                }
+                var command =
+                    $"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} --self-contained";
+
+                // output the command 
+                Console.ForegroundColor = ConsoleColor.Green;
+                Console.WriteLine(command);
+                Console.ResetColor();
 
-                string publishSingleFile = "/p:PublishSingleFile=";
-                if (parser.Arguments.ContainsKey(_paramPublishSingleFile))
-                {
-                    publishSingleFile += parser.Arguments[_paramPublishSingleFile][0];
-                }
-                else
-                {
-                    publishSingleFile += "true";
-                }
-
-                var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {publishReadyToRun} {publishSingleFile} --self-contained", Directory.GetCurrentDirectory());
+                var resultCode = ProcessHelper.CmdExecute(command, Directory.GetCurrentDirectory());
 
                 if (resultCode != 0)
                 {
@@ -204,5 +195,43 @@ public Task<bool> ExecuteAsync()
                 return true;
             });
         }
+
+        private Dictionary<string, string> GetDotNetPublishFlags(SimpleCommandLineParser parser)
+        {
+            var dotNetPublishFlags = new Dictionary<string, string>
+            {
+                {"/p:PublishReadyToRun", parser.TryGet(_paramPublishReadyToRun, out var rtr) ? rtr[0] : "true"},
+                {"/p:PublishSingleFile", parser.TryGet(_paramPublishSingleFile, out var psf) ? psf[0] : "true"},
+            };
+
+            foreach (var parm in parser.Arguments.Keys.Where(key => key.StartsWith("p:") || key.StartsWith("property:")))
+            {
+                var split = parm.IndexOf('=');
+                if (split < 0)
+                {
+                    continue;
+                }
+
+                var key = $"/{parm.Substring(0, split)}";
+                // normalize the key
+                if (key.StartsWith("/property:"))
+                {
+                    key = key.Replace("/property:", "/p:");
+                }
+
+                var value = parm.Substring(split + 1);
+
+                if (dotNetPublishFlags.ContainsKey(key))
+                {
+                    dotNetPublishFlags[key] = value;
+                }
+                else
+                {
+                    dotNetPublishFlags.Add(key, value);
+                }
+            }
+
+            return dotNetPublishFlags;
+        }
     }
 }

ElectronNET.CLI/SimpleCommandLineParser.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace ElectronNET.CLI
 {
@@ -29,10 +31,24 @@ public void Parse(string[] args)
             }
             if (currentName != "")
                 Arguments[currentName] = values.ToArray();
+
+            Console.ForegroundColor = ConsoleColor.Green;
+            Console.WriteLine($"Arguments: \n\t{string.Join("\n\t",Arguments.Keys.Select(i => $"{i} = {string.Join(" ", Arguments[i])}"))}");
+            Console.ResetColor();
         }
         public bool Contains(string name)
         {
             return Arguments.ContainsKey(name);
         }
+
+        internal bool TryGet(string key, out string[] value)
+        {
+            value = null;
+            if (!Contains(key)) {
+                return false;
+            }
+            value = Arguments[key];
+            return true;
+        }
     }
 }