How to nest jar (or e.g. PublishModule.publishLocal) commands?

[jk-1]

I used this mill example to clarify my question:

import mill._, scalalib._

trait MyModule extends ScalaModule {
  def scalaVersion = "2.13.8"
  def ivyDeps = Agg(
    ivy"com.lihaoyi::scalatags:0.8.2",
    ivy"com.lihaoyi::mainargs:0.4.0"
  )
}

object foo extends MyModule {
  def moduleDeps = Seq(bar, qux)

  object bar extends MyModule
  object qux extends MyModule {
    def moduleDeps = Seq(bar)
  }
}

object baz extends MyModule {
  def moduleDeps = Seq(foo.bar, foo.qux, foo)
}

How can I modify the baz so that when running baz.jar it checks if foo.bar, foo.qux, foo jars are uptodate and runs these .jar commands when necessary before running baz.jar?

Existing module deps does not help here because it just check that compilation is done in proper order.

If I try something like this:

object baz extends MyModule {
  override def moduleDeps = Seq(foo.bar, foo.qux, foo)

  override def jar: T[PathRef] = {
    foo.bar.jar()
    foo.qux.jar()
    foo.jar()
    super.jar
  }

it compiles error:

[info] compiling 1 Scala source to /home/jk/Downloads/0.11.12-example-scalabuilds-4-nested-modules/out/mill-build/compile.dest/classes ...
[error] /home/jk/Downloads/0.11.12-example-scalabuilds-4-nested-modules/build.sc:64:18: Target#apply() can only be used with a T{...} block
[error]       foo.bar.jar()
[error]                  ^
[error] /home/jk/Downloads/0.11.12-example-scalabuilds-4-nested-modules/build.sc:65:18: Target#apply() can only be used with a T{...} block
[error]       foo.qux.jar()
[error]                  ^
[error] /home/jk/Downloads/0.11.12-example-scalabuilds-4-nested-modules/build.sc:66:14: Target#apply() can only be used with a T{...} block
[error]       foo.jar()
[error]              ^

I can ofcourse make a new task e.g.

  def doJarT = T { 
    foo.bar.jar()
    foo.qux.jar()
    foo.jar()
    baz.jar()
  }

but it is easier to use if no new commands/targets are needed for every dependency.

[lefou]

To depend on all jars of a modules direct dependencies, you can use:

T.traverse(moduleDeps)(_.jar)()

If you also want to depend on their transitive dependencies, use:

T.traverse(recursiveModuleDeps)(_.jar)()

Your MyModule.jar could look like this:

override def jar: T[PathRef] = T {
  T.traverse(moduleDeps)(_.jar)()
  super.jar()
}

Please note, that if you use MyModule everywhere, this is already recursive.

[jk-1]

That works for T { ... } but when all objects foo, bar, qux, baz extend PublishModule and I try this:

  override def publishLocal(localIvyRepo: String): Command[Unit] = T.command {
    T.traverse(moduleDeps)(_.publishLocal(localIvyRepo))
    super.publishLocal(localIvyRepo)
  }

it publishes only the baz. How to fix this?

[lefou]

That's because you're not calling the apply-methods of the commands. Without, the commands in both lines won't evaluate. Instead, you return the super-version as-is. Since T.command accepts a Task as parameter and super.publishLocal(..) is a task, the compiler will not notice too.

Instead, your example should to look like this:

override def publishLocal(localIvyRepo: String): Command[Unit] = T.command {
  T.traverse(moduleDeps)(_.publishLocal(localIvyRepo))()
  super.publishLocal(localIvyRepo)()
}

Notice the extra parenthesis (()) in both lines.

 override def publishLocal(localIvyRepo: String): Command[Unit] = T.command {
-   T.traverse(moduleDeps)(_.publishLocal(localIvyRepo))
+   T.traverse(moduleDeps)(_.publishLocal(localIvyRepo))()
-   super.publishLocal(localIvyRepo)
+   super.publishLocal(localIvyRepo)()
 }

[lefou]

Created an issue

• Evaluate if T.command overload accepting a Task can be removed #3517

[jk-1]

Thank you!!! Now it works!