tidy up root folder

6 files changed, 210 insertions, 4 deletions

diff --git a/ci/shared.sc b/ci/shared.sc
new file mode 100644
index 00000000..c7656961
--- /dev/null
+++ b/ci/shared.sc
@@ -0,0 +1,154 @@
+/**
+  * Utility code that is shared between our SBT build and our Mill build. SBT
+  * calls this by shelling out to Ammonite in a subprocess, while Mill loads it
+  * via import $file
+  */
+
+import ammonite.ops.{write, Path, mkdir, RelPath, up}
+
+def argNames(n: Int) = {
+  val uppercases = (0 until n).map("T" + _)
+  val lowercases = uppercases.map(_.toLowerCase)
+  val typeArgs   = uppercases.mkString(", ")
+  val zipArgs    = lowercases.mkString(", ")
+  (lowercases, uppercases, typeArgs, zipArgs)
+}
+def generateApplyer(dir: Path) = {
+  def generate(n: Int) = {
+    val (lowercases, uppercases, typeArgs, zipArgs) = argNames(n)
+    val parameters = lowercases.zip(uppercases).map { case (lower, upper) => s"$lower: TT[$upper]" }.mkString(", ")
+
+    val body   = s"mapCtx(zip($zipArgs)) { case (($zipArgs), z) => cb($zipArgs, z) }"
+    val zipmap = s"def zipMap[$typeArgs, Res]($parameters)(cb: ($typeArgs, Ctx) => Z[Res]) = $body"
+    val zip    = s"def zip[$typeArgs]($parameters): TT[($typeArgs)]"
+
+    if (n < 22) List(zipmap, zip).mkString("\n") else zip
+  }
+  write(
+    dir / "ApplicativeGenerated.scala",
+    s"""package mill.define
+      |import scala.language.higherKinds
+      |trait ApplyerGenerated[TT[_], Z[_], Ctx] {
+      |  def mapCtx[A, B](a: TT[A])(f: (A, Ctx) => Z[B]): TT[B]
+      |  ${(2 to 22).map(generate).mkString("\n")}
+      |}""".stripMargin
+  )
+}
+
+def generateTarget(dir: Path) = {
+  def generate(n: Int) = {
+    val (lowercases, uppercases, typeArgs, zipArgs) = argNames(n)
+    val parameters = lowercases.zip(uppercases).map { case (lower, upper) => s"$lower: TT[$upper]" }.mkString(", ")
+    val body       = uppercases.zipWithIndex.map { case (t, i) => s"args[$t]($i)" }.mkString(", ")
+
+    s"def zip[$typeArgs]($parameters) = makeT[($typeArgs)](Seq($zipArgs), (args: mill.util.Ctx) => ($body))"
+  }
+
+  write(
+    dir / "TaskGenerated.scala",
+    s"""package mill.define
+       |import scala.language.higherKinds
+       |trait TargetGenerated {
+       |  type TT[+X]
+       |  def makeT[X](inputs: Seq[TT[_]], evaluate: mill.util.Ctx => mill.eval.Result[X]): TT[X]
+       |  ${(3 to 22).map(generate).mkString("\n")}
+       |}""".stripMargin
+  )
+}
+
+def generateEval(dir: Path) = {
+  def generate(n: Int) = {
+    val (lowercases, uppercases, typeArgs, zipArgs) = argNames(n)
+    val parameters = lowercases.zip(uppercases).map { case (lower, upper) => s"$lower: TT[$upper]" }.mkString(", ")
+    val extract    = uppercases.zipWithIndex.map { case (t, i) =>  s"result($i).asInstanceOf[$t]" }.mkString(", ")
+
+    s"""def eval[$typeArgs]($parameters):($typeArgs) = {
+       |  val result = evaluator.evaluate(Agg($zipArgs)).values
+       |  (${extract})
+       |}
+     """.stripMargin
+  }
+
+  write(
+    dir / "EvalGenerated.scala",
+    s"""package mill.main
+       |import mill.eval.Evaluator
+       |import mill.define.Task
+       |import mill.util.Strict.Agg
+       |class EvalGenerated(evaluator: Evaluator[_]) {
+       |  type TT[+X] = Task[X]
+       |  ${(1 to 22).map(generate).mkString("\n")}
+       |}""".stripMargin
+  )
+}
+
+def generateApplicativeTest(dir: Path) = {
+  def generate(n: Int): String = {
+    val (lowercases, uppercases, typeArgs, zipArgs) = argNames(n)
+    val parameters = lowercases.zip(uppercases).map { case (lower, upper) => s"$lower: Option[$upper]" }.mkString(", ")
+    val forArgs = lowercases.map(i => s"$i <- $i").mkString("; ")
+    s"def zip[$typeArgs]($parameters) = { for ($forArgs) yield ($zipArgs) }"
+  }
+
+  write(
+    dir / "ApplicativeTestsGenerated.scala",
+    s"""package mill.define
+       |trait OptGenerated {
+       |  ${(2 to 22).map(generate).mkString("\n")}
+       |}
+    """.stripMargin
+  )
+}
+
+def unpackZip(zipDest: Path, url: String) = {
+  println(s"Unpacking zip $url into $zipDest")
+  mkdir(zipDest)
+
+  val bytes = scalaj.http.Http.apply(url).option(scalaj.http.HttpOptions.followRedirects(true)).asBytes
+  val byteStream = new java.io.ByteArrayInputStream(bytes.body)
+  val zipStream = new java.util.zip.ZipInputStream(byteStream)
+  while({
+    zipStream.getNextEntry match{
+      case null => false
+      case entry =>
+        if (!entry.isDirectory) {
+          val dest = zipDest / RelPath(entry.getName)
+          mkdir(dest / up)
+          val fileOut = new java.io.FileOutputStream(dest.toString)
+          val buffer = new Array[Byte](4096)
+          while ( {
+            zipStream.read(buffer) match {
+              case -1 => false
+              case n =>
+                fileOut.write(buffer, 0, n)
+                true
+            }
+          }) ()
+          fileOut.close()
+        }
+        zipStream.closeEntry()
+        true
+    }
+  })()
+}
+
+@main
+def generateCoreSources(p: Path) = {
+  generateApplyer(p)
+  generateTarget(p)
+  generateEval(p)
+  p
+}
+
+@main
+def generateCoreTestSources(p: Path) = {
+  generateApplicativeTest(p)
+  p
+}
+
+
+@main
+def downloadTestRepo(label: String, commit: String, dest: Path) = {
+  unpackZip(dest, s"https://github.com/$label/archive/$commit.zip")
+  dest
+}
\ No newline at end of file
diff --git a/ci/test-mill-0.sh b/ci/test-mill-0.sh
index 8e44b912..92dc34c5 100755
--- a/ci/test-mill-0.sh
+++ b/ci/test-mill-0.sh
@@ -6,4 +6,4 @@ set -eux
 git clean -xdf
 
 # Run tests
