luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Deprecate old Scala+Java fork interfaces in favor of Fork+ForkOptions

This commit is contained in:
Mark Harrah 2013-04-05 09:02:24 -04:00
parent f18ddd2a88
commit 4630222aaa
2 changed files with 47 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
run/src/main/scala/sbt/Fork.scala
View File

@ -5,39 +5,74 @@ package sbt
import java.io.{File,OutputStream}
@deprecated("Use ForkOptions", "0.13.0")
trait ForkJava
{
def javaHome: Option[File]
def outputStrategy: Option[OutputStrategy]
def connectInput: Boolean
}
@deprecated("Use ForkOptions", "0.13.0")
trait ForkScala extends ForkJava
{
def scalaJars: Iterable[File]
}
@deprecated("Use ForkOptions", "0.13.0")
trait ForkScalaRun extends ForkScala
{
def workingDirectory: Option[File]
def runJVMOptions: Seq[String]
}
final case class ForkOptions(javaHome: Option[File] = None, outputStrategy: Option[OutputStrategy] = None, scalaJars: Iterable[File] = Nil, workingDirectory: Option[File] = None, runJVMOptions: Seq[String] = Nil, connectInput: Boolean = false, envVars: Map[String,String] = Map.empty) extends ForkScalaRun
final case class ForkOptions(javaHome: Option[File] = None, outputStrategy: Option[OutputStrategy] = None, bootJars: Seq[File] = Nil, workingDirectory: Option[File] = None, runJVMOptions: Seq[String] = Nil, connectInput: Boolean = false, envVars: Map[String,String] = Map.empty) extends ForkScalaRun
{
@deprecated("Use bootJars.", "0.13.0")
def scalaJars: Iterable[File] = bootJars
}
sealed abstract class OutputStrategy extends NotNull
sealed abstract class OutputStrategy
case object StdoutOutput extends OutputStrategy
case class BufferedOutput(logger: Logger) extends OutputStrategy
case class LoggedOutput(logger: Logger) extends OutputStrategy
case class CustomOutput(output: OutputStream) extends OutputStrategy
import java.lang.{ProcessBuilder => JProcessBuilder}
sealed class Fork(val commandName: String, val runnerClass: Option[String])
{
def apply(config: ForkOptions, arguments: Seq[String]): Int = fork(config, arguments).exitValue()
def fork(config: ForkOptions, arguments: Seq[String]): Process =
{
import config.{envVars => env, _}
val executable = Fork.javaCommand(javaHome, commandName).getAbsolutePath
val options = makeOptions(runJVMOptions, bootJars, arguments)
val command = (executable +: options).toArray
val builder = new JProcessBuilder(command : _*)
workingDirectory.foreach(wd => builder.directory(wd))
val environment = builder.environment
for( (key, value) <- env )
environment.put(key, value)
outputStrategy.getOrElse(StdoutOutput) match {
case StdoutOutput => Process(builder).run(connectInput)
case BufferedOutput(logger) => Process(builder).runBuffered(logger, connectInput)
case LoggedOutput(logger) => Process(builder).run(logger, connectInput)
case CustomOutput(output) => (Process(builder) #> output).run(connectInput)
}
}
private[this] def makeOptions(jvmOptions: Seq[String], bootJars: Iterable[File], arguments: Seq[String]): Seq[String] =
{
val boot = if(bootJars.isEmpty) None else Some("-Xbootclasspath/a:" + bootJars.map(_.getAbsolutePath).mkString(File.pathSeparator))
jvmOptions ++ boot.toList ++ runnerClass.toList ++ arguments
}
}
object Fork
{
private val ScalacMainClass = "scala.tools.nsc.Main"
private val ScalaMainClass = "scala.tools.nsc.MainGenericRunner"
private val JavaCommandName = "java"
val java = new ForkJava("java")
val java = new ForkJava(JavaCommandName)
val javac = new ForkJava("javac")
val scala = new ForkScala(ScalaMainClass)
val scalac = new ForkScala(ScalacMainClass)
val scala = new Fork(JavaCommandName, Some(ScalaMainClass))
val scalac = new Fork(JavaCommandName, Some(ScalacMainClass))
private def javaCommand(javaHome: Option[File], name: String): File =
{
@ -45,11 +80,9 @@ object Fork
new File(new File(home, "bin"), name)
}
final class ForkJava(commandName: String)
@deprecated("Use Fork", "0.13.0")
final class ForkJava(commandName: String) extends Fork(commandName, None)
{
def apply(config: ForkOptions, arguments: Seq[String]): Int = fork(config, arguments).exitValue()
def fork(config: ForkOptions, arguments: Seq[String]): Process =
fork(config.javaHome, config.runJVMOptions ++ arguments, config.workingDirectory, config.envVars, config.connectInput, config.outputStrategy getOrElse StdoutOutput)
@deprecated("Use apply(ForkOptions, Seq[String])", "0.13.0")
def apply(javaHome: Option[File], options: Seq[String], log: Logger): Int =
apply(javaHome, options, BufferedOutput(log))
@ -69,6 +102,8 @@ object Fork
@deprecated("Use apply(ForkOptions, Seq[String])", "0.13.0")
def apply(javaHome: Option[File], options: Seq[String], workingDirectory: Option[File], env: Map[String, String], outputStrategy: OutputStrategy): Int =
fork(javaHome, options, workingDirectory, env, false, outputStrategy).exitValue
@deprecated("Use apply(ForkOptions, Seq[String])", "0.13.0")
def fork(javaHome: Option[File], options: Seq[String], workingDirectory: Option[File], env: Map[String, String], connectInput: Boolean, outputStrategy: OutputStrategy): Process =
{
val executable = javaCommand(javaHome, commandName).getAbsolutePath
@ -87,12 +122,9 @@ object Fork
}
}
@deprecated("Use Fork", "0.13.0")
final class ForkScala(mainClassName: String)
{
def apply(options: ForkOptions, arguments: Seq[String]): Int = fork(options, arguments).exitValue()
def fork(options: ForkOptions, arguments: Seq[String]): Process =
fork(options.javaHome, options.runJVMOptions, options.scalaJars, arguments, options.workingDirectory, options.envVars, options.connectInput, options.outputStrategy getOrElse StdoutOutput)
@deprecated("Use apply(ForkOptions, Seq[String])", "0.13.0")
def apply(javaHome: Option[File], jvmOptions: Seq[String], scalaJars: Iterable[File], arguments: Seq[String], log: Logger): Int =
apply(javaHome, jvmOptions, scalaJars, arguments, None, BufferedOutput(log))
@ -109,6 +141,7 @@ object Fork
def fork(javaHome: Option[File], jvmOptions: Seq[String], scalaJars: Iterable[File], arguments: Seq[String], workingDirectory: Option[File], connectInput: Boolean, outputStrategy: OutputStrategy): Process =
fork(javaHome, jvmOptions, scalaJars, arguments, workingDirectory, connectInput, outputStrategy)
@deprecated("Use apply(ForkOptions, Seq[String])", "0.13.0")
def fork(javaHome: Option[File], jvmOptions: Seq[String], scalaJars: Iterable[File], arguments: Seq[String], workingDirectory: Option[File], env: Map[String,String], connectInput: Boolean, outputStrategy: OutputStrategy): Process =
{
if(scalaJars.isEmpty) sys.error("Scala jars not specified")

2
run/src/main/scala/sbt/Run.scala
View File

@ -16,7 +16,7 @@ trait ScalaRun
class ForkRun(config: ForkOptions) extends ScalaRun
{
@deprecated("Use the `ForkRun(ForkOptions) constructor`", "0.13.0")
def this(options: ForkScalaRun) = this(ForkOptions(options.javaHome, options.outputStrategy, options.scalaJars, options.workingDirectory, options.runJVMOptions, options.connectInput))
def this(options: ForkScalaRun) = this(ForkOptions(options.javaHome, options.outputStrategy, options.scalaJars.toSeq, options.workingDirectory, options.runJVMOptions, options.connectInput))
def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Option[String] =
{