Merge pull request #317 from lwronski/scala-update

Add command to updating scala-cli

Author: romanowski

modules/cli/src/main/scala/scala/cli/ScalaCli.scala

@@ -32,6 +32,7 @@ object ScalaCli extends CommandsEntryPoint {
     Run,
     SetupIde,
     Test,
+    Update,
     Version
   )
 

modules/cli/src/main/scala/scala/cli/commands/CommandUtils.scala

@@ -0,0 +1,12 @@
+package scala.cli.commands
+
+object CommandUtils {
+
+  def isOutOfDateVersion(newVersion: String, oldVersion: String): Boolean = {
+    import coursier.core.Version
+
+    Version(newVersion) > Version(oldVersion)
+  }
+
+  lazy val shouldCheckUpdate: Boolean = scala.util.Random.nextInt % 10 == 1
+}

modules/cli/src/main/scala/scala/cli/commands/Compile.scala

@@ -18,6 +18,8 @@ object Compile extends ScalaCommand[CompileOptions] {
       logger,
       Some(name)
     )
+    if (CommandUtils.shouldCheckUpdate)
+      Update.checkUpdateSafe(logger)
 
     val cross = options.cross.cross.getOrElse(false)
     if (options.classPath && cross) {

modules/cli/src/main/scala/scala/cli/commands/InstallHome.scala

@@ -9,12 +9,6 @@ import scala.util.{Properties, Try}
 object InstallHome extends ScalaCommand[InstallHomeOptions] {
   override def hidden: Boolean = true
 
-  private def isOutOfDate(newVersion: String, oldVersion: String): Boolean = {
-    import coursier.core.Version
-
-    Version(newVersion) > Version(oldVersion)
-  }
-
   private def logEqual(version: String) = {
     System.err.println(
       s"Scala-cli $version is already installed and up-to-date."
@@ -63,7 +57,7 @@ object InstallHome extends ScalaCommand[InstallHomeOptions] {
     if (os.exists(binDirPath))
       if (options.force) () // skip logging
       else if (newVersion == oldVersion) logEqual(newVersion)
-      else if (isOutOfDate(newVersion, oldVersion))
+      else if (CommandUtils.isOutOfDateVersion(newVersion, oldVersion))
         logUpdate(options.env, newVersion, oldVersion)
       else logDowngrade(options.env, newVersion, oldVersion)
 
@@ -93,9 +87,18 @@ object InstallHome extends ScalaCommand[InstallHomeOptions] {
           updater.applyUpdate(update)
         }
 
-      if (didUpdate) "Profile was updated"
-
       println(s"Successfully installed scala-cli $newVersion")
+
+      if (didUpdate) {
+        if (Properties.isLinux)
+          println(
+            s"""|Profile file(s) updated.
+                |To run scala-cli, log out and log back in, or run 'source ~/.profile'""".stripMargin
+          )
+        if (Properties.isMac)
+          println("To run scala-cli, open new terminal or run 'source ~/.profile'")
+      }
+
     }
   }
 }

modules/cli/src/main/scala/scala/cli/commands/Run.scala

@@ -45,6 +45,8 @@ object Run extends ScalaCommand[RunOptions] {
       logger,
       Some(name)
     )
+    if (CommandUtils.shouldCheckUpdate)
+      Update.checkUpdateSafe(logger)
 
     if (options.watch.watch) {
       val watcher = Build.watch(

modules/cli/src/main/scala/scala/cli/commands/Test.scala

@@ -25,6 +25,8 @@ object Test extends ScalaCommand[TestOptions] {
       logger,
       Some(name)
     )
+    if (CommandUtils.shouldCheckUpdate)
+      Update.checkUpdateSafe(logger)
 
     val initialBuildOptions = options.buildOptions
     val bloopRifleConfig    = options.shared.bloopRifleConfig()

modules/cli/src/main/scala/scala/cli/commands/Update.scala

@@ -0,0 +1,127 @@
+package scala.cli.commands
+
+import caseapp._
+
+import scala.build.Logger
+import scala.io.StdIn.readLine
+import scala.util.{Failure, Properties, Success, Try}
+
+object Update extends ScalaCommand[UpdateOptions] {
+
+  private def updateScalaCli(options: UpdateOptions, newVersion: String) = {
+    if (coursier.paths.Util.useAnsiOutput()) {
+      println(s"Do you want to update scala-cli to version $newVersion [Y/n]")
+      val response = readLine()
+      if (response != "Y") {
+        System.err.println("Abort")
+        sys.exit(1)
+      }
+    }
+    else if (!options.force) {
+      System.err.println(s"To update scala-cli to $newVersion pass -f or --force")
+      sys.exit(1)
+    }
+
+    val installScript =
+      os.proc("curl", "-sSLf", "https://virtuslab.github.io/scala-cli-packages/scala-setup.sh")
+        .spawn(stderr = os.Inherit)
+
+    // format: off
+    val res = os.proc(
+      "sh", "-s", "--",
+      "--version", newVersion,
+      "--force",
+      "--binary-name", options.binaryName,
+      "--bin-dir", options.installDirPath,
+    ).call(
+      cwd = os.pwd,
+      stdin = installScript.stdout,
+      stdout = os.Inherit,
+      check = false,
+      mergeErrIntoOut = true
+    )
+    // format: on
+    val output = res.out.text().trim
+    if (res.exitCode != 0) {
+      System.err.println(s"Error during updating scala-cli: $output")
+      sys.exit(1)
+    }
+  }
+
+  def update(options: UpdateOptions, scalaCliBinPath: os.Path) = {
+    val currentVersion = Try {
+      os.proc(scalaCliBinPath, "version").call(cwd = os.pwd).out.text().trim
+    }.toOption.getOrElse("0.0.0")
+
+    lazy val newestScalaCliVersion = {
+      val resp =
+        os.proc("curl", "--silent", "https://github.com/VirtusLab/scala-cli/releases/latest")
+          .call(cwd = os.pwd, mergeErrIntoOut = true, check = false)
+          .out.text().trim
+
+      val scalaCliVersionRegex = "tag/v(.*)\"".r
+      scalaCliVersionRegex.findFirstMatchIn(resp).map(_.group(1))
+    }.getOrElse(
+      sys.error("Can not resolve ScalaCLI version to update")
+    )
+
+    val isOutdated = CommandUtils.isOutOfDateVersion(newestScalaCliVersion, currentVersion)
+
+    if (!options.isInternalRun)
+      if (isOutdated)
+        updateScalaCli(options, newestScalaCliVersion)
+      else println("ScalaCLI is up-to-date")
+    else if (isOutdated)
+      println(
+        s"""Your ScalaCLI $currentVersion is outdated, please update ScalaCLI to $newestScalaCliVersion 
+           |Run 'curl -sSLf https://virtuslab.github.io/scala-cli-packages/scala-setup.sh | sh' to update ScalaCLI.""".stripMargin
+      )
+  }
+
+  def checkUpdate(options: UpdateOptions) = {
+
+    val scalaCliBinPath = options.installDirPath / options.binaryName
+
+    lazy val execScalaCliPath = os.proc("which", "scala-cli").call(
+      cwd = os.pwd,
+      mergeErrIntoOut = true,
+      check = false
+    ).out.text().trim
+    lazy val isScalaCliInPath = // if binDir is non empty, we not except scala-cli in PATH, it is useful in tests
+      execScalaCliPath.contains(options.installDirPath.toString()) || options.binDir.isDefined
+
+    if (!os.exists(scalaCliBinPath) || !isScalaCliInPath) {
+      if (!options.isInternalRun) {
+        System.err.println(
+          "Scala CLI was not installed by the installation script, please use your package manager to update scala-cli."
+        )
+        sys.exit(1)
+      }
+    }
+    else if (Properties.isWin) {
+      if (!options.isInternalRun) {
+        System.err.println("ScalaCLI update is not supported on Windows.")
+        sys.exit(1)
+      }
+    }
+    else update(options, scalaCliBinPath)
+  }
+
+  def run(options: UpdateOptions, args: RemainingArgs): Unit =
+    checkUpdate(options)
+
+  def checkUpdateSafe(logger: Logger): Unit = {
+    Try {
+      val classesDir =
+        this.getClass.getProtectionDomain.getCodeSource.getLocation.toURI.toString
+      val binRepoDir = build.Directories.default().binRepoDir.toString()
+      // log about update only if scala-cli was installed from installation script
+      if (classesDir.contains(binRepoDir))
+        checkUpdate(UpdateOptions(isInternalRun = true))
+    } match {
+      case Failure(ex) =>
+        logger.debug(s"Ignoring error during checking update: $ex")
+      case Success(_) => ()
+    }
+  }
+}

modules/cli/src/main/scala/scala/cli/commands/UpdateOptions.scala

@@ -0,0 +1,29 @@
+package scala.cli.commands
+
+import caseapp._
+
+// format: off
+@HelpMessage("Update scala-cli - it works only for installation script")
+final case class UpdateOptions(
+  @Group("Update")
+  @HelpMessage("Binary name")
+    binaryName: String = "scala-cli",
+  @Group("Update")
+  @HelpMessage("Binary directory")
+    binDir: Option[String] = None,
+  @Name("f")
+  @HelpMessage("Update scala-cli if is outdated")
+    force: Boolean = false,
+  @Hidden
+    isInternalRun: Boolean = false
+) {
+  // format: on
+  lazy val binDirPath = binDir.map(os.Path(_, os.pwd))
+  lazy val installDirPath =
+    binDirPath.getOrElse(scala.build.Directories.default().binRepoDir / binaryName)
+}
+
+object UpdateOptions {
+  implicit lazy val parser: Parser[UpdateOptions] = Parser.derive
+  implicit lazy val help: Help[UpdateOptions]     = Help.derive
+}

modules/integration/src/test/scala/scala/cli/integration/UpdateTests.scala

@@ -0,0 +1,110 @@
+package scala.cli.integration
+
+import com.eed3si9n.expecty.Expecty.expect
+
+import scala.util.Properties
+
+class UpdateTests extends munit.FunSuite {
+
+  val firstVersion           = "0.0.1"
+  val dummyScalaCliFirstName = "DummyScalaCli-1.scala"
+  val dummyScalaCliBinName   = "scala-cli-dummy-test"
+  val testInputs = TestInputs(
+    Seq(
+      os.rel / dummyScalaCliFirstName ->
+        s"""
+           |object DummyScalaCli extends App {
+           |  println(\"$firstVersion\")
+           |}""".stripMargin
+    )
+  )
+
+  private def packageDummyScalaCli(root: os.Path, dummyScalaCliFileName: String, output: String) = {
+    // format: off
+    val cmd = Seq[os.Shellable](
+      TestUtil.cli, "package", dummyScalaCliFileName, "-o", output
+    )
+    // format: on
+    os.proc(cmd).call(
+      cwd = root,
+      stdin = os.Inherit,
+      stdout = os.Inherit
+    )
+  }
+
+  private def installScalaCli(
+    root: os.Path,
+    binVersion: String,
+    binDirPath: os.Path
+  ) = {
+    // format: off
+    val cmdInstallVersion = Seq[os.Shellable](
+      TestUtil.cli, "install-home",
+      "--env",
+      "--scala-cli-binary-path", binVersion,
+      "--binary-name", dummyScalaCliBinName,
+      "--bin-dir", binDirPath,
+      "--force"
+    )
+    // format: on
+    os.proc(cmdInstallVersion).call(
+      cwd = root,
+      stdin = os.Inherit,
+      stdout = os.Inherit
+    )
+  }
+
+  def runUpdate(): Unit = {
+
+    testInputs.fromRoot { root =>
+      val binDirPath = root / ".scala" / "scala-cli"
+
+      val binDummyScalaCliFirst = dummyScalaCliFirstName.stripSuffix(".scala").toLowerCase
+
+      packageDummyScalaCli(root, dummyScalaCliFirstName, binDummyScalaCliFirst)
+
+      // install 1 version
+      installScalaCli(root, binDummyScalaCliFirst, binDirPath)
+
+      val v1Install = os.proc(binDirPath / dummyScalaCliBinName).call(
+        cwd = root,
+        stdin = os.Inherit
+      ).out.text().trim
+      expect(v1Install == firstVersion)
+
+      // update to newest version
+      // format: off
+      val cmdUpdate = Seq[os.Shellable](
+        TestUtil.cli,
+        "update",
+        "--binary-name", dummyScalaCliBinName,
+        "--bin-dir", binDirPath,
+        "--force"
+      )
+      // format: on
+      os.proc(cmdUpdate).call(
+        cwd = root,
+        stdin = os.Inherit,
+        stdout = os.Inherit
+      )
+
+      val nextVersion = os.proc(binDirPath / dummyScalaCliBinName, "version").call(
+        cwd = root,
+        stdin = os.Inherit
+      ).out.text().trim
+
+      expect(firstVersion != nextVersion)
+    }
+  }
+
+  if (!Properties.isWin)
+    test("updating dummy scala-cli using update command") {
+      runUpdate()
+    }
+
+  test("run update before run/test/compile should not return exit code") {
+    val res = os.proc(TestUtil.cli, "update", "--is-internal-run").call(cwd = os.pwd)
+    expect(res.exitCode == 0)
+  }
+
+}

website/docs/reference/cli-options.md

@@ -309,6 +309,7 @@ Available in commands:
 - [`run`](./commands.md#run)
 - [`setup-ide`](./commands.md#setup-ide)
 - [`test`](./commands.md#test)
+- [`update`](./commands.md#update)
 - [`version`](./commands.md#version)
 
 
@@ -959,6 +960,30 @@ Name of test framework's runner class to use while running tests
 
 Fail if no test suites were run
 
+## Update options
+
+Available in commands:
+- [`update`](./commands.md#update)
+
+
+<!-- Automatically generated, DO NOT EDIT MANUALLY -->
+
+#### `--binary-name`
+
+Binary name
+
+#### `--bin-dir`
+
+Binary directory
+
+#### `--force`
+
+Aliases: `-f`
+
+Update scala-cli if is outdated
+
+#### `--is-internal-run`
+
 ## Watch options
 
 Available in commands: