samples

Author: lostiniceland

example/groovylib/basic/1-simple/build.mill

@@ -0,0 +1,124 @@
+//// SNIPPET:BUILD
+
+package build
+import mill.*, groovylib.*
+
+object foo extends GroovyModule {
+  def groovyVersion = "5.0.1"
+
+  def mvnDeps = Seq(
+    mvn"org.apache.groovy:groovy-cli-commons", // BOM already loaded by module
+    mvn"org.apache.groovy:groovy-xml" // BOM already loaded by module
+  )
+  
+  def mainClass = Some("foo.Foo")
+
+  object test extends GroovyTests with TestModule.Junit5 {
+    def jupiterVersion = "5.13.4"
+
+    def mvnDeps = Seq(
+      mvn"org.apache.groovy:groovy-test" // BOM already loaded by module
+    )
+  }
+}
+
+// This is a basic Mill build for a single `GroovyModule`, with one
+// third-party dependency and a test suite using the JUnit framework.
+//// SNIPPET:TREE
+// ----
+// build.mill
+// foo/
+//     src/
+//         foo/Foo.groovy
+//     resources/
+//         ...
+//     test/
+//         src/
+//             foo/FooTest.groovy
+// out/foo/
+//     compile.json
+//     compile.dest/
+//     ...
+//     test/
+//         compile.json
+//         compile.dest/
+//         ...
+// ----
+//
+// NOTE: The default Mill source folder layout `foo/src/` differs from that of Maven/Gradle's
+// `foo/src/main/groovy`. If you wish to use the Maven source folder layout, e.g. for migrating
+// an existing codebase, you should use
+// xref:#_maven_compatible_modules[Maven-Compatible Modules]
+//
+//// SNIPPET:DEPENDENCIES
+//
+// This example project uses two third-party dependencies 
+// - Groovy-Cli-Commons for CLI argument parsing
+// - Groovy-Xml for HTML templating and escaping
+// and uses them to wrap a given input string in HTML templates with proper escaping.
+//
+// Typical usage of a `GroovyModule` is shown below
+
+/** Usage
+
+> ./mill resolve foo._ # List what tasks are available to run
+foo.assembly
+...
+foo.compile
+...
+foo.run
+...
+*/
+/** Usage
+> ./mill inspect foo.compile # Show documentation and inputs of a task
+foo.compile(GroovyModule...)
+    Compiles all the sources to JVM class files.
+    Compiles the current module to generate compiled classfiles/bytecode.
+Inputs:
+    foo.allJavaSourceFiles
+    foo.allGroovySourceFiles
+    foo.compileClasspath
+    foo.upstreamCompileOutput
+    foo.javacOptions
+    foo.zincReportCachedProblems
+...
+*/
+/** Usage
+> ./mill foo.compile # compile sources into classfiles
+...
+Compiling 1 Groovy sources to...
+*/
+/** Usage
+> ./mill foo.run # run the main method, if any
+error: Error: missing option --text
+...
+*/
+/** Usage
+> ./mill foo.run --text hello
+<h1>hello</h1>
+*/
+/** Usage
+> ./mill foo.test
+...
+Test foo.FooTest testSimple finished, ...
+Test foo.FooTest testEscaping finished, ...
+Test foo.FooTest finished, ...
+Test run finished: 0 failed, 0 ignored, 2 total, ...
+*/
+/** Usage
+> ./mill foo.assembly # bundle classfiles and libraries into a jar for deployment
+
+> ./mill show foo.assembly # show the output of the assembly task
+".../out/foo/assembly.dest/out.jar"
+
+> java -jar ./out/foo/assembly.dest/out.jar --text hello
+<h1>hello</h1>
+
+> ./out/foo/assembly.dest/out.jar --text hello # mac/linux
+<h1>hello</h1>
+
+> cp ./out/foo/assembly.dest/out.jar out.bat # windows
+
+> ./out.bat --text hello # windows
+<h1>hello</h1>
+*/

example/groovylib/basic/1-simple/foo/src/foo/Foo.groovy

@@ -0,0 +1,32 @@
+package foo
+
+import groovy.xml.MarkupBuilder
+import groovy.cli.commons.CliBuilder
+
+class Foo {
+    static String generateHtml(String text) {
+        def writer = new StringWriter()
+        new MarkupBuilder(writer).h1 {
+            mkp.yield text
+        }
+        writer.toString()
+    }
+
+    static void main(String[] args) {
+        def cli = new CliBuilder(usage:'help')
+        cli.t(longOpt:'text', args: 1, 'Passes text to the HTML generation')
+        def options = cli.parse(args)
+
+        if (!options) {
+            return
+        }
+
+        if (options.h) {
+            cli.usage()
+            return
+        }
+
+        String textToProcess = options.t ?: "hello from main"
+        println generateHtml(textToProcess)
+    }
+}

example/groovylib/basic/1-simple/foo/test/src/foo/FooTest.groovy

