Refactoring Bootstrapper to introduce better coverage and testing

docs/content/bootstrapper.md

@@ -27,6 +27,8 @@ Options:
 
   `-f`: Forces the bootstrapper to ignore any cached paket.exe versions and go directly to github.com or nuget.org based on other flags.
 
+  `--help`: Shows a help page with all possible options.
+
 Environment Variables:
 
   `PAKET.VERSION`: The requested version can also be set using this environment variable. Above options take precedence over the environment variable 

paket.dependencies

@@ -24,5 +24,6 @@ group Test
 
   nuget NUnit.Runners
   nuget NUnit ~> 3
+  nuget Moq
   nuget FSCheck
   github forki/FsUnit FsUnit.fs

paket.lock

@@ -45,6 +45,7 @@ NUGET
     FsCheck (2.3)
       FSharp.Core (>= 3.1.2.5)
     FSharp.Core (4.0.0.1)
+    Moq (4.2.1510.2205)
     NUnit (3.2)
     NUnit.ConsoleRunner (3.2)
     NUnit.Extension.NUnitProjectLoader (3.2)

src/Paket.Bootstrapper/ArgumentParser.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace Paket.Bootstrapper
+{
+    public static class ArgumentParser
+    {
+        public static class CommandArgs
+        {
+            public const string Help = "--help";
+            public const string PreferNuget = "--prefer-nuget";
+            public const string ForceNuget = "--force-nuget";
+            public const string Prerelease = "prerelease";
+            public const string NugetSourceArgPrefix = "--nuget-source=";
+            public const string SelfUpdate = "--self";
+            public const string Silent = "-s";
+            public const string IgnoreCache = "-f";
+        }
+        public static class AppSettingKeys
+        {
+            public const string PreferNugetAppSettingsKey = "PreferNuget";
+            public const string ForceNugetAppSettingsKey = "ForceNuget";
+            public const string PaketVersionAppSettingsKey = "PaketVersion";
+        }
+        public static class EnvArgs
+        {
+            public const string PaketVersionEnv = "PAKET.VERSION";
+        }
+
+        public static BootstrapperOptions ParseArgumentsAndConfigurations(IEnumerable<string> arguments, NameValueCollection appSettings, IDictionary envVariables)
+        {
+            var options = new BootstrapperOptions();
+
+            var commandArgs = arguments.ToList();
+
+            if (commandArgs.Contains(CommandArgs.PreferNuget) || appSettings.GetKey(AppSettingKeys.PreferNugetAppSettingsKey).ToLowerSafe() == "true")
+            {
+                options.PreferNuget = true;
+                commandArgs.Remove(CommandArgs.PreferNuget);
+            }
+            if (commandArgs.Contains(CommandArgs.ForceNuget) || appSettings.GetKey(AppSettingKeys.ForceNugetAppSettingsKey).ToLowerSafe() == "true")
+            {
+                options.ForceNuget = true;
+                commandArgs.Remove(CommandArgs.ForceNuget);
+            }
+            if (commandArgs.Contains(CommandArgs.Silent))
+            {
+                options.Silent = true;
+                commandArgs.Remove(CommandArgs.Silent);
+            }
+            if (commandArgs.Contains(CommandArgs.Help))
+            {
+                options.ShowHelp = true;
+                commandArgs.Remove(CommandArgs.Help);
+            }
+
+            commandArgs = EvaluateDownloadOptions(options.DownloadArguments, commandArgs, appSettings, envVariables).ToList();
+
+            options.UnprocessedCommandArgs = commandArgs;
+            return options;
+        }
+
+        private static IEnumerable<string> EvaluateDownloadOptions(DownloadArguments downloadArguments, IEnumerable<string> args, NameValueCollection appSettings, IDictionary envVariables)
+        {
+            var folder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            var target = Path.Combine(folder, "paket.exe");
+            string nugetSource = null;
+
+            var latestVersion = appSettings.GetKey(AppSettingKeys.PaketVersionAppSettingsKey) ?? envVariables.GetKey(EnvArgs.PaketVersionEnv) ?? String.Empty;
+            var ignorePrerelease = true;
+            bool doSelfUpdate = false;
+            var ignoreCache = false;
+            var commandArgs = args.ToList();
+
+            if (commandArgs.Contains(CommandArgs.SelfUpdate))
+            {
+                commandArgs.Remove(CommandArgs.SelfUpdate);
+                doSelfUpdate = true;
+            }
+            var nugetSourceArg = commandArgs.SingleOrDefault(x => x.StartsWith(CommandArgs.NugetSourceArgPrefix));
+            if (nugetSourceArg != null)
+            {
+                commandArgs = commandArgs.Where(x => !x.StartsWith(CommandArgs.NugetSourceArgPrefix)).ToList();
+                nugetSource = nugetSourceArg.Substring(CommandArgs.NugetSourceArgPrefix.Length);
+            }
+            if (commandArgs.Contains(CommandArgs.IgnoreCache))
+            {
+                commandArgs.Remove(CommandArgs.IgnoreCache);
+                ignoreCache = true;
+            }
+            if (commandArgs.Count >= 1)
+            {
+                if (commandArgs[0] == CommandArgs.Prerelease)
+                {
+                    ignorePrerelease = false;
+                    latestVersion = String.Empty;
+                    commandArgs.Remove(CommandArgs.Prerelease);
+                }
+                else
+                {
+                    latestVersion = commandArgs[0];
+                    commandArgs.Remove(commandArgs[0]);
+                }
+            }
+
+            downloadArguments.LatestVersion = latestVersion;
+            downloadArguments.IgnorePrerelease = ignorePrerelease;
+            downloadArguments.IgnoreCache = ignoreCache;
+            downloadArguments.NugetSource = nugetSource;
+            downloadArguments.DoSelfUpdate = doSelfUpdate;
+            downloadArguments.Target = target;
+            downloadArguments.Folder = folder;
+            return commandArgs;
+        }
+
+        private static string GetKey(this NameValueCollection appSettings, string key)
+        {
+            if (appSettings != null && appSettings.AllKeys.Any(x => x == key))
+                return appSettings.Get(key);
+            return null;
+        }
+
+        private static string GetKey(this IDictionary dictionary, string key)
+        {
+            if (dictionary != null && dictionary.Keys.Cast<string>().Any(x => x == key))
+                return dictionary[key].ToString();
+            return null;
+        }
+
+        private static string ToLowerSafe(this string value)
+        {
+            if (value != null)
+                return value.ToLower();
+            return null;
+        }
+    }
+}

