Named RootModule in Mill 1.x

[andrelfpinto]

Hi everyone,

I’m using Mill 1.1.5 to automate a workflow for some configuration files within a flat project structure where there is no notion of submodules. To keep terminal invocation commands short (allowing users to run mill my-task directly), I am using the standard object `package` extends Module syntax in my build.mill file.

The setup of the project structure requires a MyName.xml file and a corresponding MyName asset folder to sit side by side inside the application directory.

I would like to share a reusable trait (say MyExtensionModule) across different build setups to validate and copy these artifacts automatically from the development folder to the application one. If the module could be explicitly named (like object MyName extends MyExtensionModule), I would simply query moduleSegments.parts.last inside the trait to discover the string token "MyName" and dynamically find the paths.

Is there a recommended idiom or clean workaround in Mill 1.x to have a named package extending RootModule?

[VectorPeak]

The root module is intentionally anonymous in Mill, so object \package` extends RootModulewon’t give you a usefulmoduleSegments.parts.last; root tasks have no module-name segment. A named object MyName ...is a normal module, and its tasks are invoked asmill MyName.myTask, not mill myTask`.

The usual workaround is to make the name an explicit part of your reusable trait’s API, and optionally default it from moduleSegments for non-root modules:

import mill.*

trait MyExtensionModule extends Module {
 def artifactName: T[String] = Task {
 moduleSegments.parts.lastOption.getOrElse(
 sys.error("artifactName must be overridden for the root module")
 )
 }

 def xmlFile = Task.Source(moduleDir / s"${artifactName()}.xml")
 def assetDir = Task.Source(moduleDir / artifactName())

 def validateArtifacts = Task {
 val xml = xmlFile().path
 val dir = assetDir().path

 if (!os.exists(xml)) sys.error(s"Missing $xml")
 if (!os.isDir(dir)) sys.error(s"Missing directory $dir")
 }
}

object `package` extends RootModule with MyExtensionModule {
 override def artifactName = Task { "MyName" }

 def myTask = Task {
 validateArtifacts()
 // copy/do whatever
 }
}

[andrelfpinto]

Thank you for the answer, @VectorPeak. This is the approach I am using.
Maybe we can aproach from the other angle: is it possible to have a regular object MyName extends MyExtensionModule and to somehow redirect mill MyName.myTask to mill myTask?

[lefou]

Hmm, renaming MyName to `package` is exactly that way. There must be something that you not told us. Can you again provide some motivation? Or show the issues you have currently.

AFAIU you have some special location for your assets. Are you aware you can customize def moduleDir to rerocate the module base path or override some specific tasks like sources and resources?

[andrelfpinto]

Hi, @lefou. Thank you for also trying to help: Li Haoyi and you make an amazing job here.
I am developing an extension to a program unrelated to Scala or Java. This program expects a MyName.xml file and a corresponding MyName asset folder to be put in a specific location. I don't think is a best practice develop the extension in that specific folder, so I had a script to move the .xml and the folder from my development location to there. Later, I needed to process the files, like doing validation on the .xml. So I thought it would be beneficial for me centralize all these tasks using Mill.
Currently, I have the following structure:

MyNameDevelopmentFolder
│   build.mill
│   extension.xsd
│   mill.bat
│   millp.ps1
│
└───src
    │   MyName.xml
    │
    └───MyName
        │   main.py
        │
        ├───my-module
        │   │   __init__.py
        │   │
        │   ├───templates
        │   │       __init__.py
        │   │       file.py
        │   │
        │   └───utils
        │           __init__.py
        │           helpers.py
        │           math.py
        │
        └───images
                icon.png

With build.mill:

trait ExtensionModule extends Module {
  def extensionName: String
  def sourceDir: os.Path = moduleDir / "src"
  def targetDir: T[os.Path]
  def extensionFolder = Task.Source(sourceDir / extensionName)
  def extensionXmlFile = Task.Source(sourceDir / s"$extensionName.xml")
  def validateExtensionXml() = Task.Command { ... }
  def deploy() = Task.Command { ... }
}

object `package` extends ExtensionModule {
  def extensionName = "MyName"
  def targetDir = os.Path( ... )
}

With this configuration, I can do mill validateExtensionXml or mill deploy. Since I can't have submodules, it is good I don't need to type mill MyName.deploy.
It works for me but I need this def extensionName = "MyName". I thought I could improve a little more. In previous versions of Mill, I could have object MyName extends RootModule with MyExtensionModule. This way, I thought I could somehow move the definition of extensionName inside ExtensionModule trait (maybe implementing it using moduleSegments). It is one less configuration to do (especially if some other coworkers start using this).
But now root modules are nameless. I searched through the code to try to get back this and I couldn't. In my head one of these options would improve this:
object MyName extends RootModule with MyExtensionModule // optimal but not possible anymore AFAIU
object MyName extends MyExtensionModule // and somehow calling Mill without MyName prefix
Is any of this possible?

[lefou]

Can you also post the solution that worked with older Mill versions? It might help me to spot something.

IIRC, we didn't change how root modules work, but removed the need to explicitly inherit from RootModule. This is now done implicitly for those package objects.

[andrelfpinto]

It was a long time ago, but for Mill 0.11.x, we could do this:

import mill._

object MyName extends RootModule {
  val name = millOuterCtx.segment match {
    case define.Segment.Label(s) => s
    case _ => ???
  }
  def hello = T { s"Hello, $name" }
}

And get this:

> ./mill -w show hello
[1/1] show
"Hello, MyName"

In my case:

import mill._

trait ExtensionModule extends RootModule {
  def extensionName = millOuterCtx.segment match {
    case define.Segment.Label(s) => s
    case _ => ???
  }
  def sourceDir: os.Path = millSourcePath / "src"
  def targetDir: T[os.Path]
  def extensionFolder = T.source { sourceDir / extensionName }
  def extensionXmlFile = T.source { sourceDir / s"$extensionName.xml" }
  def validateExtensionXml() = Task.Command { ... }
  def deploy() = Task.Command { ... }
}

object MyName extends ExtensionModule {
  def targetDir = os.Path( ... )
}

> ./mill show extensionXmlFile
[1/1] show > [1/1] extensionXmlFile
"ref:v0:c984eca8:D:\\working\\test\\MyNameDevelopmentFolder\\src\\MyName.xml"
> ./mill show extensionFolder
[1/1] show > [1/1] extensionFolder
"ref:v0:c984eca8:D:\\working\\test\\MyNameDevelopmentFolder\\src\\MyName"