merged

Author: lihaoyi

core/internal/src/mill/internal/MillPathSerializer.scala

@@ -0,0 +1,77 @@
+package mill.internal
+
+import java.nio.file.Files
+
+object MillPathSerializer {
+  def setupSymlinks(wd: os.Path, workspace: os.Path): Unit = {
+    for ((base, link) <- defaultMapping(workspace)) {
+      os.makeDir.all(wd / link / "..")
+      os.remove(wd / link)
+      Files.createSymbolicLink((wd / link).toNIO, base.wrapped)
+    }
+  }
+
+  def defaultMapping(workspace: os.Path): Seq[(os.Path, os.SubPath)] = Seq(
+    workspace -> os.sub / "out/mill-workspace",
+    os.home -> os.sub / "out/mill-home"
+  )
+}
+
+class MillPathSerializer(mapping: Seq[(os.Path, os.SubPath)]) extends os.Path.Serializer {
+
+  private def mapPathPrefixes(path: os.Path, mapping: Seq[(os.Path, os.SubPath)]): os.FilePath = {
+    mapping
+      .collectFirst { case (from, to) if path.startsWith(from) => to / path.subRelativeTo(from) }
+      .getOrElse(path)
+  }
+
+  private def mapPathPrefixes(
+      path: java.nio.file.Path,
+      mapping: Seq[(os.SubPath, os.Path)]
+  ): java.nio.file.Path = {
+    mapping
+      .collectFirst {
+        case (from, to) if path.startsWith(from.toNIO) || from.segments.isEmpty =>
+          to.wrapped.resolve(
+            // java.nio.Path#relativize misbehaves on empty paths
+            if (from.segments.isEmpty) path else from.toNIO.relativize(path)
+          )
+      }
+      .getOrElse(path)
+  }
+
+  def normalizePath(path: os.Path): os.FilePath = mapPathPrefixes(path, mapping)
+
+  def denormalizePath(path: java.nio.file.Path): java.nio.file.Path =
+    mapPathPrefixes(path, mapping.map(_.swap))
+
+  override def serializeString(p: os.Path): String = normalizePath(p) match {
+    case p: os.SubPath => p.toNIO.toString
+    case p: os.Path => p.wrapped.toString
+    case p: os.RelPath => p.toNIO.toString
+  }
+
+  override def serializeFile(p: os.Path): java.io.File = normalizePath(p) match {
+    case p: os.SubPath => p.toNIO.toFile
+    case p: os.Path => p.wrapped.toFile
+    case p: os.RelPath => p.toNIO.toFile
+  }
+
+  override def serializePath(p: os.Path): java.nio.file.Path = normalizePath(p) match {
+    case p: os.SubPath => p.toNIO
+    case p: os.Path => p.wrapped
+    case p: os.RelPath => p.toNIO
+  }
+
+  override def deserialize(s: String): java.nio.file.Path =
+    denormalizePath(os.Path.defaultPathSerializer.deserialize(s))
+
+  override def deserialize(s: java.io.File): java.nio.file.Path =
+    denormalizePath(os.Path.defaultPathSerializer.deserialize(s))
+
+  override def deserialize(s: java.nio.file.Path): java.nio.file.Path =
+    denormalizePath(os.Path.defaultPathSerializer.deserialize(s))
+
+  override def deserialize(s: java.net.URI): java.nio.file.Path =
+    denormalizePath(os.Path.defaultPathSerializer.deserialize(s))
+}

integration/dedicated/reproducibility/resources/build.mill

@@ -0,0 +1,4 @@
+package build
+import mill.*
+
+def foo = Task { 31337 }

integration/dedicated/reproducibility/src/ReproducibilityTests.scala

@@ -0,0 +1,76 @@
+package mill.integration
+
+import mill.api.BuildCtx
+import mill.testkit.UtestIntegrationTestSuite
+import utest.*
+
+import java.util.zip.GZIPInputStream
+
+object ReproducibilityTests extends UtestIntegrationTestSuite {
+
+  def normalize(workspacePath: os.Path): Unit = {
+    for (p <- os.walk(workspacePath / "out")) {
+      val sub = p.subRelativeTo(workspacePath).toString()
+
+      val cacheable =
+        (sub.contains(".dest") || sub.contains(".json") || os.isDir(p)) &&
+          !sub.replace("out/mill-build", "").contains("mill-") &&
+          !(p.ext == "json" && ujson.read(
+            os.read(p)
+          ).objOpt.flatMap(_.get("value")).flatMap(_.objOpt).flatMap(_.get("worker")).nonEmpty)
+
+      if (!cacheable) {
+        os.remove.all(p)
+      }
+    }
+  }
+
+  val tests: Tests = Tests {
+    test("diff") - {
+      def run() = integrationTest { tester =>
+        val res = tester.eval(("show", "foo"))
+        val lastNonEmptyLine = res.out.linesIterator.filter(_.nonEmpty).toSeq.lastOption.getOrElse("")
+        assert(lastNonEmptyLine == "31337")
+        tester.workspacePath
+      }
+
+      val workspacePath1 = run()
+      val workspacePath2 = run()
+      assert(workspacePath1 != workspacePath2)
+      normalize(workspacePath1)
+      normalize(workspacePath2)
+      val diff = os.call(("git", "diff", "--no-index", workspacePath1, workspacePath2)).out.text()
+      assert(diff.isEmpty)
+    }
+
+    test("inspection") - {
+      def run() = integrationTest { tester =>
+        tester.eval(
+          ("--meta-level", "1", "runClasspath"),
+          env = Map("MILL_TEST_TEXT_ANALYSIS_STORE" -> "1"),
+          check = true
+        )
+        tester.workspacePath
+      }
+
+      val workspacePath = run()
+      val dest = workspacePath / "out/mill-build/compile.dest/zinc.txt"
+      val src = workspacePath / "out/mill-build/compile.dest/zinc"
+      os.write(dest, new GZIPInputStream(os.read.inputStream(src)))
+      normalize(workspacePath)
+      for (p <- os.walk(workspacePath)) {
+        if (
+          (p.ext == "json" || p.ext == "txt")
+          && !p.segments.contains("enablePluginScalacOptions.super")
+          && !p.segments.contains("allScalacOptions.json")
+          && !p.segments.contains("scalacOptions.json")
+          && p.last != "coursierEnv.json"
+        ) {
+          val txt = os.read(p)
+          Predef.assert(!txt.contains(BuildCtx.workspaceRoot.toString), p)
+          Predef.assert(!txt.contains(os.home.toString), p)
+        }
+      }
+    }
+  }
+}