From a40085812dfc8926084a66139981f14ad1e359d8 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Wed, 6 Aug 2014 15:40:16 +0200
Subject: [PATCH 01/11] Brutal ripping of code into partial classes - doesn't
 compile at all

---
 src/Squirrel/Squirrel.csproj                  |   3 +
 src/Squirrel/UpdateManager.ApplyReleases.cs   | 285 ++++++++++
 src/Squirrel/UpdateManager.CheckForUpdates.cs | 159 ++++++
 .../UpdateManager.DownloadReleases.cs         |  82 +++
 src/Squirrel/UpdateManager.cs                 | 502 +-----------------
 5 files changed, 530 insertions(+), 501 deletions(-)
 create mode 100644 src/Squirrel/UpdateManager.ApplyReleases.cs
 create mode 100644 src/Squirrel/UpdateManager.CheckForUpdates.cs
 create mode 100644 src/Squirrel/UpdateManager.DownloadReleases.cs

diff --git a/src/Squirrel/Squirrel.csproj b/src/Squirrel/Squirrel.csproj
index 1adfd660..e722a1fb 100644
--- a/src/Squirrel/Squirrel.csproj
+++ b/src/Squirrel/Squirrel.csproj
@@ -79,11 +79,14 @@
     <Compile Include="ShellFile.cs" />
     <Compile Include="TaskbarHelper.cs" />
     <Compile Include="UpdateInfo.cs" />
+    <Compile Include="UpdateManager.CheckForUpdates.cs" />
     <Compile Include="UpdateManager.cs" />
     <Compile Include="Utility.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
+    <Compile Include="UpdateManager.DownloadReleases.cs" />
+    <Compile Include="UpdateManager.ApplyReleases.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
diff --git a/src/Squirrel/UpdateManager.ApplyReleases.cs b/src/Squirrel/UpdateManager.ApplyReleases.cs
new file mode 100644
index 00000000..a346f101
--- /dev/null
+++ b/src/Squirrel/UpdateManager.ApplyReleases.cs
@@ -0,0 +1,285 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Splat;
+
+namespace Squirrel
+{
+    public sealed partial class UpdateManager
+    {
+        class ApplyReleases : IEnableLogger
+        {
+			public async Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
+			{
+				progress = progress ?? (_ => { });
+
+                await cleanDeadVersions(updateInfo.CurrentlyInstalledVersion != null ? updateInfo.CurrentlyInstalledVersion.Version : null);
+				progress(10);
+
+				var release = await createFullPackagesFromDeltas(updateInfo.ReleasesToApply, updateInfo.CurrentlyInstalledVersion);
+				progress(50);
+
+				await installPackageToAppDir(updateInfo, release);
+				progress(95);
+
+                await updateLocalReleasesFile();
+				progress(100);
+			}
+
+			async Task installPackageToAppDir(UpdateInfo updateInfo, ReleaseEntry release)
+			{
+				var pkg = new ZipPackage(Path.Combine(updateInfo.PackageDirectory, release.Filename));
+				var target = getDirectoryForRelease(release.Version);
+
+				// NB: This might happen if we got killed partially through applying the release
+				if (target.Exists) {
+					await Utility.DeleteDirectory(target.FullName);
+				}
+
+				target.Create();
+
+				// Copy all of the files out of the lib/ dirs in the NuGet package
+				// into our target App directory.
+				//
+				// NB: We sort this list in order to guarantee that if a Net20
+				// and a Net40 version of a DLL get shipped, we always end up
+				// with the 4.0 version.
+				this.Log().Info("Writing files to app directory: {0}", target.FullName);
+
+				var toWrite = pkg.GetLibFiles().Where(x => pathIsInFrameworkProfile(x, appFrameworkVersion))
+					.OrderBy(x => x.Path)
+					.ToList();
+
+				// NB: Because of the above NB, we cannot use ForEachAsync here, we 
+				// have to copy these files in-order. Once we fix assembly resolution, 
+				// we can kill both of these NBs.
+				await Task.Run(() => toWrite.ForEach(x => CopyFileToLocation(target, x)));
+
+				await pkg.GetContentFiles().ForEachAsync(x => CopyFileToLocation(target, x));
+
+				var newCurrentVersion = updateInfo.FutureReleaseEntry.Version;
+
+				// Perform post-install; clean up the previous version by asking it
+				// which shortcuts to install, and nuking them. Then, run the app's
+				// post install and set up shortcuts.
+				runPostInstallAndCleanup(newCurrentVersion, updateInfo.IsBootstrapping);
+			}
+
+			void CopyFileToLocation(FileSystemInfo target, IPackageFile x)
+			{
+				var targetPath = Path.Combine(target.FullName, x.EffectivePath);
+
+				var fi = new FileInfo(targetPath);
+				if (fi.Exists) fi.Delete();
+
+				var dir = new DirectoryInfo(Path.GetDirectoryName(targetPath));
+				if (!dir.Exists) dir.Create();
+
+				using (var inf = x.GetStream())
+				using (var of = fi.Open(FileMode.CreateNew, FileAccess.Write)) {
+					inf.CopyTo(of);
+				}
+			}
+
+			void runPostInstallAndCleanup(Version newCurrentVersion, bool isBootstrapping)
+			{
+				fixPinnedExecutables(newCurrentVersion);
+
+				this.Log().Info("runPostInstallAndCleanup: finished fixPinnedExecutables");
+				cleanUpOldVersions(newCurrentVersion);
+			}
+
+			static bool pathIsInFrameworkProfile(IPackageFile packageFile, FrameworkVersion appFrameworkVersion)
+			{
+				if (!packageFile.Path.StartsWith("lib", StringComparison.InvariantCultureIgnoreCase)) {
+					return false;
+				}
+
+				if (appFrameworkVersion == FrameworkVersion.Net40
+					&& packageFile.Path.StartsWith("lib\\net45", StringComparison.InvariantCultureIgnoreCase)) {
+					return false;
+				}
+
+				return true;
+			}
+
+			async Task<ReleaseEntry> createFullPackagesFromDeltas(IEnumerable<ReleaseEntry> releasesToApply, ReleaseEntry currentVersion)
+			{
+				Contract.Requires(releasesToApply != null);
+
+				// If there are no deltas in our list, we're already done
+				if (!releasesToApply.Any() || releasesToApply.All(x => !x.IsDelta)) {
+					return releasesToApply.MaxBy(x => x.Version).First();
+				}
+
+				if (!releasesToApply.All(x => x.IsDelta)) {
+					throw new Exception("Cannot apply combinations of delta and full packages");
+				}
+
+				// Smash together our base full package and the nearest delta
+				var ret = await Task.Run(() => {
+					var basePkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", currentVersion.Filename));
+					var deltaPkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", releasesToApply.First().Filename));
+
+					var deltaBuilder = new DeltaPackageBuilder();
+
+					return deltaBuilder.ApplyDeltaPackage(basePkg, deltaPkg,
+						Regex.Replace(deltaPkg.InputPackageFile, @"-delta.nupkg$", ".nupkg", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant));
+				});
+
+				if (releasesToApply.Count() == 1) {
+					return ReleaseEntry.GenerateFromFile(ret.InputPackageFile);
+				}
+
+				var fi = new FileInfo(ret.InputPackageFile);
+				var entry = ReleaseEntry.GenerateFromFile(fi.OpenRead(), fi.Name);
+
+				// Recursively combine the rest of them
+				return await createFullPackagesFromDeltas(releasesToApply.Skip(1), entry);
+			}
+
+			void cleanUpOldVersions(Version newCurrentVersion)
+			{
+				var directory = new DirectoryInfo(rootAppDirectory);
+				if (!directory.Exists) {
+					this.Log().Warn("cleanUpOldVersions: the directory '{0}' does not exist", rootAppDirectory);
+					return;
+				}
+				
+				foreach (var v in getOldReleases(newCurrentVersion)) {
+					Utility.DeleteDirectoryAtNextReboot(v.FullName);
+				}
+			}
+
+			void fixPinnedExecutables(Version newCurrentVersion) 
+			{
+				if (Environment.OSVersion.Version < new Version(6, 1)) {
+					this.Log().Warn("fixPinnedExecutables: Found OS Version '{0}', exiting...", Environment.OSVersion.VersionString);
+					return;
+				}
+
+				var newCurrentFolder = "app-" + newCurrentVersion;
+				var oldAppDirectories = (new DirectoryInfo(rootAppDirectory)).GetDirectories()
+					.Where(x => x.Name.StartsWith("app-", StringComparison.InvariantCultureIgnoreCase))
+					.Where(x => x.Name != newCurrentFolder)
+					.Select(x => x.FullName)
+					.ToArray();
+
+				if (!oldAppDirectories.Any()) {
+					this.Log().Info("fixPinnedExecutables: oldAppDirectories is empty, this is pointless");
+					return;
+				}
+
+				var newAppPath = Path.Combine(rootAppDirectory, newCurrentFolder);
+
+				var taskbarPath = Path.Combine(
+					Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+					"Microsoft\\Internet Explorer\\Quick Launch\\User Pinned\\TaskBar");
+
+				Func<FileInfo, ShellLink> resolveLink = file => {
+					try {
+						return new ShellLink(file.FullName);
+					} catch (Exception ex) {
+						var message = String.Format("File '{0}' could not be converted into a valid ShellLink", file.FullName);
+						this.Log().WarnException(message, ex);
+						return null;
+					}
+				};
+
+				var shellLinks = (new DirectoryInfo(taskbarPath)).GetFiles("*.lnk")
+					.Select(resolveLink)
+					.Where(x => x != null)
+					.ToArray();
+
+				foreach (var shortcut in shellLinks) {
+					try {
+						updateLink(shortcut, oldAppDirectories, newAppPath);
+					} catch (Exception ex) {
+						var message = String.Format("fixPinnedExecutables: shortcut failed: {0}", shortcut.Target);
+						this.Log().ErrorException(message, ex);
+					}
+				}
+			}
+
+			void updateLink(ShellLink shortcut, string[] oldAppDirectories, string newAppPath)
+			{
+				this.Log().Info("Processing shortcut '{0}'", shortcut.Target);
+
+				foreach (var oldAppDirectory in oldAppDirectories) {
+					if (!shortcut.Target.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
+						this.Log().Info("Does not match '{0}', continuing to next directory", oldAppDirectory);
+						continue;
+					}
+
+					// replace old app path with new app path and check, if executable still exists
+					var newTarget = Path.Combine(newAppPath, shortcut.Target.Substring(oldAppDirectory.Length + 1));
+
+					if (File.Exists(newTarget)) {
+						shortcut.Target = newTarget;
+
+						// replace working directory too if appropriate
+						if (shortcut.WorkingDirectory.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
+							this.Log().Info("Changing new directory to '{0}'", newAppPath);
+							shortcut.WorkingDirectory = Path.Combine(newAppPath,
+								shortcut.WorkingDirectory.Substring(oldAppDirectory.Length + 1));
+						}
+
+						shortcut.Save();
+					}
+					else {
+						this.Log().Info("Unpinning {0} from taskbar", shortcut.Target);
+						TaskbarHelper.UnpinFromTaskbar(shortcut.Target);
+					}
+
+					break;
+				}
+			}
+
+			// NB: Once we uninstall the old version of the app, we try to schedule
+			// it to be deleted at next reboot. Unfortunately, depending on whether
+			// the user has admin permissions, this can fail. So as a failsafe,
+			// before we try to apply any update, we assume previous versions in the
+			// directory are "dead" (i.e. already uninstalled, but not deleted), and
+			// we blow them away. This is to make sure that we don't attempt to run
+			// an uninstaller on an already-uninstalled version.
+			async Task cleanDeadVersions(Version currentVersion)
+			{
+				if (currentVersion == null) return;
+
+				var di = new DirectoryInfo(rootAppDirectory);
+				if (!di.Exists) return;
+
+				this.Log().Info("cleanDeadVersions: for version {0}", currentVersion);
+
+				string currentVersionFolder = null;
+				if (currentVersion != null) {
+					currentVersionFolder = getDirectoryForRelease(currentVersion).Name;
+					this.Log().Info("cleanDeadVersions: exclude folder {0}", currentVersionFolder);
+				}
+
+				// NB: If we try to access a directory that has already been 
+				// scheduled for deletion by MoveFileEx it throws what seems like
+				// NT's only error code, ERROR_ACCESS_DENIED. Squelch errors that
+				// come from here.
+				var toCleanup = di.GetDirectories()
+					.Where(x => x.Name.ToLowerInvariant().Contains("app-"))
+					.Where(x => x.Name != currentVersionFolder);
+
+				await toCleanup.ForEachAsync(async x => {
+					try {
+						await Utility.DeleteDirectory(x.FullName);
+					} catch (UnauthorizedAccessException ex) {
+						this.Log().WarnException("Couldn't delete directory: " + x.FullName, ex);
+					}
+				});
+			}
+
+			async Task updateLocalReleasesFile()
+			{
+				await Task.Run(() => ReleaseEntry.BuildReleasesFile(PackageDirectory));
+			}
+        }
+    }
+}
diff --git a/src/Squirrel/UpdateManager.CheckForUpdates.cs b/src/Squirrel/UpdateManager.CheckForUpdates.cs
new file mode 100644
index 00000000..1e761569
--- /dev/null
+++ b/src/Squirrel/UpdateManager.CheckForUpdates.cs
@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Splat;
+
+namespace Squirrel
+{
+    public sealed partial class UpdateManager
+    {
+        class CheckForUpdates : IEnableLogger
+        {
+            public async Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates = false, Action<int> progress = null)
+            {
+                progress = progress ?? (_ => { });
+
+                var localReleases = Enumerable.Empty<ReleaseEntry>();
+
+                bool shouldInitialize = false;
+                try {
+                    var file = File.OpenRead(LocalReleaseFile);
+
+                    // NB: sr disposes file
+                    using (var sr = new StreamReader(file, Encoding.UTF8)) {
+                        localReleases = ReleaseEntry.ParseReleaseFile(sr.ReadToEnd());
+                    }
+                } catch (Exception ex) {
+                    // Something has gone wrong, we'll start from scratch.
+                    this.Log().WarnException("Failed to load local release list", ex);
+                    shouldInitialize = true;
+                }
+
+                if (shouldInitialize) await initializeClientAppDirectory();
+
+                string releaseFile;
+
+                // Fetch the remote RELEASES file, whether it's a local dir or an 
+                // HTTP URL
+                if (isHttpUrl(updateUrlOrPath)) {
+                    this.Log().Info("Downloading RELEASES file from {0}", updateUrlOrPath);
+
+                    try {
+                        var data = await urlDownloader.DownloadUrl(String.Format("{0}/{1}", updateUrlOrPath, "RELEASES"));
+                        releaseFile = Encoding.UTF8.GetString(data);
+                    } catch (WebException ex) {
+                        this.Log().InfoException("Download resulted in WebException (returning blank release list)", ex);
+                        releaseFile = String.Empty;
+                    }
+
+                    progress(33);
+                } else {
+                    this.Log().Info("Reading RELEASES file from {0}", updateUrlOrPath);
+
+                    if (!Directory.Exists(updateUrlOrPath)) {
+                        var message = String.Format(
+                            "The directory {0} does not exist, something is probably broken with your application", 
+                            updateUrlOrPath);
+
+                        throw new Exception(message);
+                    }
+
+                    var fi = new FileInfo(Path.Combine(updateUrlOrPath, "RELEASES"));
+                    if (!fi.Exists) {
+                        var message = String.Format(
+                            "The file {0} does not exist, something is probably broken with your application", 
+                            fi.FullName);
+
+                        this.Log().Warn(message);
+
+                        var packages = (new DirectoryInfo(updateUrlOrPath)).GetFiles("*.nupkg");
+                        if (packages.Length == 0) {
+                            throw new Exception(message);
+                        }
+
+                        // NB: Create a new RELEASES file since we've got a directory of packages
+                        ReleaseEntry.WriteReleaseFile(
+                            packages.Select(x => ReleaseEntry.GenerateFromFile(x.FullName)), fi.FullName);
+                    }
+
+                    releaseFile = File.ReadAllText(fi.FullName, Encoding.UTF8);
+                    progress(33);
+                }
+
+                var ret = default(UpdateInfo);
+                var remoteReleases = ReleaseEntry.ParseReleaseFile(releaseFile);
+                progress(66);
+
+                if (!remoteReleases.IsEmpty()) {
+                    ret = determineUpdateInfo(localReleases, remoteReleases, ignoreDeltaUpdates);
+                }
+
+                progress(100);
+                return ret;
+            }
+        }
+
+        async Task initializeClientAppDirectory()
+        {
+            // On bootstrap, we won't have any of our directories, create them
+            var pkgDir = Path.Combine(rootAppDirectory, "packages");
+            if (Directory.Exists(pkgDir)) {
+                await Utility.DeleteDirectory(pkgDir);
+            }
+
+            Directory.CreateDirectory(pkgDir);
+        }
+
+        UpdateInfo determineUpdateInfo(IEnumerable<ReleaseEntry> localReleases, IEnumerable<ReleaseEntry> remoteReleases, bool ignoreDeltaUpdates)
+        {
+            localReleases = localReleases ?? Enumerable.Empty<ReleaseEntry>();
+
+            if (remoteReleases == null) {
+                this.Log().Warn("Release information couldn't be determined due to remote corrupt RELEASES file");
+                throw new Exception("Corrupt remote RELEASES file");
+            }
+
+            if (localReleases.Count() == remoteReleases.Count()) {
+                this.Log().Info("No updates, remote and local are the same");
+
+                var latestFullRelease = findCurrentVersion(remoteReleases);
+                var currentRelease = findCurrentVersion(localReleases);
+
+                var info = UpdateInfo.Create(currentRelease, new[] {latestFullRelease}, PackageDirectory,appFrameworkVersion);
+                return info;
+            }
+
+            if (ignoreDeltaUpdates) {
+                remoteReleases = remoteReleases.Where(x => !x.IsDelta);
+            }
+
+            if (!localReleases.Any()) {
+                this.Log().Warn("First run or local directory is corrupt, starting from scratch");
+
+                var latestFullRelease = findCurrentVersion(remoteReleases);
+                return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, PackageDirectory, appFrameworkVersion);
+            }
+
+            if (localReleases.Max(x => x.Version) > remoteReleases.Max(x => x.Version)) {
+                this.Log().Warn("hwhat, local version is greater than remote version");
+
+                var latestFullRelease = findCurrentVersion(remoteReleases);
+                return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, PackageDirectory, appFrameworkVersion);
+            }
+
+            return UpdateInfo.Create(findCurrentVersion(localReleases), remoteReleases, PackageDirectory, appFrameworkVersion);
+        }
+
+        static ReleaseEntry findCurrentVersion(IEnumerable<ReleaseEntry> localReleases)
+        {
+            if (!localReleases.Any()) {
+                return null;
+            }
+
+            return localReleases.MaxBy(x => x.Version).SingleOrDefault(x => !x.IsDelta);
+        }
+    }
+}
diff --git a/src/Squirrel/UpdateManager.DownloadReleases.cs b/src/Squirrel/UpdateManager.DownloadReleases.cs
new file mode 100644
index 00000000..01f9b899
--- /dev/null
+++ b/src/Squirrel/UpdateManager.DownloadReleases.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Splat;
+
+namespace Squirrel
+{
+    public sealed partial class UpdateManager
+    {
+		class DownloadReleases : IEnableLogger
+        {
+			public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
+			{
+				progress = progress ?? (_ => { });
+				int current = 0;
+				int toIncrement = (int)(100.0 / releasesToDownload.Count());
+
+                if (isHttpUrl(updateUrlOrPath)) {
+					await releasesToDownload.ForEachAsync(async x => {
+						await urlDownloader.DownloadFile(
+							String.Format("{0}/{1}", updateUrlOrPath, x.Filename),
+							Path.Combine(rootAppDirectory, "packages", x.Filename));
+						lock (progress) progress(current += toIncrement);
+					});
+				} else {
+					await releasesToDownload.ForEachAsync(x => {
+						File.Copy(
+							Path.Combine(updateUrlOrPath, x.Filename),
+							Path.Combine(rootAppDirectory, "packages", x.Filename));
+						lock (progress) progress(current += toIncrement);
+					});
+				}
+			}
+        
+			static bool isHttpUrl(string urlOrPath)
+			{
+				try {
+					var url = new Uri(urlOrPath);
+					return new[] {"https", "http"}.Contains(url.Scheme.ToLowerInvariant());
+				} catch (Exception) {
+					return false;
+				}
+			}
+
+			Task checksumAllPackages(IEnumerable<ReleaseEntry> releasesDownloaded)
+			{
+				return releasesDownloaded.ForEachAsync(x => checksumPackage(x));
+			}
+
+			void checksumPackage(ReleaseEntry downloadedRelease)
+			{
+				var targetPackage = new FileInfo(
+					Path.Combine(rootAppDirectory, "packages", downloadedRelease.Filename));
+
+				if (!targetPackage.Exists) {
+					this.Log().Error("File {0} should exist but doesn't", targetPackage.FullName);
+
+					throw new Exception("Checksummed file doesn't exist: " + targetPackage.FullName);
+				}
+
+				if (targetPackage.Length != downloadedRelease.Filesize) {
+					this.Log().Error("File Length should be {0}, is {1}", downloadedRelease.Filesize, targetPackage.Length);
+					targetPackage.Delete();
+
+					throw new Exception("Checksummed file size doesn't match: " + targetPackage.FullName);
+				}
+
+				using (var file = targetPackage.OpenRead()) {
+					var hash = Utility.CalculateStreamSHA1(file);
+
+					if (!hash.Equals(downloadedRelease.SHA1,StringComparison.OrdinalIgnoreCase)) {
+						this.Log().Error("File SHA1 should be {0}, is {1}", downloadedRelease.SHA1, hash);
+						targetPackage.Delete();
+						throw new Exception("Checksum doesn't match: " + targetPackage.FullName);
+					}
+				}
+			}
+        }
+    }
+}
diff --git a/src/Squirrel/UpdateManager.cs b/src/Squirrel/UpdateManager.cs
index 0853fbce..aedb3a79 100644
--- a/src/Squirrel/UpdateManager.cs
+++ b/src/Squirrel/UpdateManager.cs
@@ -13,7 +13,7 @@ using Splat;
 
 namespace Squirrel
 {
-    public sealed class UpdateManager : IUpdateManager, IEnableLogger
+    public sealed partial class UpdateManager : IUpdateManager, IEnableLogger
     {
         readonly string rootAppDirectory;
         readonly string applicationName;
@@ -49,140 +49,6 @@ namespace Squirrel
             get { return Path.Combine(PackageDirectory, "RELEASES"); }
         }
 
-        public async Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates = false, Action<int> progress = null)
-        {
-            progress = progress ?? (_ => { });
-            await acquireUpdateLock();
-
-            var localReleases = Enumerable.Empty<ReleaseEntry>();
-
-            bool shouldInitialize = false;
-            try {
-                var file = File.OpenRead(LocalReleaseFile);
-
-                // NB: sr disposes file
-                using (var sr = new StreamReader(file, Encoding.UTF8)) {
-                    localReleases = ReleaseEntry.ParseReleaseFile(sr.ReadToEnd());
-                }
-            } catch (Exception ex) {
-                // Something has gone wrong, we'll start from scratch.
-                this.Log().WarnException("Failed to load local release list", ex);
-                shouldInitialize = true;
-            }
-
-            if (shouldInitialize) await initializeClientAppDirectory();
-
-            string releaseFile;
-
-            // Fetch the remote RELEASES file, whether it's a local dir or an 
-            // HTTP URL
-            if (isHttpUrl(updateUrlOrPath)) {
-                this.Log().Info("Downloading RELEASES file from {0}", updateUrlOrPath);
-
-                try {
-                    var data = await urlDownloader.DownloadUrl(String.Format("{0}/{1}", updateUrlOrPath, "RELEASES"));
-                    releaseFile = Encoding.UTF8.GetString(data);
-                } catch (WebException ex) {
-                    this.Log().InfoException("Download resulted in WebException (returning blank release list)", ex);
-                    releaseFile = String.Empty;
-                }
-
-                progress(33);
-            } else {
-                this.Log().Info("Reading RELEASES file from {0}", updateUrlOrPath);
-
-                if (!Directory.Exists(updateUrlOrPath)) {
-                    var message = String.Format(
-                        "The directory {0} does not exist, something is probably broken with your application", 
-                        updateUrlOrPath);
-
-                    throw new Exception(message);
-                }
-
-                var fi = new FileInfo(Path.Combine(updateUrlOrPath, "RELEASES"));
-                if (!fi.Exists) {
-                    var message = String.Format(
-                        "The file {0} does not exist, something is probably broken with your application", 
-                        fi.FullName);
-
-                    this.Log().Warn(message);
-
-                    var packages = (new DirectoryInfo(updateUrlOrPath)).GetFiles("*.nupkg");
-                    if (packages.Length == 0) {
-                        throw new Exception(message);
-                    }
-
-                    // NB: Create a new RELEASES file since we've got a directory of packages
-                    ReleaseEntry.WriteReleaseFile(
-                        packages.Select(x => ReleaseEntry.GenerateFromFile(x.FullName)), fi.FullName);
-                }
-
-                releaseFile = File.ReadAllText(fi.FullName, Encoding.UTF8);
-                progress(33);
-            }
-
-            var ret = default(UpdateInfo);
-            var remoteReleases = ReleaseEntry.ParseReleaseFile(releaseFile);
-            progress(66);
-
-            if (!remoteReleases.IsEmpty()) {
-                ret = determineUpdateInfo(localReleases, remoteReleases, ignoreDeltaUpdates);
-            }
-
-            progress(100);
-            return ret;
-        }
-
-        public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
-        {
-            progress = progress ?? (_ => { });
-            int current = 0;
-            int toIncrement = (int)(100.0 / releasesToDownload.Count());
-
-            await acquireUpdateLock();
-
-            if (isHttpUrl(updateUrlOrPath)) {
-                await releasesToDownload.ForEachAsync(async x => {
-                    await urlDownloader.DownloadFile(
-                        String.Format("{0}/{1}", updateUrlOrPath, x.Filename),
-                        Path.Combine(rootAppDirectory, "packages", x.Filename));
-                    lock (progress) progress(current += toIncrement);
-                });
-            } else {
-                await releasesToDownload.ForEachAsync(x => {
-                    File.Copy(
-                        Path.Combine(updateUrlOrPath, x.Filename),
-                        Path.Combine(rootAppDirectory, "packages", x.Filename));
-                    lock (progress) progress(current += toIncrement);
-                });
-            }
-        }
-
-        public async Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
-        {
-            progress = progress ?? (_ => { });
-
-            await acquireUpdateLock();
-
-            await cleanDeadVersions(updateInfo.CurrentlyInstalledVersion != null ? updateInfo.CurrentlyInstalledVersion.Version : null);
-            progress(10);
-
-            var release = await createFullPackagesFromDeltas(updateInfo.ReleasesToApply, updateInfo.CurrentlyInstalledVersion);
-            progress(50);
-
-            await installPackageToAppDir(updateInfo, release);
-            progress(95);
-
-            await UpdateLocalReleasesFile();
-            progress(100);
-        }
-
-        public async Task UpdateLocalReleasesFile()
-        {
-            await acquireUpdateLock();
-            await Task.Run(() => ReleaseEntry.BuildReleasesFile(PackageDirectory));
-        }
-
         public async Task FullUninstall(Version version = null)
         {
             version = version ?? new Version(255, 255, 255, 255);
@@ -289,371 +155,5 @@ namespace Squirrel
                 Utility.DeleteDirectoryAtNextReboot(dir);
             }
         }
