Merge pull request #494 from metasim/feature/javapackager-format

Added translation of `jvmopts` contents and enhanced example app.

Author: muuki88

README.md

@@ -79,38 +79,16 @@ packageBin in Debian <<= debianJDebPackaging in Debian
 
 JDK 8 from Oracle includes the tool `javapackager` (née `javafxpackager`) to generate application
 launchers and native installers for MacOS X, Windows, and Linux. This plugin complements the existing
-`sbt-native-packager` formats by taking the staged output from `JavaAppPackaging` and `Universal`
-settings and passing them through `javapackager`.
+`sbt-native-packager` formats by taking the settings and staged output from `JavaAppPackaging`
+and passing them through `javapackager`.
 
-This plugin's most significant complement to the core capabilities is the generation of
-MacOS X App bundles and derived `.dmg` and `.pkg` packages. It can also generate Linux `.deb` and `.rpm`
-packages, and Windows `.exe` and `.msi` installers, provided the requisite tools are available on the
-build platform.
+This plugin's most significant complement to the core `sbt-native-packager` capabilities is the
+generation of MacOS X App bundles, and associated `.dmg` and `.pkg` package formats.
+It can also generate Windows `.exe` and `.msi` installers provided the requisite tools are
+available on the Windows build platform.
 
-For details on the capabilities of `javapackager`, see the [windows](http://docs.oracle.com/javase/8/docs/technotes/tools/windows/javapackager.html) and [Unix](http://docs.oracle.com/javase/8/docs/technotes/tools/unix/javapackager.html) references. (Note: only a few of the possible
-settings are exposed through this plugin. Please submit a github issue or pull request if something
-specific is desired.)
+For usage details see the [JDKPackager Plugin guide](http://www.scala-sbt.org/sbt-native-packager/formats/jdkpackager.html).
 
-Using this plugin requires running SBT under JDK 8, or setting `jdkPackagerTool` to the location
-of the tool.
-
-To use, first get your application working per `JavaAppPackaging` instructions (including `mainClass`),
-then add
-
-```scala
-enablePlugins(JDKPackagerPlugin)
-```
-
-to your build file. Then run `sbt jdkPackager:packageBin`.
-
-By default, the plugin makes the installer type that is native to the current build platform in
-the directory `target/jdkpackager`. The key `jdkPackageType` can be used to modify this behavior.
-Run `help jdkPackageType` in sbt for details. The most popular setting is likely to be `jdkAppIcon`. See
-[the example build file](test-project-jdkpackager/build.sbt) on how to use it.
-
-To take it for a test spin, run `sbt jdkPackager:packageBin` in the `test-project-jdkpackager` directory
-and then look in the `target/jdkpackager/bundles` directory for the result. See [Oracle documentation](http://docs.oracle.com/javase/8/docs/technotes/guides/deploy/self-contained-packaging.html) for Windows and
-Linux build prerequisites.
 
 ## Documentation ##
 

src/main/scala/com/typesafe/sbt/packager/jdkpackager/JDKPackagerHelper.scala

@@ -10,7 +10,7 @@ import sbt._
  */
 object JDKPackagerHelper {
 
-  // Try to compute determine a default path for the java packager tool.
+  /** Attempts to compute the path to the `javapackager` tool. */
   def locateJDKPackagerTool(): Option[File] = {
     val jdkHome = sys.props.get("java.home").map(p ⇒ file(p))
 
@@ -26,32 +26,12 @@ object JDKPackagerHelper {
       .filter(_.exists())
   }
 
-  def mkProcess(
-    tool: File,
-    mode: String,
-    argMap: Map[String, String],
-    log: Logger) = {
-
-    val invocation = Seq(tool.getAbsolutePath, mode, "-v")
-
-    val argSeq = argMap.map(p ⇒ Seq(p._1, p._2)).flatten[String].filter(_.length > 0)
-    val args = invocation ++ argSeq
-
-    val argString = args.map {
-      case s if s.contains(" ") ⇒ s""""$s""""
-      case s                    ⇒ s
-    }.mkString(" ")
-    log.debug(s"Package command: $argString")
-
-    // To help debug arguments
-    val script = file(argMap("-outdir")) / "jdkpackager.sh"
-    IO.write(script, s"#!/bin/bash\n$argString\n")
-    chmod(script, "766")
-
-    Process(args)
-  }
-
-  def mkArgMap(
+  /**
+   * Generates key-value pairs to be converted into command line arguments fed to `javapackager`.
+   * If an argument is mono/standalone (not key/value) then the key stores the complete argument
+   * and the value is the empty string.
+   */
+  private[jdkpackager] def makeArgMap(
     name: String,
     version: String,
     description: String,
@@ -62,40 +42,79 @@ object JDKPackagerHelper {
     basename: String,
     iconPath: Option[File],
     outputDir: File,
-    sourceDir: File) = {
+    sourceDir: File): Map[String, String] = {
 
-    def iconArg = iconPath
+    val iconArg = iconPath.toSeq
       .map(_.getAbsolutePath)
-      .map(p ⇒ Map(s"-Bicon=$p" -> ""))
-      .getOrElse(Map.empty)
+      .map(p ⇒ s"-Bicon=$p")
 
-    def mainClassArg = mainClass
+    val mainClassArg = mainClass
       .map(c ⇒ Map("-appclass" -> c))
       .getOrElse(Map.empty)
 
-    //    val cpSep = sys.props("path.separator")
-    //    val cp = classpath.map(p ⇒ "lib/" + p)
-    //    val cpStr = cp.mkString(cpSep)
+    // Make a setting?
+    val jvmOptsFile = (sourceDir ** "jvmopts").getPaths.headOption.map(file)
+
+    val jvmOptsArgs = jvmOptsFile.toSeq.flatMap { jvmopts ⇒
+      IO.readLines(jvmopts).map {
+        case a if a startsWith "-X" ⇒ s"-BjvmOptions=$a"
+        case b if b startsWith "-D" ⇒ s"-BjvmProperties=${b.drop(2)}"
+        case c                      ⇒ "" // Ignoring others.... is this OK?
+      }.filter(_.nonEmpty)
+    }
 
     // See http://docs.oracle.com/javase/8/docs/technotes/tools/unix/javapackager.html and
     // http://docs.oracle.com/javase/8/docs/technotes/tools/windows/javapackager.html for
     // command line options. NB: Built-in `-help` is incomplete.
-    Map(
+
+    // TODO:
+    // * copyright/license ( -BlicenseFile=LICENSE )
+    // * environment variables?
+    // * category ?
+
+    val pairs = Map(
       "-name" -> name,
       "-srcdir" -> sourceDir.getAbsolutePath,
       "-native" -> packageType,
       "-outdir" -> outputDir.getAbsolutePath,
       "-outfile" -> basename,
       "-description" -> description,
-      "-vendor" -> maintainer,
-      s"-BappVersion=$version" -> "",
-      s"-BmainJar=lib/$mainJar" -> ""
-    ) ++ mainClassArg ++ iconArg
+      "-vendor" -> maintainer
+    ) ++ mainClassArg
 
-    // TODO:
-    // * copyright/license
-    // * JVM options
-    // * application arguments
-    // * environment variables?
+    val singles = Seq(
+      s"-BappVersion=$version",
+      s"-BmainJar=lib/$mainJar"
+    ) ++ iconArg ++ jvmOptsArgs
+
+    // Merge singles into argument pair map. (Need a cleaner abstraction)
+    pairs ++ singles.map((_, "")).toMap
+  }
+
+  /** Generates a configure Process instance, ready to run. */
+  private[jdkpackager] def makeProcess(
+    tool: File,
+    mode: String,
+    argMap: Map[String, String],
+    log: Logger) = {
+
+    val invocation = Seq(tool.getAbsolutePath, mode, "-v")
+
+    val argSeq = argMap.map(p ⇒ Seq(p._1, p._2)).flatten[String].filter(_.length > 0)
+    val args = invocation ++ argSeq
+
+    val argString = args.map {
+      case s if s.contains(" ") ⇒ s""""$s""""
+      case s                    ⇒ s
+    }.mkString(" ")
+    log.debug(s"Package command: $argString")
+
+    // To help debug arguments, create a bash script doing the same.
+    val script = file(argMap("-outdir")) / "jdkpackager.sh"
+    IO.write(script, s"#!/bin/bash\n$argString\n")
+    chmod(script, "766")
+
+    Process(args)
   }
+
 }

src/main/scala/com/typesafe/sbt/packager/jdkpackager/JDKPackagerKeys.scala

@@ -3,22 +3,28 @@ package com.typesafe.sbt.packager.jdkpackager
 import sbt._
 
 /**
- * Keys specific to deployment via the `javapackger` too.
+ * Keys specific to deployment via the `javapackger` tool.
+ *
+ * @author <a href="mailto:[email protected]">Simeon H.K. Fitch</a>
+ * @since 2/11/15
  */
 trait JDKPackagerKeys {
   val jdkPackagerTool = SettingKey[Option[File]]("jdkPackagerTool",
-    "Path to `javapackager` or `javafxpackager` tool in JDK")
+    "Path to `javapackager` or `javafxpackager` tool in JDK.")
+
   val packagerArgMap = TaskKey[Map[String, String]]("packagerArgMap",
     "An intermediate task for computing the command line argument key/value pairs passed to " +
       "`javapackager -deploy`")
+
   val jdkPackagerBasename = SettingKey[String]("jdkPackagerOutputBasename",
     "Filename sans extension for generated installer package.")
-  val jdkPackageType = SettingKey[String]("jdkPackageType",
+
+  val jdkPackagerType = SettingKey[String]("jdkPackagerType",
     """Value passed as the `-native` argument to `javapackager -deploy`.
       | Per `javapackager` documentation, this may be one of the following:
       |
       |    * `all`: Runs all of the installers for the platform on which it is running,
-      |      and creates a disk image for the application. This value is used if type is not specified.
+      |      and creates a disk image for the application.
       |    * `installer`: Runs all of the installers for the platform on which it is running.
       |    * `image`: Creates a disk image for the application. On OS X, the image is
       |      the .app file. On Linux, the image is the directory that gets installed.
@@ -30,13 +36,20 @@ trait JDKPackagerKeys {
       |    * `exe`: Generates a Windows .exe package.
       |    * `msi`: Generates a Windows Installer package.
       |
-      | (NB: Your mileage may vary.)
+      | Defaults to `image`.
     """.stripMargin)
 
   val jdkAppIcon = SettingKey[Option[File]]("jdkAppIcon",
     """Path to platform-specific application icon:
       |    * `icns`: MacOS
       |    * `ico`: Windows
       |    * `png`: Linux
+      |
+      | Defaults to generic Java icon.
     """.stripMargin)
+
+  // To consider:
+  //  val jvmOptionFile = SettingKey[Option[File]]("jvmOptionFile",
+  //    "File with line delimited options to pass to the application JVM. " +
+  //      "Defaults to `stage/conf/jvmopts")
 }

src/main/scala/com/typesafe/sbt/packager/jdkpackager/JDKPackagerPlugin.scala

@@ -27,9 +27,10 @@ object JDKPackagerPlugin extends AutoPlugin {
   def javaPackagerSettings: Seq[Setting[_]] = Seq(
     jdkPackagerTool := JDKPackagerHelper.locateJDKPackagerTool(),
     jdkAppIcon := None,
-    jdkPackageType := "image",
-    jdkPackagerBasename <<= packageName apply (_ + "-pkg"),
-    mappings in JDKPackager <<= (mappings in Universal) map (_.filter(!_._2.startsWith("bin/")))
+    jdkPackagerType := "image",
+    jdkPackagerBasename <<= packageName apply (_ + "-pkg")
+    // jvmOptionFile <<= sourceDirectory apply (src ⇒ Some(src / "conf" / "jvmopts")))
+    // mappings in JDKPackager <<= (mappings in Universal) map (_.filter(!_._2.startsWith("bin/")))
   ) ++ inConfig(JDKPackager)(
     Seq(
       sourceDirectory <<= sourceDirectory apply (_ / dirname),
@@ -45,13 +46,13 @@ object JDKPackagerPlugin extends AutoPlugin {
         version,
         packageDescription,
         maintainer,
-        jdkPackageType,
+        jdkPackagerType,
         ClasspathJarPlugin.autoImport.classspathJarName,
         mainClass,
         jdkPackagerBasename,
         jdkAppIcon,
         target,
-        stage in Universal) map JDKPackagerHelper.mkArgMap
+        stage in Universal) map JDKPackagerHelper.makeArgMap
     )  ++ makePackageBuilder
   )
 
@@ -60,10 +61,10 @@ object JDKPackagerPlugin extends AutoPlugin {
   )
 
   private def makePackageBuilder = Seq(
-    packageBin <<= (jdkPackagerTool, jdkPackageType, packagerArgMap, target, streams) map { (pkgTool, pkg, args, target, s) ⇒
+    packageBin <<= (jdkPackagerTool, jdkPackagerType, packagerArgMap, target, streams) map { (pkgTool, pkg, args, target, s) ⇒
 
       val tool = checkTool(pkgTool)
-      val proc = JDKPackagerHelper.mkProcess(tool, "-deploy", args, s.log)
+      val proc = JDKPackagerHelper.makeProcess(tool, "-deploy", args, s.log)
 
       (proc ! s.log) match {
         case 0 ⇒ ()

src/sphinx/formats/index.rst

@@ -12,3 +12,4 @@ Packaging Formats
    rpm.rst
    docker.rst
    windows.rst
+   jdkpackager.rst