-mill -i all {main,scalalib,scalajslib,twirllib,main.client,contrib.scalapblib}.test
+mill -i all {main,scalalib,scalajslib,contrib.twirllib,main.client,contrib.scalapblib}.test
diff --git a/ci/test-mill-2.sh b/ci/test-mill-2.sh
index 00480a31..ceec17ef 100755
--- a/ci/test-mill-2.sh
+++ b/ci/test-mill-2.sh
@@ -5,6 +5,6 @@ set -eux
 # Starting from scratch...
 git clean -xdf
 
-mill testng.publishLocal # Needed for CaffeineTests
+mill contrib.testng.publishLocal # Needed for CaffeineTests
 # Run tests
 mill integration.test "mill.integration.local.{AcyclicTests,AmmoniteTests}"
diff --git a/ci/test-mill-bootstrap.sh b/ci/test-mill-bootstrap.sh
index cd959f9e..df8d086d 100755
--- a/ci/test-mill-bootstrap.sh
+++ b/ci/test-mill-bootstrap.sh
@@ -27,4 +27,4 @@ git clean -xdf
 rm -rf ~/.mill
 
 # Use second build to run tests using Mill
-~/mill-2 -i all {main,scalalib,scalajslib,twirllib,contrib.scalapblib}.test
+~/mill-2 -i all {main,scalalib,scalajslib,contrib.twirllib,contrib.scalapblib}.test
diff --git a/ci/test-mill-dev.sh b/ci/test-mill-dev.sh
index deb48dca..ab4a4d19 100755
--- a/ci/test-mill-dev.sh
+++ b/ci/test-mill-dev.sh
@@ -11,5 +11,5 @@ mill -i dev.assembly
 rm -rf ~/.mill
 
 # Second build & run tests
-out/dev/assembly/dest/mill -i all {main,scalalib,scalajslib,twirllib,contrib.scalapblib}.test
+out/dev/assembly/dest/mill -i all {main,scalalib,scalajslib,contrib.twirllib,contrib.scalapblib}.test
 
diff --git a/ci/upload.sc b/ci/upload.sc
new file mode 100644
index 00000000..d6aa96e2
--- /dev/null
+++ b/ci/upload.sc
@@ -0,0 +1,52 @@
+#!/usr/bin/env amm
+import ammonite.ops._
+import scalaj.http._
+
+@main
+def shorten(longUrl: String) = {
+  println("shorten longUrl " + longUrl)
+  val shortUrl = Http("https://git.io")
+    .postForm(Seq("url" -> longUrl))
+    .asString
+    .headers("Location")
+    .head
+  println("shorten shortUrl " + shortUrl)
+  shortUrl
+}
+@main
+def apply(uploadedFile: Path,
+          tagName: String,
+          uploadName: String,
+          authKey: String): String = {
+  val body = Http("https://api.github.com/repos/lihaoyi/mill/releases/tags/" + tagName)
+    .header("Authorization", "token " + authKey)
+    .asString.body
+
+  val parsed = ujson.read(body)
+
+  println(body)
+
+  val snapshotReleaseId = parsed("id").num.toInt
+
+
+  val uploadUrl =
+    s"https://uploads.github.com/repos/lihaoyi/mill/releases/" +
+      s"$snapshotReleaseId/assets?name=$uploadName"
+
+  val res = Http(uploadUrl)
+    .header("Content-Type", "application/octet-stream")
+    .header("Authorization", "token " + authKey)
+    .timeout(connTimeoutMs = 5000, readTimeoutMs = 60000)
+    .postData(read.bytes! uploadedFile)
+    .asString
+
+  println(res.body)
+  val longUrl = ujson.read(res.body)("browser_download_url").str.toString
+
+  println("Long Url " + longUrl)
+
+  val shortUrl = shorten(longUrl)
+
+  println("Short Url " + shortUrl)
+  shortUrl
+}