-
-
-        //
-        // CheckForUpdate methods
-        //
-
-        async Task initializeClientAppDirectory()
-        {
-            // On bootstrap, we won't have any of our directories, create them
-            var pkgDir = Path.Combine(rootAppDirectory, "packages");
-            if (Directory.Exists(pkgDir)) {
-                await Utility.DeleteDirectory(pkgDir);
-            }
-
-            Directory.CreateDirectory(pkgDir);
-        }
-
-        UpdateInfo determineUpdateInfo(IEnumerable<ReleaseEntry> localReleases, IEnumerable<ReleaseEntry> remoteReleases, bool ignoreDeltaUpdates)
-        {
-            localReleases = localReleases ?? Enumerable.Empty<ReleaseEntry>();
-
-            if (remoteReleases == null) {
-                this.Log().Warn("Release information couldn't be determined due to remote corrupt RELEASES file");
-                throw new Exception("Corrupt remote RELEASES file");
-            }
-
-            if (localReleases.Count() == remoteReleases.Count()) {
-                this.Log().Info("No updates, remote and local are the same");
-
-                var latestFullRelease = findCurrentVersion(remoteReleases);
-                var currentRelease = findCurrentVersion(localReleases);
-
-                var info = UpdateInfo.Create(currentRelease, new[] {latestFullRelease}, PackageDirectory,appFrameworkVersion);
-                return info;
-            }
-
-            if (ignoreDeltaUpdates) {
-                remoteReleases = remoteReleases.Where(x => !x.IsDelta);
-            }
-
-            if (!localReleases.Any()) {
-                this.Log().Warn("First run or local directory is corrupt, starting from scratch");
-
-                var latestFullRelease = findCurrentVersion(remoteReleases);
-                return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, PackageDirectory, appFrameworkVersion);
-            }
-
-            if (localReleases.Max(x => x.Version) > remoteReleases.Max(x => x.Version)) {
-                this.Log().Warn("hwhat, local version is greater than remote version");
-
-                var latestFullRelease = findCurrentVersion(remoteReleases);
-                return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, PackageDirectory, appFrameworkVersion);
-            }
-
-            return UpdateInfo.Create(findCurrentVersion(localReleases), remoteReleases, PackageDirectory, appFrameworkVersion);
-        }
-
-        static ReleaseEntry findCurrentVersion(IEnumerable<ReleaseEntry> localReleases)
-        {
-            if (!localReleases.Any()) {
-                return null;
-            }
-
-            return localReleases.MaxBy(x => x.Version).SingleOrDefault(x => !x.IsDelta);
-        }
-
-
-        //
-        // DownloadReleases methods
-        //
-        
-        static bool isHttpUrl(string urlOrPath)
-        {
-            try {
-                var url = new Uri(urlOrPath);
-                return new[] {"https", "http"}.Contains(url.Scheme.ToLowerInvariant());
-            } catch (Exception) {
-                return false;
-            }
-        }
-
-        Task checksumAllPackages(IEnumerable<ReleaseEntry> releasesDownloaded)
-        {
-            return releasesDownloaded.ForEachAsync(x => checksumPackage(x));
-        }
-
-        void checksumPackage(ReleaseEntry downloadedRelease)
-        {
-            var targetPackage = new FileInfo(
-                Path.Combine(rootAppDirectory, "packages", downloadedRelease.Filename));
-
-            if (!targetPackage.Exists) {
-                this.Log().Error("File {0} should exist but doesn't", targetPackage.FullName);
-
-                throw new Exception("Checksummed file doesn't exist: " + targetPackage.FullName);
-            }
-
-            if (targetPackage.Length != downloadedRelease.Filesize) {
-                this.Log().Error("File Length should be {0}, is {1}", downloadedRelease.Filesize, targetPackage.Length);
-                targetPackage.Delete();
-
-                throw new Exception("Checksummed file size doesn't match: " + targetPackage.FullName);
-            }
-
-            using (var file = targetPackage.OpenRead()) {
-                var hash = Utility.CalculateStreamSHA1(file);
-
-                if (!hash.Equals(downloadedRelease.SHA1,StringComparison.OrdinalIgnoreCase)) {
-                    this.Log().Error("File SHA1 should be {0}, is {1}", downloadedRelease.SHA1, hash);
-                    targetPackage.Delete();
-                    throw new Exception("Checksum doesn't match: " + targetPackage.FullName);
-                }
-            }
-        }
-
-        //
-        // ApplyReleases methods
-        //
-
-        async Task installPackageToAppDir(UpdateInfo updateInfo, ReleaseEntry release)
-        {
-            var pkg = new ZipPackage(Path.Combine(updateInfo.PackageDirectory, release.Filename));
-            var target = getDirectoryForRelease(release.Version);
-
-            // NB: This might happen if we got killed partially through applying the release
-            if (target.Exists) {
-                await Utility.DeleteDirectory(target.FullName);
-            }
-
-            target.Create();
-
-            // Copy all of the files out of the lib/ dirs in the NuGet package
-            // into our target App directory.
-            //
-            // NB: We sort this list in order to guarantee that if a Net20
-            // and a Net40 version of a DLL get shipped, we always end up
-            // with the 4.0 version.
-            this.Log().Info("Writing files to app directory: {0}", target.FullName);
-
-            var toWrite = pkg.GetLibFiles().Where(x => pathIsInFrameworkProfile(x, appFrameworkVersion))
-                .OrderBy(x => x.Path)
-                .ToList();
-
-            // NB: Because of the above NB, we cannot use ForEachAsync here, we 
-            // have to copy these files in-order. Once we fix assembly resolution, 
-            // we can kill both of these NBs.
-            await Task.Run(() => toWrite.ForEach(x => CopyFileToLocation(target, x)));
-
-            await pkg.GetContentFiles().ForEachAsync(x => CopyFileToLocation(target, x));
-
-            var newCurrentVersion = updateInfo.FutureReleaseEntry.Version;
-
-            // Perform post-install; clean up the previous version by asking it
-            // which shortcuts to install, and nuking them. Then, run the app's
-            // post install and set up shortcuts.
-            runPostInstallAndCleanup(newCurrentVersion, updateInfo.IsBootstrapping);
-        }
-
-        void CopyFileToLocation(FileSystemInfo target, IPackageFile x)
-        {
-            var targetPath = Path.Combine(target.FullName, x.EffectivePath);
-
-            var fi = new FileInfo(targetPath);
-            if (fi.Exists) fi.Delete();
-
-            var dir = new DirectoryInfo(Path.GetDirectoryName(targetPath));
-            if (!dir.Exists) dir.Create();
-
-            using (var inf = x.GetStream())
-            using (var of = fi.Open(FileMode.CreateNew, FileAccess.Write)) {
-                inf.CopyTo(of);
-            }
-        }
-
-        void runPostInstallAndCleanup(Version newCurrentVersion, bool isBootstrapping)
-        {
-            fixPinnedExecutables(newCurrentVersion);
-
-            this.Log().Info("runPostInstallAndCleanup: finished fixPinnedExecutables");
-            cleanUpOldVersions(newCurrentVersion);
-        }
-
-        static bool pathIsInFrameworkProfile(IPackageFile packageFile, FrameworkVersion appFrameworkVersion)
-        {
-            if (!packageFile.Path.StartsWith("lib", StringComparison.InvariantCultureIgnoreCase)) {
-                return false;
-            }
-
-            if (appFrameworkVersion == FrameworkVersion.Net40
-                && packageFile.Path.StartsWith("lib\\net45", StringComparison.InvariantCultureIgnoreCase)) {
-                return false;
-            }
-
-            return true;
-        }
-
-        async Task<ReleaseEntry> createFullPackagesFromDeltas(IEnumerable<ReleaseEntry> releasesToApply, ReleaseEntry currentVersion)
-        {
-            Contract.Requires(releasesToApply != null);
-
-            // If there are no deltas in our list, we're already done
-            if (!releasesToApply.Any() || releasesToApply.All(x => !x.IsDelta)) {
-                return releasesToApply.MaxBy(x => x.Version).First();
-            }
-
-            if (!releasesToApply.All(x => x.IsDelta)) {
-                throw new Exception("Cannot apply combinations of delta and full packages");
-            }
-
-            // Smash together our base full package and the nearest delta
-            var ret = await Task.Run(() => {
-                var basePkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", currentVersion.Filename));
-                var deltaPkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", releasesToApply.First().Filename));
-
-                var deltaBuilder = new DeltaPackageBuilder();
-
-                return deltaBuilder.ApplyDeltaPackage(basePkg, deltaPkg,
-                    Regex.Replace(deltaPkg.InputPackageFile, @"-delta.nupkg$", ".nupkg", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant));
-            });
-
-            if (releasesToApply.Count() == 1) {
-                return ReleaseEntry.GenerateFromFile(ret.InputPackageFile);
-            }
-
-            var fi = new FileInfo(ret.InputPackageFile);
-            var entry = ReleaseEntry.GenerateFromFile(fi.OpenRead(), fi.Name);
-
-            // Recursively combine the rest of them
-            return await createFullPackagesFromDeltas(releasesToApply.Skip(1), entry);
-        }
-
-        void cleanUpOldVersions(Version newCurrentVersion)
-        {
-            var directory = new DirectoryInfo(rootAppDirectory);
-            if (!directory.Exists) {
-                this.Log().Warn("cleanUpOldVersions: the directory '{0}' does not exist", rootAppDirectory);
-                return;
-            }
-            
-            foreach (var v in getOldReleases(newCurrentVersion)) {
-                Utility.DeleteDirectoryAtNextReboot(v.FullName);
-            }
-        }
-
-        void fixPinnedExecutables(Version newCurrentVersion) 
-        {
-            if (Environment.OSVersion.Version < new Version(6, 1)) {
-                this.Log().Warn("fixPinnedExecutables: Found OS Version '{0}', exiting...", Environment.OSVersion.VersionString);
-                return;
-            }
-
-            var newCurrentFolder = "app-" + newCurrentVersion;
-            var oldAppDirectories = (new DirectoryInfo(rootAppDirectory)).GetDirectories()
-                .Where(x => x.Name.StartsWith("app-", StringComparison.InvariantCultureIgnoreCase))
-                .Where(x => x.Name != newCurrentFolder)
-                .Select(x => x.FullName)
-                .ToArray();
-
-            if (!oldAppDirectories.Any()) {
-                this.Log().Info("fixPinnedExecutables: oldAppDirectories is empty, this is pointless");
-                return;
-            }
-
-            var newAppPath = Path.Combine(rootAppDirectory, newCurrentFolder);
-
-            var taskbarPath = Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
-                "Microsoft\\Internet Explorer\\Quick Launch\\User Pinned\\TaskBar");
-
-            Func<FileInfo, ShellLink> resolveLink = file => {
-                try {
-                    return new ShellLink(file.FullName);
-                } catch (Exception ex) {
-                    var message = String.Format("File '{0}' could not be converted into a valid ShellLink", file.FullName);
-                    this.Log().WarnException(message, ex);
-                    return null;
-                }
-            };
-
-            var shellLinks = (new DirectoryInfo(taskbarPath)).GetFiles("*.lnk")
-                .Select(resolveLink)
-                .Where(x => x != null)
-                .ToArray();
-
-            foreach (var shortcut in shellLinks) {
-                try {
-                    updateLink(shortcut, oldAppDirectories, newAppPath);
-                } catch (Exception ex) {
-                    var message = String.Format("fixPinnedExecutables: shortcut failed: {0}", shortcut.Target);
-                    this.Log().ErrorException(message, ex);
-                }
-            }
-        }
-
-        void updateLink(ShellLink shortcut, string[] oldAppDirectories, string newAppPath)
-        {
-            this.Log().Info("Processing shortcut '{0}'", shortcut.Target);
-
-            foreach (var oldAppDirectory in oldAppDirectories) {
-                if (!shortcut.Target.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
-                    this.Log().Info("Does not match '{0}', continuing to next directory", oldAppDirectory);
-                    continue;
-                }
-
-                // replace old app path with new app path and check, if executable still exists
-                var newTarget = Path.Combine(newAppPath, shortcut.Target.Substring(oldAppDirectory.Length + 1));
-
-                if (File.Exists(newTarget)) {
-                    shortcut.Target = newTarget;
-
-                    // replace working directory too if appropriate
-                    if (shortcut.WorkingDirectory.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
-                        this.Log().Info("Changing new directory to '{0}'", newAppPath);
-                        shortcut.WorkingDirectory = Path.Combine(newAppPath,
-                            shortcut.WorkingDirectory.Substring(oldAppDirectory.Length + 1));
-                    }
-
-                    shortcut.Save();
-                }
-                else {
-                    this.Log().Info("Unpinning {0} from taskbar", shortcut.Target);
-                    TaskbarHelper.UnpinFromTaskbar(shortcut.Target);
-                }
-
-                break;
-            }
-        }
-
-        // NB: Once we uninstall the old version of the app, we try to schedule
-        // it to be deleted at next reboot. Unfortunately, depending on whether
-        // the user has admin permissions, this can fail. So as a failsafe,
-        // before we try to apply any update, we assume previous versions in the
-        // directory are "dead" (i.e. already uninstalled, but not deleted), and
-        // we blow them away. This is to make sure that we don't attempt to run
-        // an uninstaller on an already-uninstalled version.
-        async Task cleanDeadVersions(Version currentVersion)
-        {
-            if (currentVersion == null) return;
-
-            var di = new DirectoryInfo(rootAppDirectory);
-            if (!di.Exists) return;
-
-            this.Log().Info("cleanDeadVersions: for version {0}", currentVersion);
-
-            string currentVersionFolder = null;
-            if (currentVersion != null) {
-                currentVersionFolder = getDirectoryForRelease(currentVersion).Name;
-                this.Log().Info("cleanDeadVersions: exclude folder {0}", currentVersionFolder);
-            }
-
-            // NB: If we try to access a directory that has already been 
-            // scheduled for deletion by MoveFileEx it throws what seems like
-            // NT's only error code, ERROR_ACCESS_DENIED. Squelch errors that
-            // come from here.
-            var toCleanup = di.GetDirectories()
-                .Where(x => x.Name.ToLowerInvariant().Contains("app-"))
-                .Where(x => x.Name != currentVersionFolder);
-
-            await toCleanup.ForEachAsync(async x => {
-                try {
-                    await Utility.DeleteDirectory(x.FullName);
-                } catch (UnauthorizedAccessException ex) {
-                    this.Log().WarnException("Couldn't delete directory: " + x.FullName, ex);
-                }
-            });
-        }
     }
 }

From 0501ed8f93428a5695852ed6e89bdbdc2db90f30 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Wed, 6 Aug 2014 17:21:51 +0200
Subject: [PATCH 02/11] Get CheckForUpdates into its own inner class

---
 src/Squirrel/IUpdateManager.cs                |   6 +
 src/Squirrel/UpdateManager.CheckForUpdates.cs | 127 ++++++++++--------
 .../UpdateManager.DownloadReleases.cs         |  12 +-
 src/Squirrel/UpdateManager.cs                 |  51 ++++---
 src/Squirrel/Utility.cs                       |  34 ++++-
 5 files changed, 136 insertions(+), 94 deletions(-)

diff --git a/src/Squirrel/IUpdateManager.cs b/src/Squirrel/IUpdateManager.cs
index da735c50..e7878ac6 100644
--- a/src/Squirrel/IUpdateManager.cs
+++ b/src/Squirrel/IUpdateManager.cs
@@ -43,6 +43,12 @@ namespace Squirrel
         /// <param name="progress">A Observer which can be used to report Progress - 
         /// will return values from 0-100 and Complete, or Throw</param>
         Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null);
+
+        /// <summary>
+        /// Completely uninstalls the targeted app
+        /// </summary>
+        /// <returns>Completion</returns>
+        async Task FullUninstall();
     }
 
     public static class EasyModeMixin
diff --git a/src/Squirrel/UpdateManager.CheckForUpdates.cs b/src/Squirrel/UpdateManager.CheckForUpdates.cs
index 1e761569..b18128f7 100644
--- a/src/Squirrel/UpdateManager.CheckForUpdates.cs
+++ b/src/Squirrel/UpdateManager.CheckForUpdates.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Net;
 using System.Text;
 using System.Threading.Tasks;
 using Splat;
@@ -12,7 +13,22 @@ namespace Squirrel
     {
         class CheckForUpdates : IEnableLogger
         {
-            public async Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates = false, Action<int> progress = null)
+            readonly string rootAppDirectory;
+
+            // TODO: rip this out
+            readonly FrameworkVersion appFrameworkVersion = FrameworkVersion.Net45;
+
+            public CheckForUpdates(string rootAppDirectory)
+            {
+                this.rootAppDirectory = rootAppDirectory;
+            }
+
+            public async Task<UpdateInfo> CheckForUpdate(
+                string localReleaseFile,
+                string updateUrlOrPath,
+                bool ignoreDeltaUpdates = false, 
+                Action<int> progress = null,
+                IFileDownloader urlDownloader = null)
             {
                 progress = progress ?? (_ => { });
 
@@ -20,7 +36,7 @@ namespace Squirrel
 
                 bool shouldInitialize = false;
                 try {
-                    var file = File.OpenRead(LocalReleaseFile);
+                    var file = File.OpenRead(localReleaseFile);
 
                     // NB: sr disposes file
                     using (var sr = new StreamReader(file, Encoding.UTF8)) {
@@ -38,7 +54,7 @@ namespace Squirrel
 
                 // Fetch the remote RELEASES file, whether it's a local dir or an 
                 // HTTP URL
-                if (isHttpUrl(updateUrlOrPath)) {
+                if (Utility.IsHttpUrl(updateUrlOrPath)) {
                     this.Log().Info("Downloading RELEASES file from {0}", updateUrlOrPath);
 
                     try {
@@ -87,73 +103,74 @@ namespace Squirrel
                 var remoteReleases = ReleaseEntry.ParseReleaseFile(releaseFile);
                 progress(66);
 
-                if (!remoteReleases.IsEmpty()) {
+                if (remoteReleases.Any()) {
                     ret = determineUpdateInfo(localReleases, remoteReleases, ignoreDeltaUpdates);
                 }
 
                 progress(100);
                 return ret;
             }
-        }
 
-        async Task initializeClientAppDirectory()
-        {
-            // On bootstrap, we won't have any of our directories, create them
-            var pkgDir = Path.Combine(rootAppDirectory, "packages");
-            if (Directory.Exists(pkgDir)) {
-                await Utility.DeleteDirectory(pkgDir);
+            async Task initializeClientAppDirectory()
+            {
+                // On bootstrap, we won't have any of our directories, create them
+                var pkgDir = Path.Combine(rootAppDirectory, "packages");
+                if (Directory.Exists(pkgDir)) {
+                    await Utility.DeleteDirectory(pkgDir);
+                }
+
+                Directory.CreateDirectory(pkgDir);
             }
 
-            Directory.CreateDirectory(pkgDir);
-        }
+            UpdateInfo determineUpdateInfo(IEnumerable<ReleaseEntry> localReleases, IEnumerable<ReleaseEntry> remoteReleases, bool ignoreDeltaUpdates)
+            {
+                var packageDirectory = Utility.PackageDirectoryForAppDir(rootAppDirectory);
+                localReleases = localReleases ?? Enumerable.Empty<ReleaseEntry>();
 
-        UpdateInfo determineUpdateInfo(IEnumerable<ReleaseEntry> localReleases, IEnumerable<ReleaseEntry> remoteReleases, bool ignoreDeltaUpdates)
-        {
-            localReleases = localReleases ?? Enumerable.Empty<ReleaseEntry>();
+                if (remoteReleases == null) {
+                    this.Log().Warn("Release information couldn't be determined due to remote corrupt RELEASES file");
+                    throw new Exception("Corrupt remote RELEASES file");
+                }
 
-            if (remoteReleases == null) {
-                this.Log().Warn("Release information couldn't be determined due to remote corrupt RELEASES file");
-                throw new Exception("Corrupt remote RELEASES file");
+                if (localReleases.Count() == remoteReleases.Count()) {
+                    this.Log().Info("No updates, remote and local are the same");
+
+                    var latestFullRelease = findCurrentVersion(remoteReleases);
+                    var currentRelease = findCurrentVersion(localReleases);
+
+                    var info = UpdateInfo.Create(currentRelease, new[] {latestFullRelease}, packageDirectory, appFrameworkVersion);
+                    return info;
+                }
+
+                if (ignoreDeltaUpdates) {
+                    remoteReleases = remoteReleases.Where(x => !x.IsDelta);
+                }
+
+                if (!localReleases.Any()) {
+                    this.Log().Warn("First run or local directory is corrupt, starting from scratch");
+
+                    var latestFullRelease = findCurrentVersion(remoteReleases);
+                    return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, packageDirectory, appFrameworkVersion);
+                }
+
+                if (localReleases.Max(x => x.Version) > remoteReleases.Max(x => x.Version)) {
+                    this.Log().Warn("hwhat, local version is greater than remote version");
+
+                    var latestFullRelease = findCurrentVersion(remoteReleases);
+                    return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, packageDirectory, appFrameworkVersion);
+                }
+
+                return UpdateInfo.Create(findCurrentVersion(localReleases), remoteReleases, packageDirectory, appFrameworkVersion);
             }
 
-            if (localReleases.Count() == remoteReleases.Count()) {
-                this.Log().Info("No updates, remote and local are the same");
+            static ReleaseEntry findCurrentVersion(IEnumerable<ReleaseEntry> localReleases)
+            {
+                if (!localReleases.Any()) {
+                    return null;
+                }
 
-                var latestFullRelease = findCurrentVersion(remoteReleases);
-                var currentRelease = findCurrentVersion(localReleases);
-
-                var info = UpdateInfo.Create(currentRelease, new[] {latestFullRelease}, PackageDirectory,appFrameworkVersion);
-                return info;
+                return localReleases.MaxBy(x => x.Version).SingleOrDefault(x => !x.IsDelta);
             }
-
-            if (ignoreDeltaUpdates) {
-                remoteReleases = remoteReleases.Where(x => !x.IsDelta);
-            }
-
-            if (!localReleases.Any()) {
-                this.Log().Warn("First run or local directory is corrupt, starting from scratch");
-
-                var latestFullRelease = findCurrentVersion(remoteReleases);
-                return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, PackageDirectory, appFrameworkVersion);
-            }
-
-            if (localReleases.Max(x => x.Version) > remoteReleases.Max(x => x.Version)) {
-                this.Log().Warn("hwhat, local version is greater than remote version");
-
-                var latestFullRelease = findCurrentVersion(remoteReleases);
-                return UpdateInfo.Create(findCurrentVersion(localReleases), new[] {latestFullRelease}, PackageDirectory, appFrameworkVersion);
-            }
-
-            return UpdateInfo.Create(findCurrentVersion(localReleases), remoteReleases, PackageDirectory, appFrameworkVersion);
-        }
-
-        static ReleaseEntry findCurrentVersion(IEnumerable<ReleaseEntry> localReleases)
-        {
-            if (!localReleases.Any()) {
-                return null;
-            }
-
-            return localReleases.MaxBy(x => x.Version).SingleOrDefault(x => !x.IsDelta);
         }
     }
 }
diff --git a/src/Squirrel/UpdateManager.DownloadReleases.cs b/src/Squirrel/UpdateManager.DownloadReleases.cs
index 01f9b899..25db65e4 100644
--- a/src/Squirrel/UpdateManager.DownloadReleases.cs
+++ b/src/Squirrel/UpdateManager.DownloadReleases.cs
@@ -9,7 +9,7 @@ namespace Squirrel
 {
     public sealed partial class UpdateManager
     {
-		class DownloadReleases : IEnableLogger
+        class DownloadReleases : IEnableLogger
         {
 			public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
 			{
@@ -33,16 +33,6 @@ namespace Squirrel
 					});
 				}
 			}
-        
-			static bool isHttpUrl(string urlOrPath)
-			{
-				try {
-					var url = new Uri(urlOrPath);
-					return new[] {"https", "http"}.Contains(url.Scheme.ToLowerInvariant());
-				} catch (Exception) {
-					return false;
-				}
-			}
 
 			Task checksumAllPackages(IEnumerable<ReleaseEntry> releasesDownloaded)
 			{
diff --git a/src/Squirrel/UpdateManager.cs b/src/Squirrel/UpdateManager.cs
index aedb3a79..092339ec 100644
--- a/src/Squirrel/UpdateManager.cs
+++ b/src/Squirrel/UpdateManager.cs
@@ -41,21 +41,26 @@ namespace Squirrel
             this.urlDownloader = urlDownloader ?? new FileDownloader();
         }
 
-        public string PackageDirectory {
-            get { return Path.Combine(rootAppDirectory, "packages"); }
-        }
-
-        public string LocalReleaseFile {
-            get { return Path.Combine(PackageDirectory, "RELEASES"); }
-        }
-
-        public async Task FullUninstall(Version version = null)
+        public Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates, Action<int> progress = null)
         {
-            version = version ?? new Version(255, 255, 255, 255);
-            this.Log().Info("Uninstalling version '{0}'", version);
+            var checkForUpdate = new CheckForUpdates(rootAppDirectory);
+            return checkForUpdate.CheckForUpdate(Utility.LocalReleaseFileForAppDir(rootAppDirectory), updateUrlOrPath, ignoreDeltaUpdates, progress, urlDownloader);
+        }
 
+        public Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
+        {
+            throw new NotImplementedException();
+        }
+
+        public async Task FullUninstall()
+        {
             await acquireUpdateLock();
-            await fullUninstall(version);
+            await fullUninstall();
         }
 
         IEnumerable<DirectoryInfo> getReleases()
@@ -75,18 +80,22 @@ namespace Squirrel
                 .ToArray();
         }
 
-        async Task fullUninstall(Version version)
+        async Task fullUninstall(Version version = null)
         {
+            version = version ?? new Version(255, 255, 255, 255);
+            this.Log().Info("Uninstalling version '{0}'", version);
+
+
             // find all the old releases (and this one)
             var directoriesToDelete = getOldReleases(version)
                 .Concat(new [] { getDirectoryForRelease(version) })
                 .Where(d => d.Exists)
                 .Select(d => d.FullName);
 
-            await directoriesToDelete.ForEachAsync(x => deleteDirectoryWithFallbackToNextReboot(x));
+            await directoriesToDelete.ForEachAsync(x => Utility.DeleteDirectoryWithFallbackToNextReboot(x));
 
             if (!getReleases().Any()) {
-                await deleteDirectoryWithFallbackToNextReboot(rootAppDirectory);
+                await Utility.DeleteDirectoryWithFallbackToNextReboot(rootAppDirectory);
             }
         }
 
@@ -143,17 +152,5 @@ namespace Squirrel
         {
             return new DirectoryInfo(Path.Combine(rootAppDirectory, "app-" + releaseVersion));
         }
-
-        async Task deleteDirectoryWithFallbackToNextReboot(string dir)
-        {
-            try {
-                await Utility.DeleteDirectory(dir);
-            } catch (UnauthorizedAccessException ex) {
-                var message = String.Format("Uninstall failed to delete dir '{0}', punting to next reboot", dir);
-                this.Log().WarnException(message, ex);
-
-                Utility.DeleteDirectoryAtNextReboot(dir);
-            }
-        }
     }
 }
