The modules (aka plugins) in this section are developed/maintained outside the mill git tree.
Besides the documentation provided here, we urge you to consult the respective linked plugin documentation pages. The usage examples given here are most probably incomplete and sometimes outdated.
If you develop or maintain a mill plugin, please create a pull request to get your plugin listed here.
ANTLR parser generator support for mill.
Project home: https://github.com/ml86/mill-antlr
Millimport $ivy.`net.mlbox::mill-antlr:0.1.0`
import net.mlbox.millantlr.AntlrModule
object foo extends ScalaModule with AntlrModule {
override def antlrGrammarSources = T.sources {
Seq(os.pwd/"someGrammar.g4").map(PathRef(_))
}
}
AspectJ compiler support for mill.
Project home: https://github.com/lefou/mill-aspectj
import mill._
import mill.scalalib._
import mill.define._
// Load the plugin from Maven Central via ivy/coursier
import $ivy.`de.tototec::de.tobiasroeser.mill.aspectj_mill0.9:0.3.1-12-89db01
import de.tobiasroeser.mill.aspectj._
object main extends AspectjModule {
// Select the AspectJ version
def aspectjVersion = "1.9.5"
// Set AspectJ options, e.g. the language level and annotation processor
// Run `mill main.ajcHelp` to get a list of supported options
def ajcOptions = Seq("-8", "-proc:none")
}
For documentation, please refer to the project home page.
Limited bash completion support.
Project home: https://github.com/lefou/mill-bash-completion
Show transitive dependencies of your build in your browser.
Project home: https://github.com/ajrnz/mill-dgraph
import $ivy.`com.github.ajrnz::mill-dgraph:0.2.0`
sh> mill plugin.dgraph.browseDeps(proj)()
Create an .ensime file for your build.
Project home: https://github.com/davoclavo/mill-ensime
import mill._
interp.repositories() =
interp.repositories() ++ Seq(coursier.MavenRepository("https://jitpack.io"))
@
import $ivy.`com.github.yyadavalli::mill-ensime:0.0.2`
You can then run the following to generate the .ensime file
mill fun.valycorp.mill.GenEnsime/ensimeConfig
Optionally, you can specify the ensime server version using the --server flag like
mill fun.valycorp.mill.GenEnsime/ensimeConfig --server "3.0.0-SNAPSHOT"
A git version plugin for mill.
Project home: https://github.com/joan38/mill-git
build.sc:
import $ivy.`com.goyeau::mill-git:<latest version>`
import com.goyeau.mill.git.GitVersionedPublishModule
import mill.scalalib.JavaModule
import mill.scalalib.publish.{Developer, License, PomSettings, VersionControl}
object `jvm-project` extends JavaModule with GitVersionedPublishModule {
override def pomSettings = PomSettings(
description = "JVM Project",
organization = "com.goyeau",
url = "https://github.com/joan38/mill-git",
licenses = Seq(License.MIT),
versionControl = VersionControl.github("joan38", "mill-git"),
developers = Seq(Developer("joan38", "Joan Goyeau", "https://github.com/joan38"))
)
}
> mill show jvm-project.publishVersion
[1/1] show
[2/2] com.goyeau.mill.git.GitVersionModule.version
"0.0.0-470-6d0b3d9"
Integration testing for mill plugins.
Project home: https://github.com/lefou/mill-integrationtest
We assume, you have a mill plugin named mill-demo
// build.sc
import mill._, mill.scalalib._
object demo extends ScalaModule with PublishModule {
// ...
}
Add a new test sub-project, e.g. itest.
// build.sc
import $ivy.`de.tototec::de.tobiasroeser.mill.integrationtest_mill0.9:0.4.0`
import de.tobiasroeser.mill.integrationtest._
object demo extends ScalaModule with PublishModule {
// ...
}
object itest extends MillIntegrationTestModule {
def millTestVersion = "0.9.3"
def pluginsUnderTest = Seq(demo)
}
Your project should now look similar to this:
.
+-- demo/
| +-- src/
|
+-- it/
+-- src/
+-- 01-first-test/
| +-- build.sc
| +-- src/
|
+-- 02-second-test/
+-- build.sc
As the buildfiles build.sc in your test cases typically want to access the locally built plugin(s), the plugins publishes all plugins referenced under pluginsUnderTest to a temporary ivy repository, just before the test is executed. The mill version used in the integration test then used that temporary ivy repository.
Instead of referring to your plugin with import $ivy.'your::plugin:version', you can use the following line instead, which ensures you will use the correct locally build plugins.
// build.sc
import $exec.plugins
Effectively, at execution time, this line gets replaced by the content of plugins.sc, a file which was generated just before the test started to execute.
Please always refer to the https://github.com/lefou/mill-integrationtest[official plugin documentation site] for complete and up-to-date information.
Create static sites/blogs with JBake.
Plugin home: https://github.com/lefou/mill-jbake
JBake home: https://jbake.org
// build.sc
import mill._
import $ivy.`de.tototec::de.tobiasroeser.mill.jbake:0.1.0`
import de.tobiasroeser.mill.jbake._
object site extends JBakeModule {
def jbakeVersion = "2.6.4"
}
Generate the site:
bash> mill site.jbake
Start a local Web-Server on Port 8820 with the generated site:
bash> mill site.jbakeServe
This is a mill module similar to BuildInfo but for Java. It will generate a Java class containing information from your build.
Project home: https://github.com/carueda/mill-jbuildinfo
To declare a module that uses this plugin, extend the com.github.carueda.mill.JBuildInfo trait and provide the desired information via the buildInfoMembers method:
// build.sc
import $ivy.`com.github.carueda::jbuildinfo:0.1.2`
import com.github.carueda.mill.JBuildInfo
import mill.T
object project extends JBuildInfo {
def buildInfoMembers: T[Map[String, String]] = T {
Map(
"name" -> "some name",
"version" -> "x.y.z"
)
}
}
This will generate:
// BuildInfo.java
public class BuildInfo {
public static final String getName() { return "some name"; }
public static final String getVersion() { return "x.y.z"; }
}
def buildInfoMembers: T[Map[String, String]]
The map containing all member names and values for the generated class.
def buildInfoClassName: String, default: BuildInfo
The name of the class that will contain all the members from buildInfoMembers.
def buildInfoPackageName: Option[String], default: None
The package name for the generated class.
Kotlin compiler support for mill.
Project home: https://github.com/lefou/mill-kotlin
// Load the plugin from Maven Central via ivy/coursier
import $ivy.`de.tototec::de.tobiasroeser.mill.kotlin_mill0.9:0.2.0`
import mill._
import mill.scalalib._
import mill.define._
import de.tobiasroeser.mill.kotlin._
object main extends KotlinModule {
// Select the Kotlin version
def kotlinVersion = "1.4.21"
// Set additional Kotlin compiler options, e.g. the language level and annotation processor
// Run `mill main.kotlincHelp` to get a list of supported options
def kotlincOptions = super.kotlincOptions() ++ Seq("-verbose")
}
For documentation please visit the mill-kotlin project page.
You will find there also a version compatibility matrix.
Small script to automatically fetch and execute mill build tool.
Project home: https://github.com/lefou/millw
millw is a small wrapper script around mill and works almost identical to mill. It automatically downloads a mill release into $HOME/.mill/download.
The mill version to be used will be determined by the following steps. The search ends, after the first step that results in a version.
--mill-version, the second parameter will be used as the mill version. Example
sh $ mill --mill-version 0.3.6 --disable-ticker version
0.3.6
.mill-version in the working directory, it’s content will be used as mill version. The file must have only a mill version as content, no additional content or comments are supported. Example
sh $ echo -n "0.3.6" > .mill-version
sh $ mill --disable-ticker version
0.3.6
The values of the DEFAULT_MILL_VERSION variable inside the script will be used.
Istead of installing mill, you can just place the script into you local $HOME/bin directory and rename it to mill.
If you need a special mill version in a project directory, just place a .mill-version file with the best mill version. Example: setting mill 0.3.6 as best local mill version
sh $ echo -n "0.3.6" > .mill-version
To make the start for others easier or to always have the correct mill version in your CI environment, you can just place a copy of the script as millw in your project root directory.
You should change the DEFAULT_MILL_VERSION variable in that script to the correct version you want to use and add the file under version control.
Produce OSGi Bundles with mill.
Project home: https://github.com/lefou/mill-osgi
import mill._, mill.scalalib._
import $ivy.`de.tototec::de.tobiasroeser.mill.osgi:0.0.5`
import de.tobiasroeser.mill.osgi._
object project extends ScalaModule with OsgiBundleModule {
def bundleSymbolicName = "com.example.project"
def osgiHeaders = T{ super.osgiHeaders().copy(
`Export-Package` = Seq("com.example.api"),
`Bundle-Activator` = Some("com.example.internal.Activator")
)}
// other settings ...
}
Since Mill 0.6.1-27-f265a4 there is a built-in publishM2Local target in PublishModule.
Mill plugin to publish artifacts into a local Maven repository.
Project home: https://github.com/lefou/mill-publishM2
Just mix-in the PublishM2Module into your project. PublishM2Module already extends mill's built-in PublishModule.
File: build.sc
import mill._, scalalib._, publish._
import $ivy.`de.tototec::de.tobiasroeser.mill.publishM2:0.0.1`
import de.tobiasroeser.mill.publishM2._
object project extends PublishModule with PublishM2Module {
// ...
}
Publishing to default local Maven repository
> mill project.publishM2Local
[40/40] project.publishM2Local
Publishing to /home/user/.m2/repository
Publishing to custom local Maven repository
> mill project.publishM2Local /tmp/m2repo
[40/40] project.publishM2Local
Publishing to /tmp/m2repo
Scalafix support for mill.
Project home: https://github.com/joan38/mill-scalafix
build.sc:
import $ivy.`com.goyeau::mill-scalafix:<latest version>`
import com.goyeau.mill.scalafix.ScalafixModule
import mill.scalalib._
object project extends ScalaModule with ScalafixModule {
def scalaVersion = "2.12.11"
}
> mill project.fix
[29/29] project.fix
/project/project/src/MyClass.scala:12:11: error: [DisableSyntax.var] mutable state should be avoided
private var hashLength = 7
^^^
1 targets failed
project.fix A Scalafix linter error was reported
Mill plugin to derive a version from (last) git tag and edit state. It may support other VCS as well.
Project home: https://github.com/lefou/mill-vcs-version
Lots of formatting options are provided. When used with its defaults, the outcome is identical to the version scheme used by mill.
import mill._
import mill.scalalib._
// Load the plugin from Maven Central via ivy/coursier
import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version_mill0.9:0.1.1`
import de.tobiasroeser.mill.vcs.version.VcsVersion
object main extends JavaModule with PublishModule {
override def publishVersion: T[String] = VcsVersion.vcsState().format()
}
This documentation was build from mill master branch.
About Mill: Mill is an Open Source Project created by Li Haoyi. It is actively maintained and the git repository has more that 100 individual contributors around the world.
About Mills Creator: Li Haoyi is a software engineer, an early contributor to Scala.js, and the author of many open-source Scala tools such as Mill, the Ammonite REPL and FastParse. If you've enjoyed using Mill, or enjoyed using Haoyi's other open source libraries, please chip in (or get your Company to chip in!) via Patreon so he can continue his open-source work.