src/Paket.Bootstrapper/BootstrapperHelper.cs

@@ -8,6 +8,19 @@ namespace Paket.Bootstrapper
 {
     internal static class BootstrapperHelper
     {
+        public static string HelpText = @"The paket.bootstrapper downloads the latest version of paket.
+Usage for paket bootstrapper:
+paket.bootstrapper [OPTIONS] [prerelease|<version>]
+
+Options:
+--help                         print this help
+--prefer-nuget                 prefer nuget as download source instead of github
+--force-nuget                  only use nuget as source
+--nuget-source=<NUGET_SOURCE>  uses <NUGET_SOURCE> to download latest paket.
+                               NUGET_SOURCE can also be a filepath
+--self                         downloads and updates paket.bootstrapper
+-f                             don't use local cache; always downloads
+-s                             silent mode; no output";
         const string PaketBootstrapperUserAgent = "Paket.Bootstrapper";
 
         internal static string GetLocalFileVersion(string target)
@@ -27,7 +40,7 @@ internal static string GetLocalFileVersion(string target)
         internal static string GetTempFile(string name)
         {
             var path = Path.GetTempPath();
-            var fileName = Path.Combine(path, name + System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
+            var fileName = Path.Combine(path, name + System.Diagnostics.Process.GetCurrentProcess().Id);
             if (File.Exists(fileName))
                 File.Delete(fileName);
             return fileName;
@@ -50,24 +63,6 @@ internal static HttpWebRequest PrepareWebRequest(string url)
             return request;
         }
 
-        internal static void WriteConsoleError(string message)
-        {
-            WriteConsole(message, ConsoleColor.Red);
-        }
-
-        internal static void WriteConsoleInfo(string message)
-        {
-            WriteConsole(message, ConsoleColor.Yellow);
-        }
-
-        private static void WriteConsole(string message, ConsoleColor consoleColor)
-        {
-            var oldColor = Console.ForegroundColor;
-            Console.ForegroundColor = consoleColor;
-            Console.WriteLine(message);
-            Console.ForegroundColor = oldColor;
-        }
-
         internal static IWebProxy GetDefaultWebProxyFor(String url)
         {
             Uri uri = new Uri(url);

src/Paket.Bootstrapper/BootstrapperOptions.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace Paket.Bootstrapper
+{
+    public class BootstrapperOptions
+    {
+        public BootstrapperOptions()
+        {
+            DownloadArguments = new DownloadArguments();
+        }
+
+        public DownloadArguments DownloadArguments { get; set; }
+
+        public bool Silent { get; set; }
+        public bool ForceNuget { get; set; }
+        public bool PreferNuget { get; set; }
+        public bool ShowHelp { get; set; }
+        public IEnumerable<string> UnprocessedCommandArgs { get; set; }
+    }
+}