Scala example source code file (ScalaTools.scala)

This example Scala source code file (ScalaTools.scala) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Scala tags/keywords

file, io, list, list, map, none, option, path, path, stream, string, string, stringbuilder, toolconfiguration, toolconfiguration

The Scala ScalaTools.scala source code

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)

  }
}