Tidy up init command impl, make it unpack into current folder

main/init/package.mill

@@ -6,7 +6,7 @@ import scala.util.matching.Regex
 object `package` extends RootModule with build.MillPublishScalaModule {
   def moduleDeps = Seq(build.main)
 
-  override def resources = T.sources {
+  override def resources = T {
     super.resources() ++ Seq(exampleList())
   }
 

main/init/src/mill/init/InitModule.scala

@@ -3,11 +3,8 @@ package mill.init
 import mainargs.{Flag, arg}
 import mill.api.IO
 import mill.define.{Discover, ExternalModule}
-import mill.util.Util.download
 import mill.{Command, Module, T}
 
-import java.io.IOException
-import java.util.UUID
 import scala.util.{Failure, Success, Try, Using}
 
 object InitModule extends ExternalModule with InitModule {
@@ -36,52 +33,60 @@ trait InitModule extends Module {
   ): Command[Seq[String]] =
     T.command {
       usingExamples { examples =>
-        val result: Try[(Seq[String], String)] = exampleId match {
+        exampleId match {
           case None =>
             val exampleIds: Seq[ExampleId] = examples.map { case (exampleId, _) => exampleId }
             def fullMessage(exampleIds: Seq[ExampleId]) =
               msg + "\n\n" + exampleIds.mkString("\n") + "\n\n" + msg
-            if (showAll.value)
-              Success((exampleIds, fullMessage(exampleIds)))
+            if (showAll.value) (exampleIds, fullMessage(exampleIds))
             else {
               val toShow = List("basic", "builds", "web")
-              val filteredIds =
-                exampleIds.filter(_.split('/').lift.apply(1).exists(toShow.contains))
-              Success((filteredIds, fullMessage(filteredIds)))
+              val filteredIds = exampleIds
+                .filter(_.split('/').lift.apply(1).exists(toShow.contains))
+
+              (filteredIds, fullMessage(filteredIds))
             }
+
           case Some(value) =>
-            val result: Try[(Seq[String], String)] = for {
-              url <- examples.toMap.get(value).toRight(new Exception(
-                moduleNotExistMsg(value)
-              )).toTry
-              extractedDirName = {
-                val zipName = url.split('/').last
-                if (zipName.toLowerCase.endsWith(".zip")) zipName.dropRight(4) else zipName
-              }
-              downloadDir = T.workspace
-              downloadPath = downloadDir / extractedDirName
-              _ <- if (os.exists(downloadPath)) Failure(new IOException(
-                directoryExistsMsg(downloadPath.toString)
-              ))
-              else Success(())
-              path <-
-                Try({
-                  val tmpName = UUID.randomUUID().toString + ".zip"
-                  val downloaded = download(url, os.rel / tmpName)(downloadDir)
-                  val unpacked = IO.unpackZip(downloaded.path, os.rel)(downloadDir)
-                  Try(os.remove(downloaded.path))
-                  unpacked
-                }).recoverWith(ex =>
-                  Failure(
-                    new IOException(s"Couldn't download example: [$value];\n ${ex.getMessage}")
-                  )
-                )
-            } yield (Seq(path.path.toString()), s"Example downloaded to [$downloadPath]")
+            val url = examples.toMap.get(value).getOrElse(sys.error(moduleNotExistMsg(value)))
+            println(s"Downloading example from $url...")
+            val zipName = url.split('/').last
+            val extractedDirName = zipName.stripSuffix(".zip")
+            val downloaded = os.temp(requests.get(url))
+            println(s"Unpacking example...")
+            val unpackPath = IO.unpackZip(downloaded, os.rel)
+            val extractedPath = T.dest / extractedDirName
+            val conflicting = for {
+              p <- os.walk(extractedPath)
+              val rel = p.relativeTo(extractedPath)
+              if os.exists(T.workspace / rel)
+            } yield rel
+
+            if (conflicting.nonEmpty) {
+              throw new Exception(
+                "Unable to unpack example because it conflicts with existing file: " +
+                  conflicting.mkString(", ")
+              )
+            }
+
+            for (p <- os.walk(extractedPath)) {
+              println(p.relativeTo(extractedPath))
+            }
+
+            // Remove any existing bootstrap script since the example will come with one
+            os.remove(T.workspace / "mill")
+            os.copy.apply(extractedPath, T.workspace, mergeFolders = true)
+
+            // Make sure the `./mill` launcher is executable
+            os.perms.set(T.workspace / "mill", "rwxrwxrwx")
 
-            result
+            (
+              Seq(unpackPath.path.toString()),
+              s"Example download and unpacked to [${T.workspace}]; " +
+                "See `build.mill` for an explanation of this example and instructions on how to use it"
+            )
         }
-        result
-      }.flatten match {
+      } match {
         case Success((ret, msg)) =>
           T.log.outputStream.println(msg)
           ret

main/init/test/src/mill/init/InitModuleTests.scala

@@ -46,27 +46,6 @@ object InitModuleTests extends TestSuite {
         assert(results.failing.keyCount == 1)
         assert(errStream.toString.contains(initmodule.moduleNotExistMsg(nonExistingModuleId)))
       }
-      test("mill init errors if directory already exist") {
-        type ExampleId = String
-        type ExampleUrl = String
-        val examplesList =
-          Using(initmodule.getClass.getClassLoader.getResourceAsStream("exampleList.txt")) {
-            examplesSource =>
-              val reader = upickle.default.reader[Seq[(ExampleId, ExampleUrl)]]
-              val examples: Seq[(ExampleId, ExampleUrl)] =
-                upickle.default.read(examplesSource)(reader)
-              examples
-          }.get
-        val exampleId = examplesList.head._1
-        val targetDir = examplesList.head._2.dropRight(4).split("/").last // dropping .zip
-
-        val targetPath = initmodule.millSourcePath / targetDir
-        os.makeDir(targetPath)
-        val results = evaluator.evaluator.evaluate(Agg(initmodule.init(Some(exampleId))))
-        assert(results.failing.keyCount == 1)
-        assert(errStream.toString.contains(initmodule.directoryExistsMsg(targetPath.toString())))
-
-      }
     }
   }
 }