diff --git a/src/Squirrel/Utility.cs b/src/Squirrel/Utility.cs
index 372206f5..89c074ad 100644
--- a/src/Squirrel/Utility.cs
+++ b/src/Squirrel/Utility.cs
@@ -17,7 +17,7 @@ using System.Collections.Concurrent;
 
 namespace Squirrel
 {
-    public static class Utility
+    static class Utility
     {
         public static IEnumerable<FileInfo> GetAllFilesRecursively(this DirectoryInfo rootPath)
         {
@@ -201,6 +201,16 @@ namespace Squirrel
             return Tuple.Create(path, (Stream) File.OpenWrite(path));
         }
 
+        public static string PackageDirectoryForAppDir(string rootAppDirectory) 
+        {
+            return Path.Combine(rootAppDirectory, "packages");
+        }
+
+        public static string LocalReleaseFileForAppDir(string rootAppDirectory)
+        {
+            return Path.Combine(PackageDirectoryForAppDir(rootAppDirectory), "RELEASES");
+        }
+
         static TAcc scan<T, TAcc>(this IEnumerable<T> This, TAcc initialValue, Func<TAcc, T, TAcc> accFunc)
         {
             TAcc acc = initialValue;
@@ -213,6 +223,28 @@ namespace Squirrel
             return acc;
         }
 
+        public static bool IsHttpUrl(string urlOrPath)
+        {
+            try {
+                var url = new Uri(urlOrPath);
+                return new[] {"https", "http"}.Contains(url.Scheme.ToLowerInvariant());
+            } catch (Exception) {
+                return false;
+            }
+        }
+
+        public static async Task DeleteDirectoryWithFallbackToNextReboot(string dir)
+        {
+            try {
+                await Utility.DeleteDirectory(dir);
+            } catch (UnauthorizedAccessException ex) {
+                var message = String.Format("Uninstall failed to delete dir '{0}', punting to next reboot", dir);
+                LogHost.Default.WarnException(message, ex);
+
+                Utility.DeleteDirectoryAtNextReboot(dir);
+            }
+        }
+
         public static void DeleteDirectoryAtNextReboot(string directoryPath)
         {
             var di = new DirectoryInfo(directoryPath);

From 2ec9192ef9f32344f3ddbd3b9c82c155fcc9d928 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Wed, 6 Aug 2014 17:30:15 +0200
Subject: [PATCH 03/11] Hard tabs? How did you get here?

---
 src/Squirrel/UpdateManager.ApplyReleases.cs   | 426 +++++++++---------
 .../UpdateManager.DownloadReleases.cs         |  92 ++--
 2 files changed, 259 insertions(+), 259 deletions(-)

diff --git a/src/Squirrel/UpdateManager.ApplyReleases.cs b/src/Squirrel/UpdateManager.ApplyReleases.cs
index a346f101..00f43ec1 100644
--- a/src/Squirrel/UpdateManager.ApplyReleases.cs
+++ b/src/Squirrel/UpdateManager.ApplyReleases.cs
@@ -11,275 +11,275 @@ namespace Squirrel
     {
         class ApplyReleases : IEnableLogger
         {
-			public async Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
-			{
-				progress = progress ?? (_ => { });
+            public async Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
+            {
+                progress = progress ?? (_ => { });
 
                 await cleanDeadVersions(updateInfo.CurrentlyInstalledVersion != null ? updateInfo.CurrentlyInstalledVersion.Version : null);
-				progress(10);
+                progress(10);
 
-				var release = await createFullPackagesFromDeltas(updateInfo.ReleasesToApply, updateInfo.CurrentlyInstalledVersion);
-				progress(50);
+                var release = await createFullPackagesFromDeltas(updateInfo.ReleasesToApply, updateInfo.CurrentlyInstalledVersion);
+                progress(50);
 
-				await installPackageToAppDir(updateInfo, release);
-				progress(95);
+                await installPackageToAppDir(updateInfo, release);
+                progress(95);
 
                 await updateLocalReleasesFile();
-				progress(100);
-			}
+                progress(100);
+            }
 
-			async Task installPackageToAppDir(UpdateInfo updateInfo, ReleaseEntry release)
-			{
-				var pkg = new ZipPackage(Path.Combine(updateInfo.PackageDirectory, release.Filename));
-				var target = getDirectoryForRelease(release.Version);
+            async Task installPackageToAppDir(UpdateInfo updateInfo, ReleaseEntry release)
+            {
+                var pkg = new ZipPackage(Path.Combine(updateInfo.PackageDirectory, release.Filename));
+                var target = getDirectoryForRelease(release.Version);
 
-				// NB: This might happen if we got killed partially through applying the release
-				if (target.Exists) {
-					await Utility.DeleteDirectory(target.FullName);
-				}
+                // NB: This might happen if we got killed partially through applying the release
+                if (target.Exists) {
+                    await Utility.DeleteDirectory(target.FullName);
+                }
 
-				target.Create();
+                target.Create();
 
-				// Copy all of the files out of the lib/ dirs in the NuGet package
-				// into our target App directory.
-				//
-				// NB: We sort this list in order to guarantee that if a Net20
-				// and a Net40 version of a DLL get shipped, we always end up
-				// with the 4.0 version.
-				this.Log().Info("Writing files to app directory: {0}", target.FullName);
+                // Copy all of the files out of the lib/ dirs in the NuGet package
+                // into our target App directory.
+                //
+                // NB: We sort this list in order to guarantee that if a Net20
+                // and a Net40 version of a DLL get shipped, we always end up
+                // with the 4.0 version.
+                this.Log().Info("Writing files to app directory: {0}", target.FullName);
 
-				var toWrite = pkg.GetLibFiles().Where(x => pathIsInFrameworkProfile(x, appFrameworkVersion))
-					.OrderBy(x => x.Path)
-					.ToList();
+                var toWrite = pkg.GetLibFiles().Where(x => pathIsInFrameworkProfile(x, appFrameworkVersion))
+                    .OrderBy(x => x.Path)
+                    .ToList();
 
-				// NB: Because of the above NB, we cannot use ForEachAsync here, we 
-				// have to copy these files in-order. Once we fix assembly resolution, 
-				// we can kill both of these NBs.
-				await Task.Run(() => toWrite.ForEach(x => CopyFileToLocation(target, x)));
+                // NB: Because of the above NB, we cannot use ForEachAsync here, we 
+                // have to copy these files in-order. Once we fix assembly resolution, 
+                // we can kill both of these NBs.
+                await Task.Run(() => toWrite.ForEach(x => CopyFileToLocation(target, x)));
 
-				await pkg.GetContentFiles().ForEachAsync(x => CopyFileToLocation(target, x));
+                await pkg.GetContentFiles().ForEachAsync(x => CopyFileToLocation(target, x));
 
-				var newCurrentVersion = updateInfo.FutureReleaseEntry.Version;
+                var newCurrentVersion = updateInfo.FutureReleaseEntry.Version;
 
-				// Perform post-install; clean up the previous version by asking it
-				// which shortcuts to install, and nuking them. Then, run the app's
-				// post install and set up shortcuts.
-				runPostInstallAndCleanup(newCurrentVersion, updateInfo.IsBootstrapping);
-			}
+                // Perform post-install; clean up the previous version by asking it
+                // which shortcuts to install, and nuking them. Then, run the app's
+                // post install and set up shortcuts.
+                runPostInstallAndCleanup(newCurrentVersion, updateInfo.IsBootstrapping);
+            }
 
-			void CopyFileToLocation(FileSystemInfo target, IPackageFile x)
-			{
-				var targetPath = Path.Combine(target.FullName, x.EffectivePath);
+            void CopyFileToLocation(FileSystemInfo target, IPackageFile x)
+            {
+                var targetPath = Path.Combine(target.FullName, x.EffectivePath);
 
-				var fi = new FileInfo(targetPath);
-				if (fi.Exists) fi.Delete();
+                var fi = new FileInfo(targetPath);
+                if (fi.Exists) fi.Delete();
 
-				var dir = new DirectoryInfo(Path.GetDirectoryName(targetPath));
-				if (!dir.Exists) dir.Create();
+                var dir = new DirectoryInfo(Path.GetDirectoryName(targetPath));
+                if (!dir.Exists) dir.Create();
 
-				using (var inf = x.GetStream())
-				using (var of = fi.Open(FileMode.CreateNew, FileAccess.Write)) {
-					inf.CopyTo(of);
-				}
-			}
+                using (var inf = x.GetStream())
+                using (var of = fi.Open(FileMode.CreateNew, FileAccess.Write)) {
+                    inf.CopyTo(of);
+                }
+            }
 
-			void runPostInstallAndCleanup(Version newCurrentVersion, bool isBootstrapping)
-			{
-				fixPinnedExecutables(newCurrentVersion);
+            void runPostInstallAndCleanup(Version newCurrentVersion, bool isBootstrapping)
+            {
+                fixPinnedExecutables(newCurrentVersion);
 
-				this.Log().Info("runPostInstallAndCleanup: finished fixPinnedExecutables");
-				cleanUpOldVersions(newCurrentVersion);
-			}
+                this.Log().Info("runPostInstallAndCleanup: finished fixPinnedExecutables");
+                cleanUpOldVersions(newCurrentVersion);
+            }
 
-			static bool pathIsInFrameworkProfile(IPackageFile packageFile, FrameworkVersion appFrameworkVersion)
-			{
-				if (!packageFile.Path.StartsWith("lib", StringComparison.InvariantCultureIgnoreCase)) {
-					return false;
-				}
+            static bool pathIsInFrameworkProfile(IPackageFile packageFile, FrameworkVersion appFrameworkVersion)
+            {
+                if (!packageFile.Path.StartsWith("lib", StringComparison.InvariantCultureIgnoreCase)) {
+                    return false;
+                }
 
-				if (appFrameworkVersion == FrameworkVersion.Net40
-					&& packageFile.Path.StartsWith("lib\\net45", StringComparison.InvariantCultureIgnoreCase)) {
-					return false;
-				}
+                if (appFrameworkVersion == FrameworkVersion.Net40
+                    && packageFile.Path.StartsWith("lib\\net45", StringComparison.InvariantCultureIgnoreCase)) {
+                    return false;
+                }
 
-				return true;
-			}
+                return true;
+            }
 
-			async Task<ReleaseEntry> createFullPackagesFromDeltas(IEnumerable<ReleaseEntry> releasesToApply, ReleaseEntry currentVersion)
-			{
-				Contract.Requires(releasesToApply != null);
+            async Task<ReleaseEntry> createFullPackagesFromDeltas(IEnumerable<ReleaseEntry> releasesToApply, ReleaseEntry currentVersion)
+            {
+                Contract.Requires(releasesToApply != null);
 
-				// If there are no deltas in our list, we're already done
-				if (!releasesToApply.Any() || releasesToApply.All(x => !x.IsDelta)) {
-					return releasesToApply.MaxBy(x => x.Version).First();
-				}
+                // If there are no deltas in our list, we're already done
+                if (!releasesToApply.Any() || releasesToApply.All(x => !x.IsDelta)) {
+                    return releasesToApply.MaxBy(x => x.Version).First();
+                }
 
-				if (!releasesToApply.All(x => x.IsDelta)) {
-					throw new Exception("Cannot apply combinations of delta and full packages");
-				}
+                if (!releasesToApply.All(x => x.IsDelta)) {
+                    throw new Exception("Cannot apply combinations of delta and full packages");
+                }
 
-				// Smash together our base full package and the nearest delta
-				var ret = await Task.Run(() => {
-					var basePkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", currentVersion.Filename));
-					var deltaPkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", releasesToApply.First().Filename));
+                // Smash together our base full package and the nearest delta
+                var ret = await Task.Run(() => {
+                    var basePkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", currentVersion.Filename));
+                    var deltaPkg = new ReleasePackage(Path.Combine(rootAppDirectory, "packages", releasesToApply.First().Filename));
 
-					var deltaBuilder = new DeltaPackageBuilder();
+                    var deltaBuilder = new DeltaPackageBuilder();
 
-					return deltaBuilder.ApplyDeltaPackage(basePkg, deltaPkg,
-						Regex.Replace(deltaPkg.InputPackageFile, @"-delta.nupkg$", ".nupkg", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant));
-				});
+                    return deltaBuilder.ApplyDeltaPackage(basePkg, deltaPkg,
+                        Regex.Replace(deltaPkg.InputPackageFile, @"-delta.nupkg$", ".nupkg", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant));
+                });
 
-				if (releasesToApply.Count() == 1) {
-					return ReleaseEntry.GenerateFromFile(ret.InputPackageFile);
-				}
+                if (releasesToApply.Count() == 1) {
+                    return ReleaseEntry.GenerateFromFile(ret.InputPackageFile);
+                }
 
-				var fi = new FileInfo(ret.InputPackageFile);
-				var entry = ReleaseEntry.GenerateFromFile(fi.OpenRead(), fi.Name);
+                var fi = new FileInfo(ret.InputPackageFile);
+                var entry = ReleaseEntry.GenerateFromFile(fi.OpenRead(), fi.Name);
 
-				// Recursively combine the rest of them
-				return await createFullPackagesFromDeltas(releasesToApply.Skip(1), entry);
-			}
+                // Recursively combine the rest of them
+                return await createFullPackagesFromDeltas(releasesToApply.Skip(1), entry);
+            }
 
-			void cleanUpOldVersions(Version newCurrentVersion)
-			{
-				var directory = new DirectoryInfo(rootAppDirectory);
-				if (!directory.Exists) {
-					this.Log().Warn("cleanUpOldVersions: the directory '{0}' does not exist", rootAppDirectory);
-					return;
-				}
-				
-				foreach (var v in getOldReleases(newCurrentVersion)) {
-					Utility.DeleteDirectoryAtNextReboot(v.FullName);
-				}
-			}
+            void cleanUpOldVersions(Version newCurrentVersion)
+            {
+                var directory = new DirectoryInfo(rootAppDirectory);
+                if (!directory.Exists) {
+                    this.Log().Warn("cleanUpOldVersions: the directory '{0}' does not exist", rootAppDirectory);
+                    return;
+                }
+                
+                foreach (var v in getOldReleases(newCurrentVersion)) {
+                    Utility.DeleteDirectoryAtNextReboot(v.FullName);
+                }
+            }
 
-			void fixPinnedExecutables(Version newCurrentVersion) 
-			{
-				if (Environment.OSVersion.Version < new Version(6, 1)) {
-					this.Log().Warn("fixPinnedExecutables: Found OS Version '{0}', exiting...", Environment.OSVersion.VersionString);
-					return;
-				}
+            void fixPinnedExecutables(Version newCurrentVersion) 
+            {
+                if (Environment.OSVersion.Version < new Version(6, 1)) {
+                    this.Log().Warn("fixPinnedExecutables: Found OS Version '{0}', exiting...", Environment.OSVersion.VersionString);
+                    return;
+                }
 
-				var newCurrentFolder = "app-" + newCurrentVersion;
-				var oldAppDirectories = (new DirectoryInfo(rootAppDirectory)).GetDirectories()
-					.Where(x => x.Name.StartsWith("app-", StringComparison.InvariantCultureIgnoreCase))
-					.Where(x => x.Name != newCurrentFolder)
-					.Select(x => x.FullName)
-					.ToArray();
+                var newCurrentFolder = "app-" + newCurrentVersion;
+                var oldAppDirectories = (new DirectoryInfo(rootAppDirectory)).GetDirectories()
+                    .Where(x => x.Name.StartsWith("app-", StringComparison.InvariantCultureIgnoreCase))
+                    .Where(x => x.Name != newCurrentFolder)
+                    .Select(x => x.FullName)
+                    .ToArray();
 
-				if (!oldAppDirectories.Any()) {
-					this.Log().Info("fixPinnedExecutables: oldAppDirectories is empty, this is pointless");
-					return;
-				}
+                if (!oldAppDirectories.Any()) {
+                    this.Log().Info("fixPinnedExecutables: oldAppDirectories is empty, this is pointless");
+                    return;
+                }
 
-				var newAppPath = Path.Combine(rootAppDirectory, newCurrentFolder);
+                var newAppPath = Path.Combine(rootAppDirectory, newCurrentFolder);
 
-				var taskbarPath = Path.Combine(
-					Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
-					"Microsoft\\Internet Explorer\\Quick Launch\\User Pinned\\TaskBar");
+                var taskbarPath = Path.Combine(
+                    Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+                    "Microsoft\\Internet Explorer\\Quick Launch\\User Pinned\\TaskBar");
 
-				Func<FileInfo, ShellLink> resolveLink = file => {
-					try {
-						return new ShellLink(file.FullName);
-					} catch (Exception ex) {
-						var message = String.Format("File '{0}' could not be converted into a valid ShellLink", file.FullName);
-						this.Log().WarnException(message, ex);
-						return null;
-					}
-				};
+                Func<FileInfo, ShellLink> resolveLink = file => {
+                    try {
+                        return new ShellLink(file.FullName);
+                    } catch (Exception ex) {
+                        var message = String.Format("File '{0}' could not be converted into a valid ShellLink", file.FullName);
+                        this.Log().WarnException(message, ex);
+                        return null;
+                    }
+                };
 
-				var shellLinks = (new DirectoryInfo(taskbarPath)).GetFiles("*.lnk")
-					.Select(resolveLink)
-					.Where(x => x != null)
-					.ToArray();
+                var shellLinks = (new DirectoryInfo(taskbarPath)).GetFiles("*.lnk")
+                    .Select(resolveLink)
+                    .Where(x => x != null)
+                    .ToArray();
 
-				foreach (var shortcut in shellLinks) {
-					try {
-						updateLink(shortcut, oldAppDirectories, newAppPath);
-					} catch (Exception ex) {
-						var message = String.Format("fixPinnedExecutables: shortcut failed: {0}", shortcut.Target);
-						this.Log().ErrorException(message, ex);
-					}
-				}
-			}
+                foreach (var shortcut in shellLinks) {
+                    try {
+                        updateLink(shortcut, oldAppDirectories, newAppPath);
+                    } catch (Exception ex) {
+                        var message = String.Format("fixPinnedExecutables: shortcut failed: {0}", shortcut.Target);
+                        this.Log().ErrorException(message, ex);
+                    }
+                }
+            }
 
-			void updateLink(ShellLink shortcut, string[] oldAppDirectories, string newAppPath)
-			{
-				this.Log().Info("Processing shortcut '{0}'", shortcut.Target);
+            void updateLink(ShellLink shortcut, string[] oldAppDirectories, string newAppPath)
+            {
+                this.Log().Info("Processing shortcut '{0}'", shortcut.Target);
 
-				foreach (var oldAppDirectory in oldAppDirectories) {
-					if (!shortcut.Target.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
-						this.Log().Info("Does not match '{0}', continuing to next directory", oldAppDirectory);
-						continue;
-					}
+                foreach (var oldAppDirectory in oldAppDirectories) {
+                    if (!shortcut.Target.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
+                        this.Log().Info("Does not match '{0}', continuing to next directory", oldAppDirectory);
+                        continue;
+                    }
 
-					// replace old app path with new app path and check, if executable still exists
-					var newTarget = Path.Combine(newAppPath, shortcut.Target.Substring(oldAppDirectory.Length + 1));
+                    // replace old app path with new app path and check, if executable still exists
+                    var newTarget = Path.Combine(newAppPath, shortcut.Target.Substring(oldAppDirectory.Length + 1));
 
-					if (File.Exists(newTarget)) {
-						shortcut.Target = newTarget;
+                    if (File.Exists(newTarget)) {
+                        shortcut.Target = newTarget;
 
-						// replace working directory too if appropriate
-						if (shortcut.WorkingDirectory.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
-							this.Log().Info("Changing new directory to '{0}'", newAppPath);
-							shortcut.WorkingDirectory = Path.Combine(newAppPath,
-								shortcut.WorkingDirectory.Substring(oldAppDirectory.Length + 1));
-						}
+                        // replace working directory too if appropriate
+                        if (shortcut.WorkingDirectory.StartsWith(oldAppDirectory, StringComparison.OrdinalIgnoreCase)) {
+                            this.Log().Info("Changing new directory to '{0}'", newAppPath);
+                            shortcut.WorkingDirectory = Path.Combine(newAppPath,
+                                shortcut.WorkingDirectory.Substring(oldAppDirectory.Length + 1));
+                        }
 
-						shortcut.Save();
-					}
-					else {
-						this.Log().Info("Unpinning {0} from taskbar", shortcut.Target);
-						TaskbarHelper.UnpinFromTaskbar(shortcut.Target);
-					}
+                        shortcut.Save();
+                    }
+                    else {
+                        this.Log().Info("Unpinning {0} from taskbar", shortcut.Target);
+                        TaskbarHelper.UnpinFromTaskbar(shortcut.Target);
+                    }
 
-					break;
-				}
-			}
+                    break;
+                }
+            }
 
-			// NB: Once we uninstall the old version of the app, we try to schedule
-			// it to be deleted at next reboot. Unfortunately, depending on whether
-			// the user has admin permissions, this can fail. So as a failsafe,
-			// before we try to apply any update, we assume previous versions in the
-			// directory are "dead" (i.e. already uninstalled, but not deleted), and
-			// we blow them away. This is to make sure that we don't attempt to run
-			// an uninstaller on an already-uninstalled version.
-			async Task cleanDeadVersions(Version currentVersion)
-			{
-				if (currentVersion == null) return;
+            // NB: Once we uninstall the old version of the app, we try to schedule
+            // it to be deleted at next reboot. Unfortunately, depending on whether
+            // the user has admin permissions, this can fail. So as a failsafe,
+            // before we try to apply any update, we assume previous versions in the
+            // directory are "dead" (i.e. already uninstalled, but not deleted), and
+            // we blow them away. This is to make sure that we don't attempt to run
+            // an uninstaller on an already-uninstalled version.
+            async Task cleanDeadVersions(Version currentVersion)
+            {
+                if (currentVersion == null) return;
 
-				var di = new DirectoryInfo(rootAppDirectory);
-				if (!di.Exists) return;
+                var di = new DirectoryInfo(rootAppDirectory);
+                if (!di.Exists) return;
 
-				this.Log().Info("cleanDeadVersions: for version {0}", currentVersion);
+                this.Log().Info("cleanDeadVersions: for version {0}", currentVersion);
 
-				string currentVersionFolder = null;
-				if (currentVersion != null) {
-					currentVersionFolder = getDirectoryForRelease(currentVersion).Name;
-					this.Log().Info("cleanDeadVersions: exclude folder {0}", currentVersionFolder);
-				}
+                string currentVersionFolder = null;
+                if (currentVersion != null) {
+                    currentVersionFolder = getDirectoryForRelease(currentVersion).Name;
+                    this.Log().Info("cleanDeadVersions: exclude folder {0}", currentVersionFolder);
+                }
 
-				// NB: If we try to access a directory that has already been 
-				// scheduled for deletion by MoveFileEx it throws what seems like
-				// NT's only error code, ERROR_ACCESS_DENIED. Squelch errors that
-				// come from here.
-				var toCleanup = di.GetDirectories()
-					.Where(x => x.Name.ToLowerInvariant().Contains("app-"))
-					.Where(x => x.Name != currentVersionFolder);
+                // NB: If we try to access a directory that has already been 
+                // scheduled for deletion by MoveFileEx it throws what seems like
+                // NT's only error code, ERROR_ACCESS_DENIED. Squelch errors that
+                // come from here.
+                var toCleanup = di.GetDirectories()
+                    .Where(x => x.Name.ToLowerInvariant().Contains("app-"))
+                    .Where(x => x.Name != currentVersionFolder);
 
-				await toCleanup.ForEachAsync(async x => {
-					try {
-						await Utility.DeleteDirectory(x.FullName);
-					} catch (UnauthorizedAccessException ex) {
-						this.Log().WarnException("Couldn't delete directory: " + x.FullName, ex);
-					}
-				});
-			}
+                await toCleanup.ForEachAsync(async x => {
+                    try {
+                        await Utility.DeleteDirectory(x.FullName);
+                    } catch (UnauthorizedAccessException ex) {
+                        this.Log().WarnException("Couldn't delete directory: " + x.FullName, ex);
+                    }
+                });
+            }
 
-			async Task updateLocalReleasesFile()
-			{
-				await Task.Run(() => ReleaseEntry.BuildReleasesFile(PackageDirectory));
-			}
+            async Task updateLocalReleasesFile()
+            {
+                await Task.Run(() => ReleaseEntry.BuildReleasesFile(PackageDirectory));
+            }
         }
     }
 }
diff --git a/src/Squirrel/UpdateManager.DownloadReleases.cs b/src/Squirrel/UpdateManager.DownloadReleases.cs
index 25db65e4..0f873144 100644
--- a/src/Squirrel/UpdateManager.DownloadReleases.cs
+++ b/src/Squirrel/UpdateManager.DownloadReleases.cs
@@ -11,62 +11,62 @@ namespace Squirrel
     {
         class DownloadReleases : IEnableLogger
         {
-			public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
-			{
-				progress = progress ?? (_ => { });
-				int current = 0;
-				int toIncrement = (int)(100.0 / releasesToDownload.Count());
+            public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
+            {
+                progress = progress ?? (_ => { });
+                int current = 0;
+                int toIncrement = (int)(100.0 / releasesToDownload.Count());
 
                 if (isHttpUrl(updateUrlOrPath)) {
-					await releasesToDownload.ForEachAsync(async x => {
-						await urlDownloader.DownloadFile(
-							String.Format("{0}/{1}", updateUrlOrPath, x.Filename),
-							Path.Combine(rootAppDirectory, "packages", x.Filename));
-						lock (progress) progress(current += toIncrement);
-					});
-				} else {
-					await releasesToDownload.ForEachAsync(x => {
-						File.Copy(
-							Path.Combine(updateUrlOrPath, x.Filename),
-							Path.Combine(rootAppDirectory, "packages", x.Filename));
-						lock (progress) progress(current += toIncrement);
-					});
-				}
-			}
+                    await releasesToDownload.ForEachAsync(async x => {
+                        await urlDownloader.DownloadFile(
+                            String.Format("{0}/{1}", updateUrlOrPath, x.Filename),
+                            Path.Combine(rootAppDirectory, "packages", x.Filename));
+                        lock (progress) progress(current += toIncrement);
+                    });
+                } else {
+                    await releasesToDownload.ForEachAsync(x => {
+                        File.Copy(
+                            Path.Combine(updateUrlOrPath, x.Filename),
+                            Path.Combine(rootAppDirectory, "packages", x.Filename));
+                        lock (progress) progress(current += toIncrement);
+                    });
+                }
+            }
 
-			Task checksumAllPackages(IEnumerable<ReleaseEntry> releasesDownloaded)
-			{
-				return releasesDownloaded.ForEachAsync(x => checksumPackage(x));
-			}
+            Task checksumAllPackages(IEnumerable<ReleaseEntry> releasesDownloaded)
+            {
+                return releasesDownloaded.ForEachAsync(x => checksumPackage(x));
+            }
 
-			void checksumPackage(ReleaseEntry downloadedRelease)
-			{
-				var targetPackage = new FileInfo(
-					Path.Combine(rootAppDirectory, "packages", downloadedRelease.Filename));
+            void checksumPackage(ReleaseEntry downloadedRelease)
+            {
+                var targetPackage = new FileInfo(
+                    Path.Combine(rootAppDirectory, "packages", downloadedRelease.Filename));
 
-				if (!targetPackage.Exists) {
-					this.Log().Error("File {0} should exist but doesn't", targetPackage.FullName);
+                if (!targetPackage.Exists) {
+                    this.Log().Error("File {0} should exist but doesn't", targetPackage.FullName);
 
-					throw new Exception("Checksummed file doesn't exist: " + targetPackage.FullName);
-				}
+                    throw new Exception("Checksummed file doesn't exist: " + targetPackage.FullName);
+                }
 
-				if (targetPackage.Length != downloadedRelease.Filesize) {
-					this.Log().Error("File Length should be {0}, is {1}", downloadedRelease.Filesize, targetPackage.Length);
-					targetPackage.Delete();
+                if (targetPackage.Length != downloadedRelease.Filesize) {
+                    this.Log().Error("File Length should be {0}, is {1}", downloadedRelease.Filesize, targetPackage.Length);
+                    targetPackage.Delete();
 
-					throw new Exception("Checksummed file size doesn't match: " + targetPackage.FullName);
-				}
+                    throw new Exception("Checksummed file size doesn't match: " + targetPackage.FullName);
+                }
 
-				using (var file = targetPackage.OpenRead()) {
-					var hash = Utility.CalculateStreamSHA1(file);
+                using (var file = targetPackage.OpenRead()) {
+                    var hash = Utility.CalculateStreamSHA1(file);
 
-					if (!hash.Equals(downloadedRelease.SHA1,StringComparison.OrdinalIgnoreCase)) {
-						this.Log().Error("File SHA1 should be {0}, is {1}", downloadedRelease.SHA1, hash);
-						targetPackage.Delete();
-						throw new Exception("Checksum doesn't match: " + targetPackage.FullName);
-					}
-				}
-			}
+                    if (!hash.Equals(downloadedRelease.SHA1,StringComparison.OrdinalIgnoreCase)) {
+                        this.Log().Error("File SHA1 should be {0}, is {1}", downloadedRelease.SHA1, hash);
+                        targetPackage.Delete();
+                        throw new Exception("Checksum doesn't match: " + targetPackage.FullName);
+                    }
+                }
+            }
         }
     }
 }

