diff options
Diffstat (limited to 'ci')
-rw-r--r-- | ci/shared.sc | 154 | ||||
-rwxr-xr-x | ci/test-mill-0.sh | 2 | ||||
-rwxr-xr-x | ci/test-mill-2.sh | 2 | ||||
-rwxr-xr-x | ci/test-mill-bootstrap.sh | 2 | ||||
-rwxr-xr-x | ci/test-mill-dev.sh | 2 | ||||
-rw-r--r-- | ci/upload.sc | 52 |
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 +} |