Assorted JlinkPlugin improvements (#1242)

* Use sys.props("java.home") if javaHome is not defined (JlinkPlugin)

* Add Ignore.byPackagePrefix (JlinkPlugin)

* Add jlinkModulePath (JlinkPlugin)

Author: nigredo-tori

src/main/scala/com/typesafe/sbt/packager/archetypes/jlink/JlinkKeys.scala

@@ -29,4 +29,7 @@ private[packager] trait JlinkKeys {
 
   val jlinkBuildImage =
     TaskKey[File]("jlinkBuildImage", "Runs jlink. Yields the directory with the runtime image")
+
+  val jlinkModulePath =
+    TaskKey[Seq[File]]("jlinkModulePath", "Module path to supply to jlink")
 }

src/main/scala/com/typesafe/sbt/packager/archetypes/jlink/JlinkPlugin.scala

@@ -89,6 +89,10 @@ object JlinkPlugin extends AutoPlugin {
           module
       }.distinct
     },
+    jlinkModulePath := (jlinkModulePath ?? Nil).value,
+    jlinkModulePath ++= {
+      fullClasspath.in(jlinkBuildImage).value.map(_.data)
+    },
     jlinkOptions := (jlinkOptions ?? Nil).value,
     jlinkOptions ++= {
       val modules = jlinkModules.value
@@ -97,7 +101,11 @@ object JlinkPlugin extends AutoPlugin {
         sys.error("jlinkModules is empty")
       }
 
-      JlinkOptions(addModules = modules, output = Some(target.in(jlinkBuildImage).value))
+      JlinkOptions(
+        addModules = modules,
+        output = Some(target.in(jlinkBuildImage).value),
+        modulePath = jlinkModulePath.value
+      )
     },
     jlinkBuildImage := {
       val log = streams.value.log
@@ -129,25 +137,28 @@ object JlinkPlugin extends AutoPlugin {
       .pair(file => IO.relativize(dir, file))
 
   private def runJavaTool(jvm: Option[File], log: Logger)(exeName: String, args: Seq[String]): ProcessBuilder = {
-    val exe = jvm match {
-      case None     => exeName
-      case Some(jh) => (jh / "bin" / exeName).getAbsolutePath
-    }
+    val jh = jvm.getOrElse(file(sys.props.getOrElse("java.home", sys.error("no java.home"))))
+    val exe = (jh / "bin" / exeName).getAbsolutePath
 
     log.info("Running: " + (exe +: args).mkString(" "))
 
     Process(exe, args)
   }
 
   private object JlinkOptions {
+    @deprecated("1.3.24", "")
     def apply(addModules: Seq[String] = Nil, output: Option[File] = None): Seq[String] =
+      apply(addModules = addModules, output = output, modulePath = Nil)
+
+    def apply(addModules: Seq[String], output: Option[File], modulePath: Seq[File]): Seq[String] =
       option("--output", output) ++
-        list("--add-modules", addModules)
+        list("--add-modules", addModules) ++
+        list("--module-path", modulePath)
 
     private def option[A](arg: String, value: Option[A]): Seq[String] =
       value.toSeq.flatMap(a => Seq(arg, a.toString))
 
-    private def list(arg: String, values: Seq[String]): Seq[String] =
+    private def list[A](arg: String, values: Seq[A]): Seq[String] =
       if (values.nonEmpty) Seq(arg, values.mkString(",")) else Nil
   }
 
@@ -204,5 +215,22 @@ object JlinkPlugin extends AutoPlugin {
     val nothing: ((String, String)) => Boolean = Function.const(false)
     val everything: ((String, String)) => Boolean = Function.const(true)
     def only(dependencies: (String, String)*): ((String, String)) => Boolean = dependencies.toSet.contains
+
+    /** This matches pairs by their respective ''package'' prefixes. This means that `"foo.bar"`
+      * matches `"foo.bar"`, `"foo.bar.baz"`, but not `"foo.barqux"`. Empty
+      * string matches anything.
+      */
+    def byPackagePrefix(prefixPairs: (String, String)*): ((String, String)) => Boolean = {
+      case (a, b) =>
+        prefixPairs.exists {
+          case (prefixA, prefixB) =>
+            packagePrefixMatches(prefixA, a) && packagePrefixMatches(prefixB, b)
+        }
+    }
+
+    private def packagePrefixMatches(prefix: String, s: String): Boolean =
+      prefix.isEmpty ||
+        s == prefix ||
+        s.startsWith(prefix + ".")
   }
 }

src/sphinx/archetypes/misc_archetypes.rst

@@ -50,14 +50,13 @@ The plugin analyzes the dependencies between packages using `jdeps`, and raises
       "foo.bar" -> "bar.qux"
     )
 
-For large projects with a lot of dependencies this can get unwieldy. You can implement a more flexible ignore strategy:
+For large projects with a lot of dependencies this can get unwieldy. You can use a more flexible ignore strategy:
 
 .. code-block:: scala
 
-  jlinkIgnoreMissingDependency := {
-    case ("foo.bar", dependee) if dependee.startsWith("bar") => true
-    case _ => false
-  }
+  jlinkIgnoreMissingDependency := JlinkIgnore.byPackagePrefix(
+    "foo.bar" -> "bar"
+  )
 
 Otherwise you may opt out of the check altogether (which is not recommended):
 

src/test/scala/com/typesafe/sbt/packager/archetypes/jlink/JlinkSpec.scala

@@ -0,0 +1,23 @@
+package com.typesafe.sbt.packager.archetypes.jlink
+
+import org.scalatest.{FlatSpec, Matchers}
+import JlinkPlugin.Ignore.byPackagePrefix
+
+class JlinkSpec extends FlatSpec with Matchers {
+  "Ignore.byPackagePrefix()" should "match as expected for sample examples" in {
+    byPackagePrefix("" -> "")("foo" -> "bar") should be(true)
+
+    byPackagePrefix("foo" -> "bar")("foo" -> "bar") should be(true)
+    byPackagePrefix("foo" -> "bar")("bar" -> "foo") should be(false)
+    byPackagePrefix("foo" -> "bar")("baz" -> "bar") should be(false)
+    byPackagePrefix("foo" -> "bar")("foo" -> "baz") should be(false)
+
+    byPackagePrefix("foo" -> "bar")("foobaz" -> "barqux") should be(false)
+    byPackagePrefix("foo" -> "bar")("foo.baz" -> "bar.qux") should be(true)
+    byPackagePrefix("foo.baz" -> "bar.qux")("foo" -> "bar") should be(false)
+
+    byPackagePrefix("" -> "", "foo" -> "bar")("baz" -> "qux") should be(true)
+    byPackagePrefix("foo" -> "bar", "" -> "")("baz" -> "qux") should be(true)
+    byPackagePrefix("foo" -> "", "" -> "bar")("baz" -> "qux") should be(false)
+  }
+}