Aggregation of mandatoryIvyDeps and ivyDeps. In most cases, instead of overriding this Target you want to override ivyDeps instead.

Aggregation of all the options passed to the Scala compiler. In most cases, instead of overriding this Target you want to override scalacOptions instead.

All individual source files fed into the Zinc compiler.

The folders containing all source files fed into the compiler

Dependencies that are necessary to run the Ammonite Scala REPL

Ammonite's version used in the repl command is by default set to the one Mill is built against.

The exact id of the artifact to be published. You probably don't want to override this. If you want to customize the name of the artifact, override artifactName instead. If you want to customize the scala version in the artifact id, see ScalaModule.artifactScalaVersion

Override this to change the published artifact id. For example, by default a scala module foo.baz might be published as foo-baz_2.12 and a java module would be foo-baz. Setting this to baz would result in a scala artifact baz_2.12 or a java artifact baz.

What Scala version string to use when publishing

The suffix appended to the artifact IDs during publishing

An executable uber-jar/assembly containing all the resources and compiled classfiles from this module and all it's upstream modules and dependencies

Use to fill most fields of BuildTarget.

Use to populate the BuildTarget.{dataKind,data} fields.

the path to the compiles classes without forcing to actually run the target

Same as compileClasspath, but does not trigger compilation targets, if possible.

Compiles the current module to generate compiled classfiles/bytecode

All classfiles and resources from upstream modules and dependencies necessary to compile this module

Same as ivyDeps, but only present at compile time. Useful for e.g. macro-related dependencies like scala-reflect that doesn't need to be present at runtime

The compile-only direct dependencies of this module.

Opens up a Scala console with your module and all dependencies present, for you to test and operate your code interactively.

Customize the coursier file cache.

This is rarely needed to be changed, but sometimes e.g you want to load a coursier plugin. Doing so requires adding to coursier's classpath. To do this you could use the following:

override def coursierCacheCustomizer = T.task {
   Some( (fc: coursier.cache.FileCache[Task]) =>
     fc.withClassLoaders(Seq(classOf[coursier.cache.protocol.S3Handler].getClassLoader))
   )
}

Whether to publish artifacts with name "mill_2.12.4" instead of "mill_2.12"

The documentation jar, containing all the Javadoc/Scaladoc HTML files, for publishing to Maven Central

Extra directories to be copied into the documentation.

Typically includes static files such as html and markdown, but depends on the doc tool that is actually used.

Directories to be processed by the API documentation tool.

Typically includes the source files to generate documentation from.

Any command-line parameters you want to pass to the forked JVM under run, test or repl

Any environment variables you want to pass to the forked JVM under run, test or repl

Folders containing source files that are generated rather than hand-written; these files can be generated in this target itself, or can refer to files generated from other targets

Contribute components to idea config files.

Contribute facets to the Java module configuration.

Any ivy dependencies you want to add to this Module, in the format ivy"org::name:version" for Scala dependencies or ivy"org:name:version" for Java dependencies

Command to print the transitive dependency tree to STDOUT.

A jar containing only this module's resources and compiled classfiles, without those from upstream modules and dependencies

Options to pass to the java compiler

Additional options to be used by the javadoc tool. You should not set the -d setting for specifying the target directory, as that is done in the docJar target.

Builds a command-line "launcher" file that can be used to run this module's code, without the Mill process. Useful for deployment & other places where you do not want a build tool running

The output classfiles/resources from this module, excluding upstream modules and third-party dependencies

Allows you to specify an explicit main class to use for the run command. If none is specified, the classpath is searched for an appropriate main class to use if one exists

Adds the Scala Library is a mandatory dependency.

Mandatory command-line options to pass to the Scala compiler that shouldn't be removed by overriding scalacOptions

Creates a manifest representation which can be modified or replaced The default implementation just adds the Manifest-Version, Main-Class and Created-By attributes

Map dependencies before resolving them. Override this to customize the set of dependencies.

The direct dependencies of this module

What platform suffix to use for publishing, e.g. _sjs for Scala.js projects

What shell script to use to launch the executable generated by assembly. Defaults to a generic "universal" launcher that should work for Windows, OS-X and Linux

Task that print the transitive dependency tree to STDOUT.

The direct and indirect dependencies of this module

Opens up an Ammonite Scala REPL with your module and all dependencies present, for you to test and operate your code interactively. Use ammoniteVersion to customize the Ammonite version to use.

The repositories used to resolved dependencies with resolveDeps().

Customize the coursier resolution resolution process. This is rarely needed to changed, as the default try to provide a highly reproducible resolution process. But sometime, you need more control, e.g. you want to add some OS or JDK specific resolution properties which are sometimes used by Maven and therefore found in dependency artifact metadata. For example, the JavaFX artifacts are known to use OS specific properties. To fix resolution for JavaFX, you could override this task like the following:

override def resolutionCustomizer = T.task {
  Some( (r: coursier.core.Resolution) =>
    r.withOsInfo(coursier.core.Activation.Os.fromProperties(sys.props.toMap))
  )
}

Task that resolves the given dependencies using the repositories defined with repositories.

Resolved dependencies based on transitiveIvyDeps and transitiveCompileIvyDeps.

The folders where the resource files for this module live

Runs this module's code in a subprocess and waits for it to finish

Runs this module's code in a background process, until it dies or runBackground is used again. This lets you continue using Mill while the process is running in the background: editing files, compiling, and only re-starting the background process when you're ready.

You can also use -w foo.runBackground to make Mill watch for changes and automatically recompile your code & restart the background process when ready. This is useful when working on long-running server processes that would otherwise run forever

All classfiles and resources from upstream modules and dependencies necessary to run this module's code after compilation

Same as ivyDeps, but only present at runtime. Useful for e.g. selecting different versions of a dependency to use at runtime after your code has already been compiled

Runs this module's code in-process within an isolated classloader. This is faster than run, but in exchange you have less isolation between runs since the code can dirty the parent Mill process and potentially leave it in a bad state.

Same as run, but lets you specify a main class to run

Same as runBackground, but lets you specify a main class to run

Same as runLocal, but lets you specify a main class to run

Control whether run*-targets should use an args file to pass command line args, if possible.

Classpath of the Scala Compiler & any compiler plugins

Classpath of the scaladoc (or dottydoc) tool.

The ivy coordinates of Scala's own standard library

What Scala organization to use

What version of Scala to use

Command-line options to pass to the Scala compiler defined by the user. Consumers should use allScalacOptions to read them.

The local classpath of Scala compiler plugins on-disk; you can add additional jars here if you have some copiler plugin that isn't present on maven central

Allows you to make use of Scala compiler plugins.

Show the module dependencies.

Skip Idea project file generation.

The source jar, containing only source code for publishing to Maven Central

The folders where the source files for this module live

The compile-only transitive ivy dependencies of this module and all it's upstream compile-only modules.

The transitive ivy dependencies of this module and all it's upstream modules. This is calculated from ivyDeps, mandatoryIvyDeps and recursively from moduleDeps.

The transitive version of localClasspath

Like recursiveModuleDeps but also include the module itself

Additional jars, classfiles or resources to add to the classpath directly from disk rather than being downloaded from Maven Central or other package repositories

Build the assembly for upstream dependencies separate from the current classpath

This should allow much faster assembly creation in the common case where upstream dependencies do not change

All upstream classfiles and resources necessary to build and executable assembly, but without this module's contribution

The upstream compilation output of all this module's upstream modules

The repositories used to resolved dependencies with resolveDeps().