Added some configuration of how template start scripts are generated.

* Use same classpath ordering as sbt in start scripts
* Allow user configuration of additional hooks for the script.

Review by @huntc to see if we're any closer to parity with Play.

Author: jsuereth

src/main/resources/com/typesafe/sbt/packager/archetypes/bash-template

@@ -137,16 +137,15 @@ is_function_defined() {
   declare -f "$1" > /dev/null
 }
 
-# If we're *not* running in a terminal, and we don't have any arguments, then we need to add the 'ui' parameter
+# Attempt to detect if the script is running via a GUI or not
+# TODO - Determine where/how we use this generically
 detect_terminal_for_ui() {
   [[ ! -t 0 ]] && [[ "${#residual_args}" == "0" ]] && {
-    addResidual "ui"
+    echo "true"
   }
   # SPECIAL TEST FOR MAC
   [[ "$(uname)" == "Darwin" ]] && [[ "$HOME" == "$PWD" ]] && [[ "${#residual_args}" == "0" ]] && {
-    echo "Detected MAC OSX launched script...."
-    echo "Swapping to UI"
-    addResidual "ui"
+    echo "true"
   }
 }
 
@@ -182,7 +181,6 @@ run() {
 
   # process the combined args, then reset "$@" to the residuals
   process_args "$@"
-  detect_terminal_for_ui
   set -- "${residual_args[@]}"
   argumentCount=$#
 
@@ -251,11 +249,10 @@ declare -a residual_args
 declare -a java_args
 declare -a app_commands
 declare -r app_home="$(realpath "$(dirname "$0")")"
-${{template_declares}}
-declare -r java_cmd=$(get_java_cmd)
 # TODO - Check whether this is ok in cygwin...
 declare -r lib_dir="${app_home}/../lib"
-declare -r app_classpath="$lib_dir/*"
+${{template_declares}}
+declare -r java_cmd=$(get_java_cmd)
 
 # Now check to see if it's a good enough version
 # TODO - Check to see if we have a configured default java version, otherwise use 1.6

src/main/resources/com/typesafe/sbt/packager/archetypes/bat-template

@@ -11,6 +11,8 @@
 if "%@@APP_ENV_NAME@@_HOME%"=="" set "@@APP_ENV_NAME@@_HOME=%~dp0\\.."
 set ERROR_CODE=0
 
+set "APP_LIB_DIR=%@@APP_ENV_NAME@@_HOME%\lib\"
+
 rem Detect if we were double clicked, although theoretically A user could
 rem manually run cmd /c
 for %%x in (%cmdcmdline%) do if %%~x==/c set DOUBLECLICKED=1
@@ -85,9 +87,10 @@ set _JAVA_OPTS=%JAVA_OPTS%
 if "%_JAVA_OPTS%"=="" set _JAVA_OPTS=%CFG_OPTS%
 
 :run
-
+ 
+set "APP_CLASSPATH=@@APP_CLASSPATH@@"
 rem TODO - figure out how to pass arguments....
-"%_JAVACMD%" %_JAVA_OPTS% %@@APP_ENV_NAME@@_OPTS% -cp "%@@APP_ENV_NAME@@_HOME%\lib\*" @@APP_MAIN_CLASS@@ %CMDS%
+"%_JAVACMD%" %_JAVA_OPTS% %@@APP_ENV_NAME@@_OPTS% -cp "%APP_CLASSPATH%" @@APP_MAIN_CLASS@@ %CMDS%
 if ERRORLEVEL 1 goto error
 goto end
 

src/main/scala/com/typesafe/sbt/packager/Keys.scala

@@ -10,7 +10,14 @@ object Keys extends linux.Keys
   with universal.UniversalKeys {
 
   // TODO - Do these keys belong here?
+
+  // These keys are used by the JavaApp archetype.
+  val classpathOrdering = TaskKey[Seq[(File, String)]]("classpathOrdering", "The order of the classpath used at runtime for the bat/bash scripts.")
   val makeBashScript = TaskKey[Option[File]]("makeBashScript", "Creates or discovers the bash script used by this project.")
+  val bashScriptDefines = TaskKey[Seq[String]]("bashScriptDefines", "A list of definitions that should be written to the bash file template.")
+  val bashScriptExtraDefines = TaskKey[Seq[String]]("bashScriptExtraDefines", "A list of extra definitions that should be written to the bash file template.")
+  val scriptClasspath = TaskKey[Seq[String]]("scriptClasspath", "A list of relative filenames (to the lib/ folder in the distribution) of what to include on the classpath.")
   val makeBatScript = TaskKey[Option[File]]("makeBatScript", "Creates or discovers the bat script used by this project.")
+  val batScriptReplacements = TaskKey[Seq[(String,String)]]("batScriptReplacements", "Replacements of template parameters used in the windows bat script.")
 
 }

src/main/scala/com/typesafe/sbt/packager/archetypes/JavaApp.scala

@@ -4,7 +4,7 @@ package archetypes
 
 import Keys._
 import sbt._
-import sbt.Keys.{mappings, target, name, mainClass}
+import sbt.Keys.{mappings, target, name, mainClass, normalizedName}
 import linux.LinuxPackageMapping
 import SbtNativePackager._
 
@@ -19,40 +19,71 @@ import SbtNativePackager._
 object JavaAppPackaging {
 
   def settings: Seq[Setting[_]] = Seq(
-    mappings in Universal <++= (Keys.managedClasspath in Compile) map universalDepMappings,
-    mappings in Universal <+= (Keys.packageBin in Compile) map { jar =>
-      jar -> ("lib/" + jar.getName)
+    // Here we record the classpath as it's added to the mappings separately, so
+    // we cna use it to generate the bash/bat scripts.
+    classpathOrdering := Nil, 
+    classpathOrdering <+= (Keys.packageBin in Compile) map { jar =>
+	  jar -> ("lib/" + jar.getName)
+	},
+    classpathOrdering <++= (Keys.managedClasspath in Compile) map universalDepMappings,
+    mappings in Universal <++= classpathOrdering,
+    scriptClasspath <<= classpathOrdering map makeRelativeClasspathNames, 
+    bashScriptExtraDefines := Nil,
+    bashScriptDefines <<= (Keys.mainClass in Compile, scriptClasspath, bashScriptExtraDefines) map { (mainClass, cp, extras) =>
+      val hasMain =
+        for {
+          cn <- mainClass
+        } yield JavaAppBashScript.makeDefines(cn, appClasspath = cp, extras = extras)
+      hasMain getOrElse Nil
     },
-    makeBashScript <<= (Keys.mainClass in Compile, target in Universal, name in Universal) map makeUniversalBinScript,
-    makeBatScript <<= (Keys.mainClass in Compile, target in Universal, name) map makeUniversalBatScript,
-    mappings in Universal <++= (makeBashScript, name) map { (script, name) =>
+    makeBashScript <<= (bashScriptDefines, target in Universal, normalizedName) map makeUniversalBinScript,
+    batScriptReplacements <<= (normalizedName, Keys.mainClass in Compile, scriptClasspath) map { (name, mainClass, cp) =>
+      mainClass map { mc => 
+        JavaAppBatScript.makeReplacements(name = name, mainClass = mc, appClasspath = cp)
+      } getOrElse Nil
+      
+    },
+    makeBatScript <<= (batScriptReplacements, target in Universal, normalizedName) map makeUniversalBatScript,
+    mappings in Universal <++= (makeBashScript, normalizedName) map { (script, name) =>
       for {
         s <- script.toSeq  
       } yield s -> ("bin/" + name)
     },
-    mappings in Universal <++= (makeBatScript, name) map { (script, name) =>
+    mappings in Universal <++= (makeBatScript, normalizedName) map { (script, name) =>
       for {
         s <- script.toSeq  
       } yield s -> ("bin/" + name + ".bat")
     } 
   )
 
-  def makeUniversalBinScript(mainClass: Option[String], tmpDir: File, name: String): Option[File] = 
-    for(mc <- mainClass) yield {
-      val scriptBits = JavaAppBashScript.generateScript(mc)
+  def makeRelativeClasspathNames(mappings: Seq[(File, String)]): Seq[String] =
+    for {
+      (file, name) <- mappings
+    } yield {
+      // Here we want the name relative to the lib/ folder...
+      // For now we just cheat...
+      if(name startsWith "lib/") name drop 4
+      else "../" + name
+    }
+  
+  def makeUniversalBinScript(defines: Seq[String], tmpDir: File, name: String): Option[File] = 
+    if(defines.isEmpty) None
+    else {
+      val scriptBits = JavaAppBashScript.generateScript(defines)
       val script = tmpDir / "tmp" / "bin" / name
       IO.write(script, scriptBits)
       // TODO - Better control over this!
       script.setExecutable(true)
-      script
+      Some(script)
     }
 
-  def makeUniversalBatScript(mainClass: Option[String], tmpDir: File, name: String): Option[File] = 
-    for(mc <- mainClass) yield {
-      val scriptBits = JavaAppBatScript.generateScript(name, mc)
+  def makeUniversalBatScript(replacements: Seq[(String, String)], tmpDir: File, name: String): Option[File] = 
+    if(replacements.isEmpty) None
+    else {
+      val scriptBits = JavaAppBatScript.generateScript(replacements)
       val script = tmpDir / "tmp" / "bin" / (name + ".bat")
       IO.write(script, scriptBits)
-      script
+      Some(script)
     }
 
   // Converts a managed classpath into a set of lib mappings.
@@ -64,10 +95,10 @@ object JavaAppPackaging {
       // TODO - Figure out what to do with jar files.
     } yield {
       val filename: Option[String] = for {
-            module <- dep.metadata.get(AttributeKey[ModuleID]("module-id"))
-            artifact <- dep.metadata.get(AttributeKey[Artifact]("artifact"))
-          } yield {
-            module.organization + "." +
+        module <- dep.metadata.get(AttributeKey[ModuleID]("module-id"))
+        artifact <- dep.metadata.get(AttributeKey[Artifact]("artifact"))
+      } yield {
+        module.organization + "." +
               module.name + "-" +
               Option(artifact.name.replace(module.name, "")).filterNot(_.isEmpty).map(_ + "-").getOrElse("") +
               module.revision + ".jar"

src/main/scala/com/typesafe/sbt/packager/archetypes/JavaAppBashScript.scala

@@ -1,17 +1,42 @@
 package com.typesafe.sbt.packager.archetypes
 
+/**
+ * Constructs a bash script for running a java application.
+ * 
+ * Makes use of the associated bash-template, with a few hooks
+ * 
+ */
 object JavaAppBashScript {
 
   private[this] def bashTemplateSource =
     getClass.getResource("bash-template")
   private[this] def charset =
     java.nio.charset.Charset.forName("UTF-8")
-  def generateScript(mainClass: String,
-                     configFile: Option[String] = None): String = {
-     val sb = new StringBuffer
-     val defines: Seq[String] =
+    
+  /** Creates the block of defines for a script.
+   * 
+   * @param mainClass The required "main" method class we use to run the program.
+   * @param appClasspath A sequence of relative-locations (to the lib/ folder) of jars
+   *                     to include on the classpath.
+   * @param configFile An (optional) filename from which the script will read arguments.
+   * @param extras  Any additional defines/commands that should be run in this script. 
+   */
+  def makeDefines(
+      mainClass: String,
+      appClasspath: Seq[String] = Seq("*"),
+      configFile: Option[String] = None,
+      extras: Seq[String] = Nil): Seq[String] =
+       Seq(mainClassDefine(mainClass)) ++
        (configFile map configFileDefine).toSeq ++
-       Seq(mainClassDefine(mainClass))
+       Seq(makeClasspathDefine(appClasspath)) ++
+       extras
+       
+  private def makeClasspathDefine(cp: Seq[String]): String = {
+    val fullString = cp map (n => "$lib_dir/"+n) mkString ":"
+    "declare -r app_classpath=\""+fullString+"\"\n"
+  }  
+  def generateScript(defines: Seq[String]): String = {
+     val sb = new StringBuffer
      for(line <- sbt.IO.readLinesURL(bashTemplateSource, charset)) {
        if(line contains """${{template_declares}}""") {
          sb append (defines mkString "\n")

src/main/scala/com/typesafe/sbt/packager/archetypes/JavaAppBatScript.scala

@@ -8,18 +8,36 @@ object JavaAppBatScript {
 
   def makeEnvFriendlyName(name: String): String =
     name.toUpperCase.replaceAll("\\W", "_")   
+  
+  def makeWindowsRelativeClasspath(cp: Seq[String]): String = {
+     def cleanPath(path: String): String = path.replaceAll("/", "\\")
+     def makeRelativePath(path: String): String =
+       "%APP_LIB_DIR%\\" + cleanPath(path)
+     cp map makeRelativePath mkString ":"
+   }
+    // TODO - Allow recursive replacements....
+   def makeReplacements(
+       name: String, 
+       mainClass: String, 
+       appClasspath: Seq[String] = Seq("*"),
+       extras: Seq[(String,String)] = Nil): Seq[(String, String)] = {
+     Seq(
+         "APP_NAME" -> name,
+         "APP_MAIN_CLASS" -> mainClass,
+         "APP_ENV_NAME" -> makeEnvFriendlyName(name),
+         "APP_CLASSPATH" -> makeWindowsRelativeClasspath(appClasspath)
+     ) ++ extras
+   }
 
    def generateScript(
-       name: String,
-       mainClass: String): String = {
+       replacements: Seq[(String,String)]): String = {
      val sb = new StringBuffer
      for(line <- sbt.IO.readLinesURL(bashTemplateSource, charset)) {
-       
        val fixed =
-         line.replaceAll("@@APP_NAME@@", name).
-              replaceAll("@@APP_MAIN_CLASS@@", mainClass).
-              replaceAll("@@APP_ENV_NAME@@", makeEnvFriendlyName(name))
-       
+         replacements.foldLeft(line) { 
+           case (line, (key, value)) =>
+             line.replaceAll("@@"+key+"@@", java.util.regex.Matcher.quoteReplacement(value))
+         }
        sb append fixed
        sb append "\r\n"
      }