import java.io.{FileInputStream, File, InputStream, FileWriter}
import sbt._
import scala.io._
/**
* Create the scala binaries
* Based on scala.tools.ant.ScalaTool
* @author Grégory Moix (for the sbt adaptation)
*/
trait ScalaTools{
self:BasicLayer =>
lazy val templatesLocation = compilerConfig.srcDir/ "scala" / "tools" / "ant" / "templates"
lazy val unixTemplate = templatesLocation / "tool-unix.tmpl"
lazy val winTemplate = templatesLocation / "tool-windows.tmpl"
// XXX encoding and generalize
private def getResourceAsCharStream(resource: Path): Stream[Char] = {
val stream = new FileInputStream(resource.asFile)
def streamReader():Stream[Char]= stream.read match{
case -1 => Stream.empty
case value => Stream.cons(value.asInstanceOf[Char], streamReader())
}
if (stream == null) {
log.debug("Stream was null")
Stream.empty
}
//else Stream continually stream.read() takeWhile (_ != -1) map (_.asInstanceOf[Char]) // Does not work in scala 2.7.7
else streamReader
}
// Converts a variable like @SCALA_HOME@ to ${SCALA_HOME} when pre = "${" and post = "}"
private def transposeVariableMarkup(text: String, pre: String, post: String) : String = {
val chars = Source.fromString(text)
val builder = new StringBuilder()
while (chars.hasNext) {
val char = chars.next
if (char == '@') {
var char = chars.next
val token = new StringBuilder()
while (chars.hasNext && char != '@') {
token.append(char)
char = chars.next
}
if (token.toString == "")
builder.append('@')
else
builder.append(pre + token.toString + post)
} else builder.append(char)
}
builder.toString
}
private def readAndPatchResource(resource: Path, tokens: Map[String, String]): String = {
val chars = getResourceAsCharStream(resource).elements
val builder = new StringBuilder()
while (chars.hasNext) {
val char = chars.next
if (char == '@') {
var char = chars.next
val token = new StringBuilder()
while (chars.hasNext && char != '@') {
token.append(char)
char = chars.next
}
if (tokens.contains(token.toString))
builder.append(tokens(token.toString))
else if (token.toString == "")
builder.append('@')
else
builder.append("@" + token.toString + "@")
} else builder.append(char)
}
builder.toString
}
private def writeFile(file: File, content: String, makeExecutable:Boolean):Option[String] =
if (file.exists() && !file.canWrite())
Some("File " + file + " is not writable")
else {
val writer = new FileWriter(file, false)
writer.write(content)
writer.close()
file.setExecutable(makeExecutable)
None
}
/** Gets the value of the classpath attribute in a Scala-friendly form.
* @return The class path as a list of files. */
private def getUnixclasspath(classpath:List[String]): String =
transposeVariableMarkup(classpath.mkString("", ":", "").replace('\\', '/'), "${", "}")
/** Gets the value of the classpath attribute in a Scala-friendly form.
* @return The class path as a list of files. */
private def getWinclasspath(classpath:List[String]): String =
transposeVariableMarkup(classpath.mkString("", ";", "").replace('/', '\\'), "%", "%")
/** Performs the tool creation of a tool with for a given os
* @param file
* @param mainClas
* @param properties
* @param javaFlags
* @param toolFlags
* @param classPath
* @param template
* @param classpathFormater
*/
private def tool(template:Path,classpathFormater: List[String]=>String, file:Path,mainClass:String,
properties:String,javaFlags:String,toolFlags:String,classPath:List[Path],makeExecutable:Boolean):Option[String] = {
val patches = Map (
("class", mainClass),
("properties", properties),
("javaflags", javaFlags),
("toolflags", toolFlags),
("classpath", classpathFormater(classPath.map(_.absolutePath)))
)
val result = readAndPatchResource(template,patches)
writeFile(file.asFile,result,makeExecutable)
}
private def generateTool(config:ToolConfiguration):Option[String] =
generateTool(config.toolName,config.destination,config.mainClass,config.properties,config.javaFlags,config.toolFlags,config.classPath)
private def generateTool(toolName:String,destination:Path,mainClass:String, properties:String,javaFlags:String,toolFlags:String,classPath:List[Path]):Option[String] ={
val unixFile = destination / toolName
val winFile = destination /(toolName + ".bat")
tool(unixTemplate,getUnixclasspath,unixFile,mainClass, properties,javaFlags,toolFlags,classPath,true) orElse
tool(winTemplate,getWinclasspath,winFile,mainClass, properties,javaFlags,toolFlags,classPath,false)
}
/*============================================================================*\
** Definition of the different tools **
\*============================================================================*/
private val defaultJavaFlags = "-Xmx256M -Xms32M"
/**
* A class that holds the different parameters of a tool
*/
class ToolConfiguration(val toolName:String, val destination:Path, val mainClass:String, val properties:String, val javaFlags:String,val toolFlags:String,val classPath:List[Path])
/**
* Generate all tools
* @param destination Root folder where all the binaries will be written
* @param classpath Should be specified when you want to use a specific classpath, could be Nil if you want
* to make the bin use what is in the lib folder of the distribution.
*/
def tools(destination:Path,classpath:List[Path]) = task{
val scala = new ToolConfiguration("scala", destination, "scala.tools.nsc.MainGenericRunner", "",defaultJavaFlags, "", classpath)
val scalac = new ToolConfiguration("scalac", destination, "scala.tools.nsc.Main", "",defaultJavaFlags, "", classpath)
val scaladoc = new ToolConfiguration("scaladoc",destination,"scala.tools.nsc.ScalaDoc", "",defaultJavaFlags,"", classpath)
val fsc = new ToolConfiguration("fsc", destination,"scala.tools.nsc.CompileClient", "",defaultJavaFlags, "", classpath)
val scalap = new ToolConfiguration("scalap",destination, "scala.tools.scalap.Main", "",defaultJavaFlags, "", classpath)
val toolList = scala ::scalac::scaladoc::fsc::scalap::Nil
def process(list:List[ToolConfiguration]):Option[String] = list match{
case x::xs => {
log.debug("Generating "+x.toolName+" bin")
generateTool(x) orElse process(xs)
}
case Nil => None
}
FileUtilities.createDirectory(destination,log)
process(toolList)
}
}
