From 77142bd99eb52a2d5145b0c12c5c9e88ae72a271 Mon Sep 17 00:00:00 2001
From: Lea Anthony <lea.anthony@gmail.com>
Date: Sun, 12 May 2019 12:59:35 +1000
Subject: [PATCH] feat: support version flag

---
 cmd/wails/8_update.go | 97 ++++++++++++++++++++++++++++++-------------
 1 file changed, 69 insertions(+), 28 deletions(-)

diff --git a/cmd/wails/8_update.go b/cmd/wails/8_update.go
index 8f8c399e..d01c9745 100644
--- a/cmd/wails/8_update.go
+++ b/cmd/wails/8_update.go
@@ -12,15 +12,17 @@ import (
 func init() {
 
 	var prereleaseRequired bool
+	var specificVersion string
 
 	// var forceRebuild = false
 	checkSpinner := spinner.NewSpinner()
 	checkSpinner.SetSpinSpeed(50)
 
 	commandDescription := `This command allows you to update your version of Wails.`
-	updateCmd := app.Command("update", "Check for Updates.").
+	updateCmd := app.Command("update", "Update to newer [pre]releases or specific versions").
 		LongDescription(commandDescription).
-		BoolFlag("pre", "Update to latest Prerelease", &prereleaseRequired)
+		BoolFlag("pre", "Update to latest Prerelease", &prereleaseRequired).
+		StringFlag("version", "Install a specific version (Overrides other flags)", &specificVersion)
 
 	updateCmd.Action(func() error {
 
@@ -34,11 +36,24 @@ func init() {
 		github := cmd.NewGitHubHelper()
 		var desiredVersion *cmd.SemanticVersion
 		var err error
+		var valid bool
 
-		if prereleaseRequired {
-			desiredVersion, err = github.GetLatestPreRelease()
+		if len(specificVersion) > 0 {
+			// Check if this is a valid version
+			valid, err = github.IsValidTag(specificVersion)
+			if err == nil {
+				if !valid {
+					err = fmt.Errorf("version '%s' is invalid", specificVersion)
+				} else {
+					desiredVersion, err = cmd.NewSemanticVersion(specificVersion)
+				}
+			}
 		} else {
-			desiredVersion, err = github.GetLatestStableRelease()
+			if prereleaseRequired {
+				desiredVersion, err = github.GetLatestPreRelease()
+			} else {
+				desiredVersion, err = github.GetLatestStableRelease()
+			}
 		}
 		if err != nil {
 			checkSpinner.Error(err.Error())
@@ -47,43 +62,69 @@ func init() {
 		checkSpinner.Success()
 		fmt.Println()
 
-		fmt.Println("  Current Version   : " + cmd.Version)
-		if prereleaseRequired {
-			fmt.Printf("  Latest Prerelease : v%s\n", desiredVersion)
+		fmt.Println("    Current Version : " + cmd.Version)
+
+		if len(specificVersion) > 0 {
+			fmt.Printf("    Desired Version : v%s\n", desiredVersion)
 		} else {
-			fmt.Printf("  Latest Release    : v%s\n", desiredVersion)
+			if prereleaseRequired {
+				fmt.Printf("  Latest Prerelease : v%s\n", desiredVersion)
+			} else {
+				fmt.Printf("     Latest Release : v%s\n", desiredVersion)
+			}
 		}
 
-		return updateToVersion(desiredVersion)
+		return updateToVersion(desiredVersion, len(specificVersion) > 0)
 	})
 }
 
-func updateToVersion(version *cmd.SemanticVersion) error {
+func updateToVersion(targetVersion *cmd.SemanticVersion, force bool) error {
 
 	// Early exit
-	if version.String() == cmd.Version {
+	if targetVersion.String() == cmd.Version {
 		logger.Green("Looks like you're up to date!")
 		return nil
 	}
 
-	compareVersion := cmd.Version
-	if version.IsPreRelease() {
-		compareVersion += "-0"
+	var desiredVersion string
+
+	if !force {
+
+		compareVersion := cmd.Version
+
+		currentVersion, err := cmd.NewSemanticVersion(compareVersion)
+		if err != nil {
+			return err
+		}
+
+		// Release -> Pre-Release = Massage current version to prerelease format
+		if targetVersion.IsPreRelease() && currentVersion.IsRelease() {
+			currentVersion, err = cmd.NewSemanticVersion(compareVersion + "-0")
+			if err != nil {
+				return err
+			}
+		}
+		// Pre-Release -> Release = Massage target version to prerelease format
+		if targetVersion.IsRelease() && currentVersion.IsPreRelease() {
+			targetVersion, err = cmd.NewSemanticVersion(targetVersion.String() + "-0")
+			if err != nil {
+				return err
+			}
+		}
+
+		desiredVersion = "v" + targetVersion.String()
+
+		// Compare
+		success, err := targetVersion.IsGreaterThan(currentVersion)
+		if !success {
+			logger.Red("The requested version is lower than the current version.")
+			logger.Red("If this is what you really want to do, use `wails update -version %s`", desiredVersion)
+			return nil
+		}
+	} else {
+		desiredVersion = "v" + targetVersion.String()
 	}
 
-	currentVersion, err := cmd.NewSemanticVersion(compareVersion)
-	if err != nil {
-		return err
-	}
-
-	// Compare
-	success, err := version.IsGreaterThan(currentVersion)
-	if !success {
-		logger.Red("The requested version is lower than the current version. Aborting.")
-		return nil
-	}
-
-	desiredVersion := "v" + version.String()
 	fmt.Println()
 	updateSpinner := spinner.NewSpinner()
 	updateSpinner.SetSpinSpeed(40)