@@ -0,0 +1,15 @@
+package foo
+
+import org.junit.jupiter.api.Test
+
+class FooTest {
+    @Test
+    void "generate html created properly"() {
+        assert Foo.generateHtml("hello") == "<h1>hello</h1>"
+    }
+    
+    @Test
+    void "generated html is properly escaped"() {
+        assert Foo.generateHtml("<hello>") == "<h1>&lt;hello&gt;</h1>"
+    }
+}

example/groovylib/basic/2-compat-modules/build.mill

@@ -0,0 +1,59 @@
+//// SNIPPET:ALL
+// Mill's default folder layout of `foo/src/` and `foo/test/src` differs from that
+// of Maven or Gradle's `foo/src/main/groovy/` and `foo/src/test/groovy/`. If you are
+// migrating an existing codebase, you can use Mill's `GroovyMavenModule` and
+// `GroovyMavenTests` as shown below to preserve filesystem compatibility with an existing
+// Maven or Gradle build:
+
+package build
+import mill.*, groovylib.*
+
+object foo extends GroovyMavenModule {
+
+  def groovyVersion = "5.0.1"
+
+  object test extends GroovyMavenTests with TestModule.Junit5 {
+  }
+  object integration extends GroovyMavenTests with TestModule.Junit5 {
+  }
+}
+
+// `GroovyMavenModule` is a variant of `GroovyModule`
+// that uses the more verbose folder layout of Maven, `sbt`, and other tools:
+//
+// - `foo/src/main/java`
+// - `foo/src/main/groovy`
+// - `foo/src/test/java`
+// - `foo/src/test/groovy`
+// - `foo/src/integration/java`
+// - `foo/src/integration/groovy`
+//
+// Rather than Mill's
+//
+// - `foo/src`
+// - `foo/test/src`
+//
+// This is especially useful if you are migrating from Maven to Mill (or vice
+// versa), during which a particular module may be built using both Maven and
+// Mill at the same time
+
+/** Usage
+
+> ./mill foo.compile
+Compiling 1 Groovy source...
+
+> ./mill foo.test.compile
+Compiling 1 Groovy source...
+
+> ./mill foo.test.testForked
+...foo.FooTests hello ...
+
+> ./mill foo.test
+...foo.FooTests hello ...
+
+> ./mill foo.integration
+...foo.FooIntegrationTests hello ...
+
+*/
+
+// For more details on migrating from other build tools, see xref:migrating/migrating.adoc[]

example/groovylib/basic/2-compat-modules/foo/src/integration/groovy/foo/FooIntegrationTests.groovy

@@ -0,0 +1,12 @@
+package foo
+
+import org.junit.jupiter.api.Test
+
+class FooIntegrationTests {
+    @Test
+    void "hello should print correct greeting"() {
+        // Groovy creates an implicit class for the script named after the file
+        def foo = new Foo()
+        assert foo.hello() == "Hello World, Earth"
+    }
+}

example/groovylib/basic/2-compat-modules/foo/src/main/groovy/foo/Foo.groovy

@@ -0,0 +1,9 @@
+package foo
+
+def run(){
+    println(hello())
+}
+
+def hello() {
+    "Hello World, ${Foo2.VALUE}"
+}

example/groovylib/basic/2-compat-modules/foo/src/main/java/foo/Foo2.java

@@ -0,0 +1,5 @@
+package foo;
+
+public class Foo2 {
+  public static final String VALUE = "Earth";
+}

example/groovylib/basic/2-compat-modules/foo/src/test/groovy/foo/FooTests.groovy

@@ -0,0 +1,13 @@
+package foo
+
+import org.junit.jupiter.api.Test
+
+class FooTest {
+
+    @Test
+    void "hello should print correct greeting"() {
+        // Groovy creates an implicit class for the script named after the file
+        def foo = new Foo()
+        assert foo.hello() == "Hello World, Earth"
+    }
+}

example/groovylib/testing/1-test-suite/bar/src/bar/Bar.groovy

@@ -0,0 +1,9 @@
+package bar
+
+def hello() {
+    "Hello World"
+}
+
+def run(){
+    println new Bar().hello()
+}

example/groovylib/testing/1-test-suite/bar/test/src/bar/BarTests.groovy

@@ -0,0 +1,29 @@
+package bar
+
+import org.junit.jupiter.api.Test
+import groovy.mock.interceptor.MockFor
+
+class BarTests{
+    @Test
+    void "hello"() {
+        def result = new Bar().hello()
+        assert result == "Hello World"
+    }
+
+    @Test
+    void "world"() {
+        def result = new Bar().hello()
+        assert result.endsWith("World")
+    }
+
+    @Test
+    void "using groovy mocks"() {
+        def mockBar = new MockFor(Bar)
+        mockBar.demand.hello { "Hello GroovyMock World" }
+
+        mockBar.use{
+            def result = new Bar().hello()
+            assert result == "Hello GroovyMock World"
+        }
+    }
+}