Renamed mvnDepsTree to showMvnDepsTree (#5161)

Fix #4939

Also make the tree as string available via a protected task
`mvnDepsTree`.

Pull request: #5161

Author: lefou

integration/feature/inspect/src/InspectTests.scala

@@ -85,12 +85,12 @@ object InspectTests extends UtestIntegrationTestSuite {
         run
       )
 
-      assert(eval(("inspect", "core.mvnDepsTree")).isSuccess)
+      assert(eval(("inspect", "core.showMvnDepsTree")).isSuccess)
 
       val mvnDepsTree = out("inspect").json.str
 
       assertGlobMatches(
-        """core.mvnDepsTree(JavaModule.scala:...)
+        """core.showMvnDepsTree(JavaModule.scala:...)
           |    Command to print the transitive dependency tree to STDOUT.
           |
           |    --inverse                Invert the tree representation, so that the root is on the bottom val
@@ -131,8 +131,8 @@ object InspectTests extends UtestIntegrationTestSuite {
 
       // Make sure both kebab-case and camelCase flags work, even though the
       // docs from `inspect` only show the kebab-case version
-      assert(eval(("core.mvnDepsTree", "--withCompile", "--withRuntime")).isSuccess)
-      assert(eval(("core.mvnDepsTree", "--with-compile", "--with-runtime")).isSuccess)
+      assert(eval(("core.showMvnDepsTree", "--withCompile", "--withRuntime")).isSuccess)
+      assert(eval(("core.showMvnDepsTree", "--with-compile", "--with-runtime")).isSuccess)
 
       val basic = eval(("inspect", "basic"))
       assert(basic.isSuccess)

libs/scalalib/src/mill/scalalib/JavaModule.scala

@@ -1126,11 +1126,11 @@ trait JavaModule
    * @param whatDependsOn possible list of modules to target in the tree in order to see
    *                      where a dependency stems from.
    */
-  protected def printDepsTree(
+  private def renderDepsTree(
       inverse: Boolean,
       additionalDeps: Task[Seq[BoundDep]],
       whatDependsOn: List[JavaOrScalaModule]
-  ): Task[Unit] =
+  ): Task[String] =
     Task.Anon {
       val dependencies =
         (additionalDeps() ++ Seq(BoundDep(coursierDependency, force = false))).iterator.to(Seq)
@@ -1148,7 +1148,7 @@ trait JavaModule
         case List() =>
           val mandatoryModules =
             mandatoryMvnDeps().map(bindDependency()).iterator.map(_.dep.module).toSet
-          val (mandatory, main) = resolution.dependenciesOf(coursierDependency)
+          val (mandatory, main) = resolution.dependenciesOf0(coursierDependency).toTry.get
             .partition(dep => mandatoryModules.contains(dep.module))
           additionalDeps().iterator.toSeq.map(_.dep) ++ main ++ mandatory
         case _ =>
@@ -1180,71 +1180,76 @@ trait JavaModule
         .replace(":0+mill-internal ", " ")
         .replace(":0+mill-internal" + System.lineSeparator(), System.lineSeparator())
 
-      println(processedTree)
-
-      ()
+      processedTree
     }
 
   /**
    * Command to print the transitive dependency tree to STDOUT.
    */
-  def mvnDepsTree(args: MvnDepsTreeArgs = MvnDepsTreeArgs()): Command[Unit] = {
+  def showMvnDepsTree(args: MvnDepsTreeArgs = MvnDepsTreeArgs()): Command[String] = {
+    val treeTask = mvnDepsTree(args)
+    Task.Command(exclusive = true) {
+      val rendered = treeTask()
+      Task.log.streams.out.println(rendered)
+      rendered
+    }
+  }
 
-    val (invalidModules, validModules) =
-      args.whatDependsOn.map(ModuleParser.javaOrScalaModule(_)).partitionMap(identity)
+  protected def mvnDepsTree(args: MvnDepsTreeArgs): Task[String] = {
+    val (invalidModules, modules) =
+      args.whatDependsOn.partitionMap(ModuleParser.javaOrScalaModule)
 
-    if (invalidModules.isEmpty) {
+    if (invalidModules.nonEmpty) {
+      Task.Anon {
+        val msg = invalidModules.mkString("\n")
+        Task.fail(msg)
+      }
+    } else {
       (args.withCompile, args.withRuntime) match {
         case (Flag(true), Flag(true)) =>
-          Task.Command {
-            printDepsTree(
-              args.inverse.value,
-              Task.Anon {
-                Seq(
-                  coursierDependency.withConfiguration(cs.Configuration.provided),
-                  coursierDependency.withConfiguration(cs.Configuration.runtime)
-                ).map(BoundDep(_, force = false))
-              },
-              validModules
-            )()
-          }
+          renderDepsTree(
+            args.inverse.value,
+            Task.Anon {
+              Seq(
+                coursierDependency.withConfiguration(cs.Configuration.provided),
+                coursierDependency.withConfiguration(cs.Configuration.runtime)
+              ).map(BoundDep(_, force = false))
+            },
+            modules
+          )
         case (Flag(true), Flag(false)) =>
-          Task.Command {
-            printDepsTree(
-              args.inverse.value,
-              Task.Anon {
-                Seq(BoundDep(
-                  coursierDependency.withConfiguration(cs.Configuration.provided),
-                  force = false
-                ))
-              },
-              validModules
-            )()
-          }
+          renderDepsTree(
+            args.inverse.value,
+            Task.Anon {
+              Seq(BoundDep(
+                coursierDependency.withConfiguration(cs.Configuration.provided),
+                force = false
+              ))
+            },
+            modules
+          )
         case (Flag(false), Flag(true)) =>
-          Task.Command {
-            printDepsTree(
-              args.inverse.value,
-              Task.Anon {
-                Seq(BoundDep(
-                  coursierDependency.withConfiguration(cs.Configuration.runtime),
-                  force = false
-                ))
-              },
-              validModules
-            )()
-          }
+          renderDepsTree(
+            args.inverse.value,
+            Task.Anon {
+              Seq(BoundDep(
+                coursierDependency.withConfiguration(cs.Configuration.runtime),
+                force = false
+              ))
+            },
+            modules
+          )
         case _ =>
-          Task.Command {
-            printDepsTree(args.inverse.value, Task.Anon { Seq.empty[BoundDep] }, validModules)()
-          }
-      }
-    } else {
-      Task.Command {
-        val msg = invalidModules.mkString("\n")
-        Task.fail(msg)
+          renderDepsTree(
+            args.inverse.value,
+            Task.Anon {
+              Seq.empty[BoundDep]
+            },
+            modules
+          )
       }
     }
+
   }
 
   /**

libs/scalalib/test/src/mill/scalalib/CrossVersionTests.scala

@@ -1,7 +1,6 @@
 package mill.scalalib
 
 import mill.define.Discover
-import mill.define.ExecutionPaths
 import mill.util.TokenReaders.*
 import mill.testkit.UnitTester
 import mill.testkit.TestRootModule
@@ -136,23 +135,15 @@ object CrossVersionTests extends TestSuite {
       expectedDeps: Seq[String],
       expectedLibs: Seq[String],
       expectedMvnDepsTree: Option[String] = None
-  )(implicit
+  )(using
       testPath: TestPath
   ) = {
     init().scoped { eval =>
-      eval.apply(mod.mvnDepsTree(MvnDepsTreeArgs()))
+      val Right(result) = eval.apply(mod.showMvnDepsTree(MvnDepsTreeArgs())): @unchecked
 
       expectedMvnDepsTree.foreach { tree =>
-        if (!scala.util.Properties.isWin) {
-          // Escape-sequence formatting isn't working under bare Windows
-          val expectedDepsTree = tree
-          val depsTree =
-            os.read(ExecutionPaths.resolve(
-              eval.outPath,
-              mod.mvnDepsTree(MvnDepsTreeArgs())
-            ).log)
-          assert(depsTree == expectedDepsTree)
-        }
+        val diffed = diff(result.value.trim, tree.trim)
+        assert(diffed == Nil)
       }
 
       val Right(libs) = eval.apply(mod.compileClasspath): @unchecked
@@ -162,6 +153,14 @@ object CrossVersionTests extends TestSuite {
     }
   }
 
+  def diff(actual: String, expected: String): List[String] = {
+    actual.lazyZip(expected).collect {
+      case (x, y) if x != y => s"'$x' != '$y'"
+    }.toList ++
+      actual.drop(expected.length).map(x => s"'$x' is unexpected") ++
+      expected.drop(actual.length).map(y => s"'$y' is expected but missing")
+  }
+
   def tests: Tests = Tests {
 
     test("StandaloneScala213") {