From 9c50cbc7f4f77cf3ae88e22e19aa7fbe179e4eab Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 12:38:50 +0200
Subject: [PATCH 04/11] DownloadReleases into its own class

---
 src/Squirrel/UpdateManager.DownloadReleases.cs | 14 ++++++++++++--
 src/Squirrel/UpdateManager.cs                  |  3 ++-
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/Squirrel/UpdateManager.DownloadReleases.cs b/src/Squirrel/UpdateManager.DownloadReleases.cs
index 0f873144..679bc927 100644
--- a/src/Squirrel/UpdateManager.DownloadReleases.cs
+++ b/src/Squirrel/UpdateManager.DownloadReleases.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -11,13 +12,22 @@ namespace Squirrel
     {
         class DownloadReleases : IEnableLogger
         {
-            public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
+            readonly string rootAppDirectory;
+
+            public DownloadReleases(string rootAppDirectory)
+            {
+                this.rootAppDirectory = rootAppDirectory;
+            }
+
+            public async Task DownloadReleases(string updateUrlOrPath, IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null, IFileDownloader urlDownloader = null)
             {
                 progress = progress ?? (_ => { });
+                urlDownloader = urlDownloader ?? new FileDownloader();
+
                 int current = 0;
                 int toIncrement = (int)(100.0 / releasesToDownload.Count());
 
-                if (isHttpUrl(updateUrlOrPath)) {
+                if (Utility.IsHttpUrl(updateUrlOrPath)) {
                     await releasesToDownload.ForEachAsync(async x => {
                         await urlDownloader.DownloadFile(
                             String.Format("{0}/{1}", updateUrlOrPath, x.Filename),
diff --git a/src/Squirrel/UpdateManager.cs b/src/Squirrel/UpdateManager.cs
index 092339ec..a9b35ee6 100644
--- a/src/Squirrel/UpdateManager.cs
+++ b/src/Squirrel/UpdateManager.cs
@@ -49,7 +49,8 @@ namespace Squirrel
 
         public Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
         {
-            throw new NotImplementedException();
+            var downloadReleases = new DownloadReleases(rootAppDirectory);
+            return downloadReleases.DownloadReleases(updateUrlOrPath, releasesToDownload, progress, urlDownloader);
         }
 
         public Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)

From 0763761c57f635b3a9c5b21e4e06d8c1b17befad Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 12:58:18 +0200
Subject: [PATCH 05/11] Get ApplyReleases building

---
 src/Squirrel/UpdateManager.ApplyReleases.cs | 62 +++++++++++++++++++-
 src/Squirrel/UpdateManager.cs               | 64 ++++++---------------
 2 files changed, 77 insertions(+), 49 deletions(-)

diff --git a/src/Squirrel/UpdateManager.ApplyReleases.cs b/src/Squirrel/UpdateManager.ApplyReleases.cs
index 00f43ec1..1b6003ce 100644
--- a/src/Squirrel/UpdateManager.ApplyReleases.cs
+++ b/src/Squirrel/UpdateManager.ApplyReleases.cs
@@ -1,8 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.IO;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using NuGet;
 using Splat;
 
 namespace Squirrel
@@ -11,6 +15,16 @@ namespace Squirrel
     {
         class ApplyReleases : IEnableLogger
         {
+            // TODO: Kill this entire concept
+            readonly FrameworkVersion appFrameworkVersion = FrameworkVersion.Net45;
+
+            readonly string rootAppDirectory;
+
+            public ApplyReleases(string rootAppDirectory)
+            {
+                this.rootAppDirectory = rootAppDirectory;
+            }
+
             public async Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
             {
                 progress = progress ?? (_ => { });
@@ -28,6 +42,25 @@ namespace Squirrel
                 progress(100);
             }
 
+            public async Task FullUninstall(Version version = null)
+            {
+                version = version ?? new Version(255, 255, 255, 255);
+                this.Log().Info("Uninstalling version '{0}'", version);
+
+
+                // find all the old releases (and this one)
+                var directoriesToDelete = getOldReleases(version)
+                    .Concat(new [] { getDirectoryForRelease(version) })
+                    .Where(d => d.Exists)
+                    .Select(d => d.FullName);
+
+                await directoriesToDelete.ForEachAsync(x => Utility.DeleteDirectoryWithFallbackToNextReboot(x));
+
+                if (!getReleases().Any()) {
+                    await Utility.DeleteDirectoryWithFallbackToNextReboot(rootAppDirectory);
+                }
+            }
+
             async Task installPackageToAppDir(UpdateInfo updateInfo, ReleaseEntry release)
             {
                 var pkg = new ZipPackage(Path.Combine(updateInfo.PackageDirectory, release.Filename));
@@ -278,7 +311,34 @@ namespace Squirrel
 
             async Task updateLocalReleasesFile()
             {
-                await Task.Run(() => ReleaseEntry.BuildReleasesFile(PackageDirectory));
+                await Task.Run(() => ReleaseEntry.BuildReleasesFile(Utility.PackageDirectoryForAppDir(rootAppDirectory)));
+            }
+
+            IEnumerable<DirectoryInfo> getReleases()
+            {
+                var rootDirectory = new DirectoryInfo(rootAppDirectory);
+
+                if (!rootDirectory.Exists) return Enumerable.Empty<DirectoryInfo>();
+
+                return rootDirectory.GetDirectories()
+                    .Where(x => x.Name.StartsWith("app-", StringComparison.InvariantCultureIgnoreCase));
+            }
+
+            IEnumerable<DirectoryInfo> getOldReleases(Version version)
+            {
+                return getReleases()
+                    .Where(x => x.Name.ToVersion() < version)
+                    .ToArray();
+            }
+
+            static string getLocalAppDataDirectory()
+            {
+                return Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            }
+
+            DirectoryInfo getDirectoryForRelease(Version releaseVersion)
+            {
+                return new DirectoryInfo(Path.Combine(rootAppDirectory, "app-" + releaseVersion));
             }
         }
     }
diff --git a/src/Squirrel/UpdateManager.cs b/src/Squirrel/UpdateManager.cs
index a9b35ee6..6054e319 100644
--- a/src/Squirrel/UpdateManager.cs
+++ b/src/Squirrel/UpdateManager.cs
@@ -41,63 +41,36 @@ namespace Squirrel
             this.urlDownloader = urlDownloader ?? new FileDownloader();
         }
 
-        public Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates, Action<int> progress = null)
+        public async Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates, Action<int> progress = null)
         {
             var checkForUpdate = new CheckForUpdates(rootAppDirectory);
-            return checkForUpdate.CheckForUpdate(Utility.LocalReleaseFileForAppDir(rootAppDirectory), updateUrlOrPath, ignoreDeltaUpdates, progress, urlDownloader);
+
+            await acquireUpdateLock();
+            return await checkForUpdate.CheckForUpdate(Utility.LocalReleaseFileForAppDir(rootAppDirectory), updateUrlOrPath, ignoreDeltaUpdates, progress, urlDownloader);
         }
 
-        public Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
+        public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
         {
             var downloadReleases = new DownloadReleases(rootAppDirectory);
-            return downloadReleases.DownloadReleases(updateUrlOrPath, releasesToDownload, progress, urlDownloader);
+            await acquireUpdateLock();
+
+            await downloadReleases.DownloadReleases(updateUrlOrPath, releasesToDownload, progress, urlDownloader);
         }
 
-        public Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
+        public async Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
         {
-            throw new NotImplementedException();
+            var applyReleases = new ApplyReleases(rootAppDirectory);
+            await acquireUpdateLock();
+
+            await applyReleases.ApplyReleases(updateInfo, progress);
         }
 
         public async Task FullUninstall()
         {
+            var applyReleases = new ApplyReleases(rootAppDirectory);
             await acquireUpdateLock();
-            await fullUninstall();
-        }
 
-        IEnumerable<DirectoryInfo> getReleases()
-        {
-            var rootDirectory = new DirectoryInfo(rootAppDirectory);
-
-            if (!rootDirectory.Exists) return Enumerable.Empty<DirectoryInfo>();
-
-            return rootDirectory.GetDirectories()
-                .Where(x => x.Name.StartsWith("app-", StringComparison.InvariantCultureIgnoreCase));
-        }
-
-        IEnumerable<DirectoryInfo> getOldReleases(Version version)
-        {
-            return getReleases()
-                .Where(x => x.Name.ToVersion() < version)
-                .ToArray();
-        }
-
-        async Task fullUninstall(Version version = null)
-        {
-            version = version ?? new Version(255, 255, 255, 255);
-            this.Log().Info("Uninstalling version '{0}'", version);
-
-
-            // find all the old releases (and this one)
-            var directoriesToDelete = getOldReleases(version)
-                .Concat(new [] { getDirectoryForRelease(version) })
-                .Where(d => d.Exists)
-                .Select(d => d.FullName);
-
-            await directoriesToDelete.ForEachAsync(x => Utility.DeleteDirectoryWithFallbackToNextReboot(x));
-
-            if (!getReleases().Any()) {
-                await Utility.DeleteDirectoryWithFallbackToNextReboot(rootAppDirectory);
-            }
+            await applyReleases.FullUninstall();
         }
 
         public void Dispose()
@@ -148,10 +121,5 @@ namespace Squirrel
         {
             return Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
         }
-
-        DirectoryInfo getDirectoryForRelease(Version releaseVersion)
-        {
-            return new DirectoryInfo(Path.Combine(rootAppDirectory, "app-" + releaseVersion));
-        }
     }
-}
+}
\ No newline at end of file

From cedb12266d2228870bd205983653924e5cc91c04 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 13:01:25 +0200
Subject: [PATCH 06/11] Rename classes to get rid of naming conflict

---
 Squirrel.sln                                   | 1 +
 src/Squirrel/IUpdateManager.cs                 | 2 +-
 src/Squirrel/UpdateManager.ApplyReleases.cs    | 9 ++-------
 src/Squirrel/UpdateManager.CheckForUpdates.cs  | 4 ++--
 src/Squirrel/UpdateManager.DownloadReleases.cs | 4 ++--
 src/Squirrel/UpdateManager.cs                  | 8 ++++----
 6 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/Squirrel.sln b/Squirrel.sln
index 1f2218f8..31b35dc5 100644
--- a/Squirrel.sln
+++ b/Squirrel.sln
@@ -34,6 +34,7 @@ Global
 		{98AEB048-E27D-42F4-9440-505B7F78BAFD}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{98AEB048-E27D-42F4-9440-505B7F78BAFD}.Release|Any CPU.Build.0 = Release|Any CPU
 		{C1D40624-A484-438A-B846-052F321C89D1}.CIBuild|Any CPU.ActiveCfg = CIBuild|Win32
+		{C1D40624-A484-438A-B846-052F321C89D1}.CIBuild|Any CPU.Build.0 = CIBuild|Win32
 		{C1D40624-A484-438A-B846-052F321C89D1}.Debug|Any CPU.ActiveCfg = Debug|Win32
 		{C1D40624-A484-438A-B846-052F321C89D1}.Debug|Any CPU.Build.0 = Debug|Win32
 		{C1D40624-A484-438A-B846-052F321C89D1}.Release|Any CPU.ActiveCfg = Release|Win32
diff --git a/src/Squirrel/IUpdateManager.cs b/src/Squirrel/IUpdateManager.cs
index e7878ac6..b64368c6 100644
--- a/src/Squirrel/IUpdateManager.cs
+++ b/src/Squirrel/IUpdateManager.cs
@@ -48,7 +48,7 @@ namespace Squirrel
         /// Completely uninstalls the targeted app
         /// </summary>
         /// <returns>Completion</returns>
-        async Task FullUninstall();
+        Task FullUninstall();
     }
 
     public static class EasyModeMixin
diff --git a/src/Squirrel/UpdateManager.ApplyReleases.cs b/src/Squirrel/UpdateManager.ApplyReleases.cs
index 1b6003ce..04b41c0f 100644
--- a/src/Squirrel/UpdateManager.ApplyReleases.cs
+++ b/src/Squirrel/UpdateManager.ApplyReleases.cs
@@ -13,14 +13,14 @@ namespace Squirrel
 {
     public sealed partial class UpdateManager
     {
-        class ApplyReleases : IEnableLogger
+        class ApplyReleasesImpl : IEnableLogger
         {
             // TODO: Kill this entire concept
             readonly FrameworkVersion appFrameworkVersion = FrameworkVersion.Net45;
 
             readonly string rootAppDirectory;
 
-            public ApplyReleases(string rootAppDirectory)
+            public ApplyReleasesImpl(string rootAppDirectory)
             {
                 this.rootAppDirectory = rootAppDirectory;
             }
@@ -331,11 +331,6 @@ namespace Squirrel
                     .ToArray();
             }
 
-            static string getLocalAppDataDirectory()
-            {
-                return Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
-            }
-
             DirectoryInfo getDirectoryForRelease(Version releaseVersion)
             {
                 return new DirectoryInfo(Path.Combine(rootAppDirectory, "app-" + releaseVersion));
diff --git a/src/Squirrel/UpdateManager.CheckForUpdates.cs b/src/Squirrel/UpdateManager.CheckForUpdates.cs
index b18128f7..e47e7276 100644
--- a/src/Squirrel/UpdateManager.CheckForUpdates.cs
+++ b/src/Squirrel/UpdateManager.CheckForUpdates.cs
@@ -11,14 +11,14 @@ namespace Squirrel
 {
     public sealed partial class UpdateManager
     {
-        class CheckForUpdates : IEnableLogger
+        class CheckForUpdateImpl : IEnableLogger
         {
             readonly string rootAppDirectory;
 
             // TODO: rip this out
             readonly FrameworkVersion appFrameworkVersion = FrameworkVersion.Net45;
 
-            public CheckForUpdates(string rootAppDirectory)
+            public CheckForUpdateImpl(string rootAppDirectory)
             {
                 this.rootAppDirectory = rootAppDirectory;
             }
diff --git a/src/Squirrel/UpdateManager.DownloadReleases.cs b/src/Squirrel/UpdateManager.DownloadReleases.cs
index 679bc927..023cbdaf 100644
--- a/src/Squirrel/UpdateManager.DownloadReleases.cs
+++ b/src/Squirrel/UpdateManager.DownloadReleases.cs
@@ -10,11 +10,11 @@ namespace Squirrel
 {
     public sealed partial class UpdateManager
     {
-        class DownloadReleases : IEnableLogger
+        class DownloadReleasesImpl : IEnableLogger
         {
             readonly string rootAppDirectory;
 
-            public DownloadReleases(string rootAppDirectory)
+            public DownloadReleasesImpl(string rootAppDirectory)
             {
                 this.rootAppDirectory = rootAppDirectory;
             }
diff --git a/src/Squirrel/UpdateManager.cs b/src/Squirrel/UpdateManager.cs
index 6054e319..575b20fc 100644
--- a/src/Squirrel/UpdateManager.cs
+++ b/src/Squirrel/UpdateManager.cs
@@ -43,7 +43,7 @@ namespace Squirrel
 
         public async Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates, Action<int> progress = null)
         {
-            var checkForUpdate = new CheckForUpdates(rootAppDirectory);
+            var checkForUpdate = new CheckForUpdateImpl(rootAppDirectory);
 
             await acquireUpdateLock();
             return await checkForUpdate.CheckForUpdate(Utility.LocalReleaseFileForAppDir(rootAppDirectory), updateUrlOrPath, ignoreDeltaUpdates, progress, urlDownloader);
@@ -51,7 +51,7 @@ namespace Squirrel
 
         public async Task DownloadReleases(IEnumerable<ReleaseEntry> releasesToDownload, Action<int> progress = null)
         {
-            var downloadReleases = new DownloadReleases(rootAppDirectory);
+            var downloadReleases = new DownloadReleasesImpl(rootAppDirectory);
             await acquireUpdateLock();
 
             await downloadReleases.DownloadReleases(updateUrlOrPath, releasesToDownload, progress, urlDownloader);
@@ -59,7 +59,7 @@ namespace Squirrel
 
         public async Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null)
         {
-            var applyReleases = new ApplyReleases(rootAppDirectory);
+            var applyReleases = new ApplyReleasesImpl(rootAppDirectory);
             await acquireUpdateLock();
 
             await applyReleases.ApplyReleases(updateInfo, progress);
@@ -67,7 +67,7 @@ namespace Squirrel
 
         public async Task FullUninstall()
         {
-            var applyReleases = new ApplyReleases(rootAppDirectory);
+            var applyReleases = new ApplyReleasesImpl(rootAppDirectory);
             await acquireUpdateLock();
 
             await applyReleases.FullUninstall();

From 41cfc64e9d5b2f0f554de6e32c16c78a39c61796 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 13:32:44 +0200
Subject: [PATCH 07/11] Clean up existing tests to use our new internal classes

---
 src/Squirrel/IUpdateManager.cs                |  2 +-
 src/Squirrel/UpdateManager.ApplyReleases.cs   |  4 +-
 src/Squirrel/UpdateManager.CheckForUpdates.cs |  2 +-
 .../UpdateManager.DownloadReleases.cs         |  2 +-
 src/Squirrel/UpdateManager.cs                 |  2 +-
 test/ApplyReleasesTests.cs                    | 82 +++++++++----------
 test/UpdateManagerTests.cs                    | 62 ++++++--------
 7 files changed, 68 insertions(+), 88 deletions(-)

diff --git a/src/Squirrel/IUpdateManager.cs b/src/Squirrel/IUpdateManager.cs
index b64368c6..96bd7509 100644
--- a/src/Squirrel/IUpdateManager.cs
+++ b/src/Squirrel/IUpdateManager.cs
@@ -20,7 +20,7 @@ namespace Squirrel
         /// will return values from 0-100 and Complete, or Throw</param>
         /// <returns>An UpdateInfo object representing the updates to install.
         /// </returns>
-        Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates, Action<int> progress = null);
+        Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates = false, Action<int> progress = null);
 
         /// <summary>
         /// Download a list of releases into the local package directory.
diff --git a/src/Squirrel/UpdateManager.ApplyReleases.cs b/src/Squirrel/UpdateManager.ApplyReleases.cs
index 04b41c0f..edbcedff 100644
--- a/src/Squirrel/UpdateManager.ApplyReleases.cs
+++ b/src/Squirrel/UpdateManager.ApplyReleases.cs
@@ -13,7 +13,7 @@ namespace Squirrel
 {
     public sealed partial class UpdateManager
     {
-        class ApplyReleasesImpl : IEnableLogger
+        internal class ApplyReleasesImpl : IEnableLogger
         {
             // TODO: Kill this entire concept
             readonly FrameworkVersion appFrameworkVersion = FrameworkVersion.Net45;
@@ -309,7 +309,7 @@ namespace Squirrel
                 });
             }
 
-            async Task updateLocalReleasesFile()
+            internal async Task updateLocalReleasesFile()
             {
                 await Task.Run(() => ReleaseEntry.BuildReleasesFile(Utility.PackageDirectoryForAppDir(rootAppDirectory)));
             }
diff --git a/src/Squirrel/UpdateManager.CheckForUpdates.cs b/src/Squirrel/UpdateManager.CheckForUpdates.cs
index e47e7276..e71722d6 100644
--- a/src/Squirrel/UpdateManager.CheckForUpdates.cs
+++ b/src/Squirrel/UpdateManager.CheckForUpdates.cs
@@ -11,7 +11,7 @@ namespace Squirrel
 {
     public sealed partial class UpdateManager
     {
-        class CheckForUpdateImpl : IEnableLogger
+        internal class CheckForUpdateImpl : IEnableLogger
         {
             readonly string rootAppDirectory;
 
diff --git a/src/Squirrel/UpdateManager.DownloadReleases.cs b/src/Squirrel/UpdateManager.DownloadReleases.cs
index 023cbdaf..0997d47e 100644
--- a/src/Squirrel/UpdateManager.DownloadReleases.cs
+++ b/src/Squirrel/UpdateManager.DownloadReleases.cs
@@ -10,7 +10,7 @@ namespace Squirrel
 {
     public sealed partial class UpdateManager
     {
-        class DownloadReleasesImpl : IEnableLogger
+        internal class DownloadReleasesImpl : IEnableLogger
         {
             readonly string rootAppDirectory;
 
diff --git a/src/Squirrel/UpdateManager.cs b/src/Squirrel/UpdateManager.cs
index 575b20fc..f01f219f 100644
--- a/src/Squirrel/UpdateManager.cs
+++ b/src/Squirrel/UpdateManager.cs
@@ -41,7 +41,7 @@ namespace Squirrel
             this.urlDownloader = urlDownloader ?? new FileDownloader();
         }
 
-        public async Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates, Action<int> progress = null)
+        public async Task<UpdateInfo> CheckForUpdate(bool ignoreDeltaUpdates = false, Action<int> progress = null)
         {
             var checkForUpdate = new CheckForUpdateImpl(rootAppDirectory);
 
diff --git a/test/ApplyReleasesTests.cs b/test/ApplyReleasesTests.cs
index 42935972..ddf78346 100644
--- a/test/ApplyReleasesTests.cs
+++ b/test/ApplyReleasesTests.cs
@@ -90,7 +90,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.1.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.0.0.0-full.nupkg"));
                 var latestFullEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-full.nupkg"));
@@ -98,16 +98,14 @@ namespace Squirrel.Tests
                 var updateInfo = UpdateInfo.Create(baseEntry, new[] { latestFullEntry }, packagesDir, FrameworkVersion.Net40);
                 updateInfo.ReleasesToApply.Contains(latestFullEntry).ShouldBeTrue();
 
-                using (fixture) {
-                    var progress = new List<int>();
+                var progress = new List<int>();
 
-                    await fixture.ApplyReleases(updateInfo, progress.Add);
-                    this.Log().Info("Progress: [{0}]", String.Join(",", progress));
+                await fixture.ApplyReleases(updateInfo, progress.Add);
+                this.Log().Info("Progress: [{0}]", String.Join(",", progress));
 
-                    progress
-                        .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
-                        .ShouldEqual(100);
-                }
+                progress
+                    .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
+                    .ShouldEqual(100);
 
                 var filesToFind = new[] {
                     new {Name = "NLog.dll", Version = new Version("2.0.0.0")},
@@ -141,7 +139,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.2.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-full.nupkg"));
                 var latestFullEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.2.0.0-full.nupkg"));
@@ -149,15 +147,13 @@ namespace Squirrel.Tests
                 var updateInfo = UpdateInfo.Create(baseEntry, new[] { latestFullEntry }, packagesDir, FrameworkVersion.Net40);
                 updateInfo.ReleasesToApply.Contains(latestFullEntry).ShouldBeTrue();
 
-                using (fixture) {
-                    var progress = new List<int>();
-                    await fixture.ApplyReleases(updateInfo, progress.Add);
-                    this.Log().Info("Progress: [{0}]", String.Join(",", progress));
+                var progress = new List<int>();
+                await fixture.ApplyReleases(updateInfo, progress.Add);
+                this.Log().Info("Progress: [{0}]", String.Join(",", progress));
 
-                    progress
-                        .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
-                        .ShouldEqual(100);
-                }
+                progress
+                    .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
+                    .ShouldEqual(100);
 
                 var rootDirectory = Path.Combine(tempDir, "theApp", "app-1.2.0.0");
 
@@ -191,7 +187,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.3.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-full.nupkg"));
                 var latestFullEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.3.0.0-full.nupkg"));
@@ -199,15 +195,13 @@ namespace Squirrel.Tests
                 var updateInfo = UpdateInfo.Create(baseEntry, new[] { latestFullEntry }, packagesDir, FrameworkVersion.Net40);
                 updateInfo.ReleasesToApply.Contains(latestFullEntry).ShouldBeTrue();
 
-                using (fixture) {
-                    var progress = new List<int>();
-                    await fixture.ApplyReleases(updateInfo, progress.Add);
-                    this.Log().Info("Progress: [{0}]", String.Join(",", progress));
+                var progress = new List<int>();
+                await fixture.ApplyReleases(updateInfo, progress.Add);
+                this.Log().Info("Progress: [{0}]", String.Join(",", progress));
 
-                    progress
-                        .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
-                        .ShouldEqual(100);
-                }
+                progress
+                    .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
+                    .ShouldEqual(100);
 
                 var rootDirectory = Path.Combine(tempDir, "theApp", "app-1.3.0.0");
 
@@ -243,7 +237,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.1.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.0.0.0-full.nupkg"));
                 var deltaEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-delta.nupkg"));
@@ -252,16 +246,14 @@ namespace Squirrel.Tests
                 var updateInfo = UpdateInfo.Create(baseEntry, new[] { deltaEntry, latestFullEntry }, packagesDir, FrameworkVersion.Net40);
                 updateInfo.ReleasesToApply.Contains(deltaEntry).ShouldBeTrue();
 
-                using (fixture) {
-                    var progress = new List<int>();
+                var progress = new List<int>();
 
-                    await fixture.ApplyReleases(updateInfo, progress.Add);
-                    this.Log().Info("Progress: [{0}]", String.Join(",", progress));
+                await fixture.ApplyReleases(updateInfo, progress.Add);
+                this.Log().Info("Progress: [{0}]", String.Join(",", progress));
 
-                    progress
-                        .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
-                        .ShouldEqual(100);
-                }
+                progress
+                    .Aggregate(0, (acc, x) => { x.ShouldBeGreaterThan(acc); return x; })
+                    .ShouldEqual(100);
 
                 var filesToFind = new[] {
                     new {Name = "NLog.dll", Version = new Version("2.0.0.0")},
@@ -294,17 +286,17 @@ namespace Squirrel.Tests
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(tempDir, "theApp", "packages", x)));
 
                 var urlDownloader = new FakeUrlDownloader();
-                using (var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, tempDir, urlDownloader)) {
-                    var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Squirrel.Core.1.0.0.0-full.nupkg"));
-                    var deltaEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Squirrel.Core.1.1.0.0-delta.nupkg"));
+                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
 
-                    var resultObs = (Task<ReleaseEntry>)fixture.GetType().GetMethod("createFullPackagesFromDeltas", BindingFlags.NonPublic | BindingFlags.Instance)
-                        .Invoke(fixture, new object[] { new[] {deltaEntry}, baseEntry });
+                var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Squirrel.Core.1.0.0.0-full.nupkg"));
+                var deltaEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Squirrel.Core.1.1.0.0-delta.nupkg"));
 
-                    var result = await resultObs;
-                    var zp = new ZipPackage(Path.Combine(tempDir, "theApp", "packages", result.Filename));
-                    zp.Version.ToString().ShouldEqual("1.1.0.0");
-                }
+                var resultObs = (Task<ReleaseEntry>)fixture.GetType().GetMethod("createFullPackagesFromDeltas", BindingFlags.NonPublic | BindingFlags.Instance)
+                    .Invoke(fixture, new object[] { new[] {deltaEntry}, baseEntry });
+
+                var result = await resultObs;
+                var zp = new ZipPackage(Path.Combine(tempDir, "theApp", "packages", result.Filename));
+                zp.Version.ToString().ShouldEqual("1.1.0.0");
             }
         }
     }
diff --git a/test/UpdateManagerTests.cs b/test/UpdateManagerTests.cs
index 97e9034c..c08fb64b 100644
--- a/test/UpdateManagerTests.cs
+++ b/test/UpdateManagerTests.cs
@@ -27,11 +27,9 @@ namespace Squirrel.Tests
                         "Squirrel.Core.1.1.0.0-full.nupkg",
                     }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(tempDir, "theApp", "packages", x)));
 
-                    var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
 
-                    using (fixture) {
-                        await fixture.UpdateLocalReleasesFile();
-                    }
+                    await fixture.updateLocalReleasesFile();
 
                     var releasePath = Path.Combine(packageDir.FullName, "RELEASES");
                     File.Exists(releasePath).ShouldBeTrue();
@@ -63,17 +61,16 @@ namespace Squirrel.Tests
                         File.Copy(path, Path.Combine(remotePackages, x));
                     });
 
-                    var fixture = new UpdateManager(remotePackages, "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                        
+                    // sync both release files
+                    await fixture.updateLocalReleasesFile();
+                    ReleaseEntry.BuildReleasesFile(remotePackages);
 
+                    // check for an update
                     UpdateInfo updateInfo;
-                    using (fixture)
-                    {
-                        // sync both release files
-                        await fixture.UpdateLocalReleasesFile();
-                        ReleaseEntry.BuildReleasesFile(remotePackages);
-
-                        // check for an update
-                        updateInfo = await fixture.CheckForUpdate();
+                    using (var mgr = new UpdateManager(remotePackages, "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader())) {
+                        updateInfo = await mgr.CheckForUpdate();
                     }
 
                     Assert.NotNull(updateInfo);
@@ -111,17 +108,15 @@ namespace Squirrel.Tests
                         File.Copy(path, Path.Combine(remotePackages, x));
                     });
 
-                    var fixture = new UpdateManager(remotePackages, "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+
+                    // sync both release files
+                    await fixture.updateLocalReleasesFile();
+                    ReleaseEntry.BuildReleasesFile(remotePackages);
 
                     UpdateInfo updateInfo;
-                    using (fixture)
-                    {
-                        // sync both release files
-                        await fixture.UpdateLocalReleasesFile();
-                        ReleaseEntry.BuildReleasesFile(remotePackages);
-
-                        // check for an update
-                        updateInfo = await fixture.CheckForUpdate();
+                    using (var mgr = new UpdateManager(remotePackages, "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader())) {
+                        updateInfo = await mgr.CheckForUpdate();
                     }
 
                     Assert.NotNull(updateInfo);
@@ -154,25 +149,21 @@ namespace Squirrel.Tests
                         File.Copy(path, Path.Combine(remotePackages, x));
                     });
 
-                    var fixture = new UpdateManager(remotePackages, "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader());
+                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
 
-                    UpdateInfo updateInfo;
-                    using (fixture)
-                    {
-                        // sync both release files
-                        await fixture.UpdateLocalReleasesFile();
-                        ReleaseEntry.BuildReleasesFile(remotePackages);
-
-                        updateInfo = await fixture.CheckForUpdate();
+                    // sync both release files
+                    await fixture.updateLocalReleasesFile();
+                    ReleaseEntry.BuildReleasesFile(remotePackages);
 
+                    using (var mgr = new UpdateManager(remotePackages, "theApp", FrameworkVersion.Net40, tempDir, new FakeUrlDownloader())) {
+                        UpdateInfo updateInfo;
+                        updateInfo = await mgr.CheckForUpdate();
                         Assert.True(updateInfo.ReleasesToApply.First().IsDelta);
 
-                        updateInfo = await fixture.CheckForUpdate(ignoreDeltaUpdates: true);
-
+                        updateInfo = await mgr.CheckForUpdate(ignoreDeltaUpdates: true);
                         Assert.False(updateInfo.ReleasesToApply.First().IsDelta);
                     }
                 }
-
             }
 
             [Fact]
@@ -220,11 +211,8 @@ namespace Squirrel.Tests
             public async Task WhenUrlResultsInWebExceptionReturnNull()
             {
                 // This should result in a WebException (which gets caught) unless you can actually access http://lol
-
                 var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net45);
-
                 var updateInfo = await fixture.CheckForUpdate();
-
                 Assert.Null(updateInfo);
             }
         }

From 2b72912ef29907ce01ec429ec29beccef7819f61 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 13:51:02 +0200
Subject: [PATCH 08/11] RootDir != RootAppDir

---
 test/ApplyReleasesTests.cs | 34 ++++++++++++++++++++--------------
 test/UpdateManagerTests.cs | 20 ++++++++++++--------
 2 files changed, 32 insertions(+), 22 deletions(-)

diff --git a/test/ApplyReleasesTests.cs b/test/ApplyReleasesTests.cs
index ddf78346..d2315374 100644
--- a/test/ApplyReleasesTests.cs
+++ b/test/ApplyReleasesTests.cs
@@ -33,8 +33,8 @@ namespace Squirrel.Tests
         {
             string tempDir;
             using (Utility.WithTempDirectory(out tempDir)) {
-                Directory.CreateDirectory(Path.Combine(tempDir, "theApp"));
-                var packages = Path.Combine(tempDir, "theApp", "packages");
+                var appDir = Directory.CreateDirectory(Path.Combine(tempDir, "theApp"));
+                var packages = Path.Combine(appDir.FullName, "packages");
                 Directory.CreateDirectory(packages);
 
                 var package = "Squirrel.Core.1.0.0.0-full.nupkg";
@@ -55,8 +55,8 @@ namespace Squirrel.Tests
             string tempDir;
             using (Utility.WithTempDirectory(out tempDir))
             {
-                Directory.CreateDirectory(Path.Combine(tempDir, "theApp"));
-                var packages = Path.Combine(tempDir, "theApp", "packages");
+                var appDir = Directory.CreateDirectory(Path.Combine(tempDir, "theApp"));
+                var packages = Path.Combine(appDir.FullName, "packages");
                 Directory.CreateDirectory(packages);
 
                 var baseFile = "Squirrel.Core.1.0.0.0-full.nupkg";
@@ -82,7 +82,8 @@ namespace Squirrel.Tests
             string tempDir;
 
             using (Utility.WithTempDirectory(out tempDir)) {
-                string packagesDir = Path.Combine(tempDir, "theApp", "packages");
+                string appDir = Path.Combine(tempDir, "theApp");
+                string packagesDir = Path.Combine(appDir, "packages");
                 Directory.CreateDirectory(packagesDir);
 
                 new[] {
@@ -90,7 +91,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.1.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.0.0.0-full.nupkg"));
                 var latestFullEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-full.nupkg"));
@@ -131,7 +132,8 @@ namespace Squirrel.Tests
             string tempDir;
 
             using (Utility.WithTempDirectory(out tempDir)) {
-                string packagesDir = Path.Combine(tempDir, "theApp", "packages");
+                string appDir = Path.Combine(tempDir, "theApp");
+                string packagesDir = Path.Combine(appDir, "packages");
                 Directory.CreateDirectory(packagesDir);
 
                 new[] {
@@ -139,7 +141,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.2.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-full.nupkg"));
                 var latestFullEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.2.0.0-full.nupkg"));
@@ -179,7 +181,8 @@ namespace Squirrel.Tests
 
             using (Utility.WithTempDirectory(out tempDir))
             {
-                string packagesDir = Path.Combine(tempDir, "theApp", "packages");
+                string appDir = Path.Combine(tempDir, "theApp");
+                string packagesDir = Path.Combine(appDir, "packages");
                 Directory.CreateDirectory(packagesDir);
 
                 new[] {
@@ -187,7 +190,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.3.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-full.nupkg"));
                 var latestFullEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.3.0.0-full.nupkg"));
@@ -228,7 +231,8 @@ namespace Squirrel.Tests
             string tempDir;
 
             using (Utility.WithTempDirectory(out tempDir)) {
-                string packagesDir = Path.Combine(tempDir, "theApp", "packages");
+                string appDir = Path.Combine(tempDir, "theApp");
+                string packagesDir = Path.Combine(appDir, "packages");
                 Directory.CreateDirectory(packagesDir);
 
                 new[] {
@@ -237,7 +241,7 @@ namespace Squirrel.Tests
                     "Squirrel.Core.1.1.0.0-full.nupkg",
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(packagesDir, x)));
 
-                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.0.0.0-full.nupkg"));
                 var deltaEntry = ReleaseEntry.GenerateFromFile(Path.Combine(packagesDir, "Squirrel.Core.1.1.0.0-delta.nupkg"));
@@ -278,7 +282,9 @@ namespace Squirrel.Tests
         {
             string tempDir;
             using (Utility.WithTempDirectory(out tempDir)) {
-                Directory.CreateDirectory(Path.Combine(tempDir, "theApp", "packages"));
+                string appDir = Path.Combine(tempDir, "theApp");
+                string packagesDir = Path.Combine(appDir, "packages");
+                Directory.CreateDirectory(packagesDir);
 
                 new[] {
                     "Squirrel.Core.1.0.0.0-full.nupkg",
@@ -286,7 +292,7 @@ namespace Squirrel.Tests
                 }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(tempDir, "theApp", "packages", x)));
 
                 var urlDownloader = new FakeUrlDownloader();
-                var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                 var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Squirrel.Core.1.0.0.0-full.nupkg"));
                 var deltaEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Squirrel.Core.1.1.0.0-delta.nupkg"));
diff --git a/test/UpdateManagerTests.cs b/test/UpdateManagerTests.cs
index c08fb64b..0caf448a 100644
--- a/test/UpdateManagerTests.cs
+++ b/test/UpdateManagerTests.cs
@@ -19,7 +19,8 @@ namespace Squirrel.Tests
             {
                 string tempDir;
                 using (Utility.WithTempDirectory(out tempDir)) {
-                    var packageDir = Directory.CreateDirectory(Path.Combine(tempDir, "theApp", "packages"));
+                    var appDir = Path.Combine(tempDir, "theApp");
+                    var packageDir = Directory.CreateDirectory(Path.Combine(appDir, "packages"));
 
                     new[] {
                         "Squirrel.Core.1.0.0.0-full.nupkg",
@@ -27,7 +28,7 @@ namespace Squirrel.Tests
                         "Squirrel.Core.1.1.0.0-full.nupkg",
                     }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(tempDir, "theApp", "packages", x)));
 
-                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                    var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                     await fixture.updateLocalReleasesFile();
 
@@ -45,7 +46,8 @@ namespace Squirrel.Tests
                 string tempDir;
                 using (Utility.WithTempDirectory(out tempDir))
                 {
-                    var localPackages = Path.Combine(tempDir, "theApp", "packages");
+                    var appDir = Path.Combine(tempDir, "theApp");
+                    var localPackages = Path.Combine(appDir, "packages");
                     var remotePackages = Path.Combine(tempDir, "releases");
                     Directory.CreateDirectory(localPackages);
                     Directory.CreateDirectory(remotePackages);
@@ -61,7 +63,7 @@ namespace Squirrel.Tests
                         File.Copy(path, Path.Combine(remotePackages, x));
                     });
 
-                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                    var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
                         
                     // sync both release files
                     await fixture.updateLocalReleasesFile();
@@ -84,7 +86,8 @@ namespace Squirrel.Tests
                 string tempDir;
                 using (Utility.WithTempDirectory(out tempDir))
                 {
-                    var localPackages = Path.Combine(tempDir, "theApp", "packages");
+                    var appDir = Path.Combine(tempDir, "theApp");
+                    var localPackages = Path.Combine(appDir, "packages");
                     var remotePackages = Path.Combine(tempDir, "releases");
                     Directory.CreateDirectory(localPackages);
                     Directory.CreateDirectory(remotePackages);
@@ -108,7 +111,7 @@ namespace Squirrel.Tests
                         File.Copy(path, Path.Combine(remotePackages, x));
                     });
 
-                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                    var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                     // sync both release files
                     await fixture.updateLocalReleasesFile();
@@ -130,7 +133,8 @@ namespace Squirrel.Tests
                 string tempDir;
                 using (Utility.WithTempDirectory(out tempDir))
                 {
-                    var localPackages = Path.Combine(tempDir, "theApp", "packages");
+                    var appDir = Path.Combine(tempDir, "theApp");
+                    var localPackages = Path.Combine(appDir, "packages");
                     var remotePackages = Path.Combine(tempDir, "releases");
                     Directory.CreateDirectory(localPackages);
                     Directory.CreateDirectory(remotePackages);
@@ -149,7 +153,7 @@ namespace Squirrel.Tests
                         File.Copy(path, Path.Combine(remotePackages, x));
                     });
 
-                    var fixture = new UpdateManager.ApplyReleasesImpl(tempDir);
+                    var fixture = new UpdateManager.ApplyReleasesImpl(appDir);
 
                     // sync both release files
                     await fixture.updateLocalReleasesFile();

From bc771de4b328acf0c71a63c14d3389f648facaba Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 14:51:38 +0200
Subject: [PATCH 09/11] Run clean *after* apply, dummy

---
 src/Squirrel/ReleaseEntry.cs                |  3 ++-
 src/Squirrel/UpdateManager.ApplyReleases.cs | 17 ++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/Squirrel/ReleaseEntry.cs b/src/Squirrel/ReleaseEntry.cs
index ab01370e..864c0e1f 100644
--- a/src/Squirrel/ReleaseEntry.cs
+++ b/src/Squirrel/ReleaseEntry.cs
@@ -150,7 +150,7 @@ namespace Squirrel
             }
         }
 
-        public static void BuildReleasesFile(string releasePackagesDir)
+        public static List<ReleaseEntry> BuildReleasesFile(string releasePackagesDir)
         {
             var packagesDir = new DirectoryInfo(releasePackagesDir);
 
@@ -176,6 +176,7 @@ namespace Squirrel
             }
 
             File.Move(tempFile, target);
+            return entries;
         }
 
         static bool filenameIsDeltaFile(string filename)
diff --git a/src/Squirrel/UpdateManager.ApplyReleases.cs b/src/Squirrel/UpdateManager.ApplyReleases.cs
index edbcedff..74200006 100644
--- a/src/Squirrel/UpdateManager.ApplyReleases.cs
+++ b/src/Squirrel/UpdateManager.ApplyReleases.cs
@@ -29,16 +29,16 @@ namespace Squirrel
             {
                 progress = progress ?? (_ => { });
 
-                await cleanDeadVersions(updateInfo.CurrentlyInstalledVersion != null ? updateInfo.CurrentlyInstalledVersion.Version : null);
+                var release = await createFullPackagesFromDeltas(updateInfo.ReleasesToApply, updateInfo.CurrentlyInstalledVersion);
                 progress(10);
 
-                var release = await createFullPackagesFromDeltas(updateInfo.ReleasesToApply, updateInfo.CurrentlyInstalledVersion);
+                await installPackageToAppDir(updateInfo, release);
                 progress(50);
 
-                await installPackageToAppDir(updateInfo, release);
-                progress(95);
+                var currentReleases = await updateLocalReleasesFile();
+                progress(75);
 
-                await updateLocalReleasesFile();
+                await cleanDeadVersions(currentReleases.MaxBy(x => x.Version).First().Version);
                 progress(100);
             }
 
@@ -47,7 +47,6 @@ namespace Squirrel
                 version = version ?? new Version(255, 255, 255, 255);
                 this.Log().Info("Uninstalling version '{0}'", version);
 
-
                 // find all the old releases (and this one)
                 var directoriesToDelete = getOldReleases(version)
                     .Concat(new [] { getDirectoryForRelease(version) })
@@ -302,16 +301,16 @@ namespace Squirrel
 
                 await toCleanup.ForEachAsync(async x => {
                     try {
-                        await Utility.DeleteDirectory(x.FullName);
+                        await Utility.DeleteDirectoryWithFallbackToNextReboot(x.FullName);
                     } catch (UnauthorizedAccessException ex) {
                         this.Log().WarnException("Couldn't delete directory: " + x.FullName, ex);
                     }
                 });
             }
 
-            internal async Task updateLocalReleasesFile()
+            internal async Task<List<ReleaseEntry>> updateLocalReleasesFile()
             {
-                await Task.Run(() => ReleaseEntry.BuildReleasesFile(Utility.PackageDirectoryForAppDir(rootAppDirectory)));
+                return await Task.Run(() => ReleaseEntry.BuildReleasesFile(Utility.PackageDirectoryForAppDir(rootAppDirectory)));
             }
 
             IEnumerable<DirectoryInfo> getReleases()

From 98da7e789e56b218bb622a0666eab900e094e756 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 15:18:07 +0200
Subject: [PATCH 10/11] Make sure UpdateManager can do clean installs

---
 test/UpdateManagerTests.cs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/test/UpdateManagerTests.cs b/test/UpdateManagerTests.cs
index 0caf448a..b2832679 100644
--- a/test/UpdateManagerTests.cs
+++ b/test/UpdateManagerTests.cs
@@ -40,6 +40,37 @@ namespace Squirrel.Tests
                 }
             }
 
+            [Fact]
+            public async Task InitialInstallSmokeTest()
+            {
+                string tempDir;
+                using (Utility.WithTempDirectory(out tempDir)) {
+                    var remotePackageDir = Directory.CreateDirectory(Path.Combine(tempDir, "remotePackages"));
+                    var localAppDir = Path.Combine(tempDir, "theApp");
+
+                    new[] {
+                        "Squirrel.Core.1.0.0.0-full.nupkg",
+                    }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(remotePackageDir.FullName, x)));
+
+                    using (var fixture = new UpdateManager(remotePackageDir.FullName, "theApp", FrameworkVersion.Net45, tempDir)) {
+                        var updateInfo = await fixture.CheckForUpdate();
+                        await fixture.DownloadReleases(updateInfo.ReleasesToApply);
+                        await fixture.ApplyReleases(updateInfo);
+                    }
+
+                    var releasePath = Path.Combine(localAppDir, "packages", "RELEASES");
+                    File.Exists(releasePath).ShouldBeTrue();
+
+                    var entries = ReleaseEntry.ParseReleaseFile(File.ReadAllText(releasePath, Encoding.UTF8));
+                    entries.Count().ShouldEqual(1);
+
+                    new[] {
+                        "ReactiveUI.dll",
+                        "NSync.Core.dll",
+                    }.ForEach(x => File.Exists(Path.Combine(localAppDir, "app-1.0.0.0", x)).ShouldBeTrue());
+                }
+            }
+
             [Fact]
             public async Task WhenBothFilesAreInSyncNoUpdatesAreApplied()
             {

From a9e5cf75d1d4bdee3c4469f815ecc75fe0dc0510 Mon Sep 17 00:00:00 2001
From: Paul Betts <paul@paulbetts.org>
Date: Fri, 8 Aug 2014 15:24:59 +0200
Subject: [PATCH 11/11] Add an explicit FullInstall method

This doesn't do everything we want yet like run the application, but it's a
start.
---
 src/Squirrel/IUpdateManager.cs | 6 ++++++
 src/Squirrel/UpdateManager.cs  | 7 +++++++
 test/UpdateManagerTests.cs     | 4 +---
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/Squirrel/IUpdateManager.cs b/src/Squirrel/IUpdateManager.cs
index 96bd7509..9f580cee 100644
--- a/src/Squirrel/IUpdateManager.cs
+++ b/src/Squirrel/IUpdateManager.cs
@@ -44,6 +44,12 @@ namespace Squirrel
         /// will return values from 0-100 and Complete, or Throw</param>
         Task ApplyReleases(UpdateInfo updateInfo, Action<int> progress = null);
 
+        /// <summary>
+        /// Completely Installs a targeted app
+        /// </summary>
+        /// <returns>Completion</returns>
+        Task FullInstall();
+
         /// <summary>
         /// Completely uninstalls the targeted app
         /// </summary>
diff --git a/src/Squirrel/UpdateManager.cs b/src/Squirrel/UpdateManager.cs
index f01f219f..a83e3aa2 100644
--- a/src/Squirrel/UpdateManager.cs
+++ b/src/Squirrel/UpdateManager.cs
@@ -65,6 +65,13 @@ namespace Squirrel
             await applyReleases.ApplyReleases(updateInfo, progress);
         }
 
+        public async Task FullInstall()
+        {
+            var updateInfo = await CheckForUpdate();
+            await DownloadReleases(updateInfo.ReleasesToApply);
+            await ApplyReleases(updateInfo);
+        }
+
         public async Task FullUninstall()
         {
             var applyReleases = new ApplyReleasesImpl(rootAppDirectory);
diff --git a/test/UpdateManagerTests.cs b/test/UpdateManagerTests.cs
index b2832679..f85dc88e 100644
--- a/test/UpdateManagerTests.cs
+++ b/test/UpdateManagerTests.cs
@@ -53,9 +53,7 @@ namespace Squirrel.Tests
                     }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(remotePackageDir.FullName, x)));
 
                     using (var fixture = new UpdateManager(remotePackageDir.FullName, "theApp", FrameworkVersion.Net45, tempDir)) {
-                        var updateInfo = await fixture.CheckForUpdate();
-                        await fixture.DownloadReleases(updateInfo.ReleasesToApply);
-                        await fixture.ApplyReleases(updateInfo);
+                        await fixture.FullInstall();
                     }
 
                     var releasePath = Path.Combine(localAppDir, "packages", "RELEASES");