javabuilds/2-custom-tasks passes

example/javabuilds/2-custom-tasks/build.sc

@@ -1,33 +1,23 @@
-// This example shows how to define target that depend on other tasks:
-//
-// 1. For `generatedSources`, we override an the task and make it depend
-//    directly on `ivyDeps` to generate its source files. In this example,
-//    to include the list of dependencies as tuples within a static `object`
-//
-// 2. For `lineCount`, we define a brand new task that depends on `sources`,
-//    and then override `forkArgs` to use it. That lets us access the line
-//    count at runtime using `sys.props` and print it when the program runs
+// SNIPPET:BUILD
 
 import mill._, scalalib._
 
-object foo extends RootModule with ScalaModule {
-  def scalaVersion = "2.13.8"
-  def ivyDeps = Agg(ivy"com.lihaoyi::mainargs:0.4.0")
+object foo extends RootModule with JavaModule {
+  def ivyDeps = Agg(ivy"net.sourceforge.argparse4j:argparse4j:0.9.0")
 
   def generatedSources: T[Seq[PathRef]] = T {
     val prettyIvyDeps = for(ivyDep <- ivyDeps()) yield {
       val org = ivyDep.dep.module.organization.value
       val name = ivyDep.dep.module.name.value
       val version = ivyDep.dep.version
-      s"""("$org", "$name", "$version")"""
+      s""" "$org:$name:$version" """
     }
     os.write(
-      T.dest / s"MyDeps.scala",
-      s"""package foo
-         |object MyDeps {
-         |  val value = List(
-         |    ${prettyIvyDeps.mkString(",\n")}
-         |  )
+      T.dest / s"MyDeps.java",
+      s"""package foo;
+         |public class MyDeps {
+         |  public static String value =
+         |    ${prettyIvyDeps.mkString(" + \"\\n\" + \n")};
          |}
          |""".stripMargin
     )
@@ -38,7 +28,7 @@ object foo extends RootModule with ScalaModule {
   def lineCount: T[Int] = T {
     sources()
       .flatMap(pathRef => os.walk(pathRef.path))
-      .filter(_.ext == "scala")
+      .filter(_.ext == "java")
       .map(os.read.lines(_).size)
       .sum
   }
@@ -48,48 +38,18 @@ object foo extends RootModule with ScalaModule {
   def printLineCount() = T.command { println(lineCount()) }
 }
 
-// Mill lets you define new cached Targets using the `T {...}` syntax,
-// depending on existing Targets e.g. `foo.sources` via the `foo.sources()`
-// syntax to extract their current value, as shown in `lineCount` above. The
-// return-type of a Target has to be JSON-serializable (using
-// https://github.com/lihaoyi/upickle[uPickle]) and the Target is cached when
-// first run until its inputs change (in this case, if someone edits the
-// `foo.sources` files which live in `foo/src`. Cached Targets cannot take
-// parameters.
-//
-// Note that depending on a task requires use of parentheses after the task
-// name, e.g. `ivyDeps()`, `sources()` and `lineCount()`. This converts the
-// task of type `T[V]` into a value of type `V` you can make use in your task
-// implementation.
-//
-// This example can be run as follows:
+// SNIPPET:COMMANDS
 
 /** Usage
 
 > mill run --text hello
 text: hello
-MyDeps.value: List((com.lihaoyi,mainargs,0.4.0))
-my.line.count: 12
+MyDeps.value: net.sourceforge.argparse4j:argparse4j:0.9.0
+my.line.count: 24
 
 > mill show lineCount
-12
+24
 
 > mill printLineCount
-12
-*/
-
-// Custom targets and commands can contain arbitrary code. Whether you want to
-// download files using `requests.get`, shell-out to Webpack
-// to compile some Javascript, generate sources to feed into a compiler, or
-// create some custom jar/zip assembly with the files you want , all of these
-// can simply be custom targets with your code running in the `T {...}` block.
-//
-// You can create arbitrarily long chains of dependent targets, and Mill will
-// handle the re-evaluation and caching of the targets' output for you.
-// Mill also provides you a `T.dest` folder for you to use as scratch space or
-// to store files you want to return: all files a task creates should live
-// within `T.dest`, and any files you want to modify should be copied into
-// `T.dest` before being modified. That ensures that the files belonging to a
-// particular target all live in one place, avoiding file-name conflicts and
-// letting Mill automatically invalidate the files when the target's inputs
-// change.
+24
+*/

example/javabuilds/2-custom-tasks/src/Foo.java

@@ -0,0 +1,24 @@
+package foo;
+
+import net.sourceforge.argparse4j.ArgumentParsers;
+import net.sourceforge.argparse4j.inf.ArgumentParser;
+import net.sourceforge.argparse4j.inf.ArgumentParserException;
+import net.sourceforge.argparse4j.inf.Namespace;
+
+public class Foo {
+  public static void main(String[] args) throws Exception {
+    ArgumentParser parser = ArgumentParsers.newFor("Foo").build()
+            .defaultHelp(true)
+            .description("Process some integers.");
+    parser.addArgument("-t", "--text")
+            .required(true)
+            .help("input text");
+
+    Namespace res = parser.parseArgs(args);
+    String text = res.getString("text");
+
+    System.out.println("text: " + text);
+    System.out.println("MyDeps.value: " + MyDeps.value);
+    System.out.println("my.line.count: " + System.getProperty("my.line.count"));
+  }
+}

example/scalabuilds/2-custom-tasks/build.sc

@@ -8,6 +8,8 @@
 //    and then override `forkArgs` to use it. That lets us access the line
 //    count at runtime using `sys.props` and print it when the program runs
 
+// SNIPPET:BUILD
+
 import mill._, scalalib._
 
 object foo extends RootModule with ScalaModule {
@@ -48,6 +50,8 @@ object foo extends RootModule with ScalaModule {
   def printLineCount() = T.command { println(lineCount()) }
 }
 
+// SNIPPET:END
+
 // Mill lets you define new cached Targets using the `T {...}` syntax,
 // depending on existing Targets e.g. `foo.sources` via the `foo.sources()`
 // syntax to extract their current value, as shown in `lineCount` above. The
@@ -64,6 +68,8 @@ object foo extends RootModule with ScalaModule {
 //
 // This example can be run as follows:
 
+// SNIPPET:COMMANDS
+
 /** Usage
 
 > mill run --text hello
@@ -78,6 +84,8 @@ my.line.count: 12
 12
 */
 
+// SNIPPET:END
+
 // Custom targets and commands can contain arbitrary code. Whether you want to
 // download files using `requests.get`, shell-out to Webpack
 // to compile some Javascript, generate sources to feed into a compiler, or

example/scalabuilds/2-custom-tasks/src/Foo.scala

@@ -1,5 +1,7 @@
 package foo
+
 import mainargs.{main, ParserForMethods}
+
 object Foo {
   @main
   def main(text: String): Unit = {