Added server-side compilation of *.java files (along with *.scala files)

scalatron · scalatron · commit 42ae84aec426 · 2012-05-23T11:52:01.000+02:00
diff --git a/Scalatron/Readme.txt b/Scalatron/Readme.txt
@@ -51,9 +51,16 @@ in the public domain. Feel free to use, copy, and improve them!
 
 ## Version History
 
+### Version 1.1.0.2 -- 2012-05-23
+
+* Adds support for server-side compilation of bots written in Java. This relies on Java's `tools.jar`,
+  which may not be available on all systems. Works with Java 1.6 on MacOSX, fails on Windows.
+
+
+
 ### Version 1.1.0.1 -- 2012-05-22
 
-* Adds support for bots written in Java. Implement a bot as follows:
+* Adds support for bots written in Java. Implement a simple bot by placing this code in a file `ControlFunction.java`:
   public class ControlFunction { final public String respond(String input) { return "Status(text=Written in Java)"; } }
 
 
diff --git a/Scalatron/src/scalatron/scalatron/api/ScalatronOutwardDemo.scala b/Scalatron/src/scalatron/scalatron/api/ScalatronOutwardDemo.scala
@@ -227,7 +227,7 @@ object ScalatronOutwardDemo
 
         } finally {
             // delete the temporary directory
-            FileUtil.deleteRecursively(tmpDirPath)
+            FileUtil.deleteRecursively(tmpDirPath, atThisLevel = true, verbose = false)
         }
     }
 }
diff --git a/Scalatron/src/scalatron/scalatron/impl/CompileActor.scala b/Scalatron/src/scalatron/scalatron/impl/CompileActor.scala
@@ -10,6 +10,9 @@ import tools.nsc.reporters.StoreReporter
 import scalatron.core.Scalatron
 import scala.tools.nsc.util.{BatchSourceFile, Position}
 import akka.actor.Actor
+import scala.util.parsing.input.OffsetPosition
+import java.util.Locale
+import java.io.IOException
 
 
 /** Each compile actor holds a Scala compiler instance and uses it to process CompileJob messages
@@ -85,6 +88,14 @@ object CompileActor {
 
         classPaths
     }
+
+
+    // constants
+    object Constants {
+        val ScalaCompilerInfo = 0       // see scala.tools.nsc.reporters.Reporter.INFO
+        val ScalaCompilerWarning = 1    // see scala.tools.nsc.reporters.Reporter.WARNING
+        val ScalaCompilerError = 2      // see scala.tools.nsc.reporters.Reporter.ERROR
+    }
 }
 
 case class CompileActor(verbose: Boolean) extends Actor {
@@ -125,12 +136,96 @@ case class CompileActor(verbose: Boolean) extends Actor {
       * @param outputDirectoryPath the output directory path where the class files should go
       */
     private def compileFromFiles(sourceFilePathList: Iterable[String], outputDirectoryPath: String): CompileResult = {
-        // System.err.println("COMPILE WORKER ACTOR = " + self.toString())
-        compile(
+        // feed all source files to the Scala compiler, including *.java files
+        // it will parse the Java files to resolve dependencies, but will not generate code for them
+        val scalaCompilationResult = compileScalaCode(
             (run: Global#Run) => { run.compile(sourceFilePathList.toList) },
             outputDirectoryPath,
             sourceFilePathList.mkString(", ")
         )
+
+        // Test: are there *.java sources among the source files?
+        val javaFilePathList = sourceFilePathList.filter(_.endsWith(".java"))
+        if(javaFilePathList.isEmpty) {
+            // no *.java files, just *.scala
+            scalaCompilationResult
+        } else {
+            // there are some *.java files => compile them and merge the error messages!
+            try {
+                import javax.tools._
+
+                var javaCompilerErrors = 0
+                var javaCompilerWarnings = 0
+                val javaCompilerMessageBuilder = Vector.newBuilder[CompilerMessage]
+                val diagnosticListener = new DiagnosticListener[Any] {
+                    def report(diagnostic: Diagnostic[_]) {
+                        val sourceFilePath = diagnostic.getSource match {
+                            case t: Any => t.toString // TODO
+                        }
+
+                        import CompileActor.Constants._
+                        val severity = diagnostic.getKind match {
+                            case Diagnostic.Kind.ERROR => javaCompilerErrors += 1; ScalaCompilerError
+                            case Diagnostic.Kind.WARNING => javaCompilerWarnings += 1; ScalaCompilerWarning
+                            case Diagnostic.Kind.MANDATORY_WARNING => javaCompilerWarnings += 1; ScalaCompilerWarning
+                            case _ => ScalaCompilerInfo
+                        }
+
+                        javaCompilerMessageBuilder +=
+                            CompilerMessage(
+                                CompilerMessagePosition(sourceFilePath, diagnostic.getLineNumber.toInt, diagnostic.getColumnNumber.toInt),
+                                msg = diagnostic.getMessage(Locale.ENGLISH),
+                                severity = severity
+                            )
+                    }
+                }
+
+                // Prepare the compilation options to be used during Java compilation
+                // We are asking the compiler to place the output files under the /out folder.
+                val compileOptions = scala.collection.JavaConversions.asJavaIterable(Iterable("-d", outputDirectoryPath))
+
+                val compiler = ToolProvider.getSystemJavaCompiler
+                if(compiler==null) throw new IllegalStateException("Java Compiler not available (on this platform)")
+
+                val fileManager  = compiler.getStandardFileManager(diagnosticListener, null, null)
+                val fileObjects = fileManager.getJavaFileObjectsFromStrings(scala.collection.JavaConversions.asJavaIterable(javaFilePathList))
+                val task = compiler.getTask(null, fileManager, diagnosticListener, compileOptions, null, fileObjects)
+                val javaCompilationSuccessful = task.call()
+
+                try {
+                    fileManager.close()
+                } catch {
+                    case t: Throwable =>
+                        System.err.println("error: while closing Java compiler standard file manager: " + t)
+                }
+
+                val javaCompilationDuration = 0 // TODO: milliseconds
+                val javaCompilerMessages = javaCompilerMessageBuilder.result()
+                CompileResult(
+                    javaCompilationSuccessful && scalaCompilationResult.compilationSuccessful,
+                    javaCompilationDuration + scalaCompilationResult.duration,
+                    scalaCompilationResult.errorCount,
+                    scalaCompilationResult.warningCount,
+                    scalaCompilationResult.compilerMessages ++ javaCompilerMessages
+                )
+            } catch {
+                case t: Throwable =>
+                    // Uh, something went wrong with the Java compilation - maybe not working on this system?
+                System.err.println("error: exception during attempt to compile Java files: " + t)
+                CompileResult(
+                    false,
+                    scalaCompilationResult.duration,
+                    scalaCompilationResult.errorCount,
+                    scalaCompilationResult.warningCount,
+                    scalaCompilationResult.compilerMessages ++
+                        Iterable(CompilerMessage(
+                            CompilerMessagePosition(javaFilePathList.head, 0, 0),
+                            msg = "exception during attempt to compile Java files: " + t,
+                            severity = CompileActor.Constants.ScalaCompilerError
+                        ))
+                )
+            }
+        }
     }
 
     /** Compiles a given collection of source files residing in memory into a given output directory.
@@ -157,7 +252,7 @@ case class CompileActor(verbose: Boolean) extends Actor {
                 at scala.tools.nsc.Global$Run.compileSources(Global.scala:916)
                 at scalatron.scalatron.impl.CompileActor$$anonfun$scalatron$scalatron$impl$CompileActor$$compileFromMemory$1.apply(CompileActor.scala:143)
          */
-        compile(
+        compileScalaCode(
             (run: Global#Run) => {
                 val batchSourceFileList = sourceFiles.map(sf => {
                     new BatchSourceFile(sf.filename, sf.code.toCharArray)
@@ -178,7 +273,7 @@ case class CompileActor(verbose: Boolean) extends Actor {
       * @param runDescription a description for verbose output, e.g. a list of filenames
       * @return a CompileResult instance holding any compiler messages
       */
-    private def compile(compilerInvocation: (Global#Run) => Unit, outputDirectoryPath: String, runDescription: String): CompileResult = {
+    private def compileScalaCode(compilerInvocation: (Global#Run) => Unit, outputDirectoryPath: String, runDescription: String): CompileResult = {
         compilerGlobalOpt match {
             case None =>
                 throw new IllegalStateException("compiler not initialized")
@@ -197,7 +292,12 @@ case class CompileActor(verbose: Boolean) extends Actor {
                 val elapsed = (endTime - startTime).toInt
                 if( verbose ) println("    ...compilation completed (" + elapsed + "ms)")
 
-                val errorList = compilerGlobal.reporter.asInstanceOf[StoreReporter].infos.map(info => CompilerMessage(info.pos, info.msg, info.severity.id))
+                val errorList =
+                    compilerGlobal.reporter.asInstanceOf[StoreReporter].infos
+                    .map(info => CompilerMessage(
+                        CompilerMessagePosition(info.pos.source.path, info.pos.line, info.pos.column),
+                        info.msg,
+                        info.severity.id))
                 val hasErrors = compilerGlobal.reporter.hasErrors
                 val errorCount = compilerGlobal.reporter.ERROR.count
                 val warningCount = compilerGlobal.reporter.WARNING.count
@@ -211,7 +311,8 @@ case class CompileActor(verbose: Boolean) extends Actor {
 
 
 /** Records one error or warning that was generated by the compiler. */
-case class CompilerMessage(pos: Position, msg: String, severity: Int)
+case class CompilerMessagePosition(sourceFilePath: String, line: Int, column: Int)
+case class CompilerMessage(pos: CompilerMessagePosition, msg: String, severity: Int)
 
 
 /** Messages passed to and from the compile actor. */
diff --git a/Scalatron/src/scalatron/scalatron/impl/FileUtil.scala b/Scalatron/src/scalatron/scalatron/impl/FileUtil.scala
@@ -40,28 +40,35 @@ object FileUtil
 
 
     /** Recursively deletes the given directory and all of its contents (CAUTION!)
+      * @param path the path of the directory to begin recursive deletion at
+      * @param atThisLevel if true: the directory at `path` is deleted; if false: only its children
+      * @param verbose if true, log verbosely to the console
       * @throws IllegalStateException if there is a problem deleting a file or directory
       */
-    def deleteRecursively(path: String, verbose: Boolean = false) {
+    def deleteRecursively(path: String, atThisLevel: Boolean, verbose: Boolean) {
         val itemAtPath = new File(path)
         if(itemAtPath.exists) {
             // caller handles exceptions
             if(itemAtPath.isDirectory) {
                 if(verbose) println("  deleting contents of directory at: " + path)
                 val filesInsideUserDir = itemAtPath.listFiles()
                 if(filesInsideUserDir != null) {
-                    filesInsideUserDir.foreach(file => deleteRecursively(file.getAbsolutePath, verbose))
+                    filesInsideUserDir.foreach(file => deleteRecursively(file.getAbsolutePath, true, verbose))
                 }
-                if(verbose) println("  deleting directory: " + path)
-                if(!itemAtPath.delete()) {
-                    System.err.println("error: failed to delete directory: %s".format(itemAtPath.getAbsolutePath))
-                    throw new IllegalStateException("failed to delete directory at: " + itemAtPath.getAbsolutePath)
+                if(atThisLevel) {
+                    if(verbose) println("  deleting directory: " + path)
+                    if(!itemAtPath.delete()) {
+                        System.err.println("error: failed to delete directory: %s".format(itemAtPath.getAbsolutePath))
+                        throw new IllegalStateException("failed to delete directory at: " + itemAtPath.getAbsolutePath)
+                    }
                 }
             } else {
-                if(verbose) println("  deleting file at: " + path)
-                if(!itemAtPath.delete()) {
-                    System.err.println("error: failed to delete file: %s".format(itemAtPath.getAbsolutePath))
-                    throw new IllegalStateException("failed to delete file: " + itemAtPath.getAbsolutePath)
+                if(atThisLevel) {
+                    if(verbose) println("  deleting file at: " + path)
+                    if(!itemAtPath.delete()) {
+                        System.err.println("error: failed to delete file: %s".format(itemAtPath.getAbsolutePath))
+                        throw new IllegalStateException("failed to delete file: " + itemAtPath.getAbsolutePath)
+                    }
                 }
             }
         }
diff --git a/Scalatron/src/scalatron/scalatron/impl/ScalatronSample.scala b/Scalatron/src/scalatron/scalatron/impl/ScalatronSample.scala
@@ -13,5 +13,5 @@ case class ScalatronSample(name: String, scalatron: ScalatronImpl) extends Scala
 
     def sourceFiles: Iterable[SourceFile] = SourceFileCollection.loadFrom(sampleSourceDirectoryPath)
 
-    def delete() { deleteRecursively(sampleDirectoryPath, scalatron.verbose) }
+    def delete() { deleteRecursively(sampleDirectoryPath, atThisLevel = true, verbose = scalatron.verbose) }
 }
diff --git a/Scalatron/src/scalatron/scalatron/impl/ScalatronUser.scala b/Scalatron/src/scalatron/scalatron/impl/ScalatronUser.scala
@@ -81,8 +81,8 @@ case class ScalatronUser(name: String, scalatron: ScalatronImpl) extends Scalatr
             throw ScalatronException.Forbidden("deleting '" + Scalatron.Constants.AdminUserName + "' account is not permitted")
         } else {
             // caller must handle IOError exceptions
-            deleteRecursively(userDirectoryPath, scalatron.verbose)
-            deleteRecursively(userPluginDirectoryPath, scalatron.verbose)
+            deleteRecursively(userDirectoryPath, atThisLevel = true, verbose = scalatron.verbose)
+            deleteRecursively(userPluginDirectoryPath, atThisLevel = true, verbose = scalatron.verbose)
 
             // remove from cache
             release()
@@ -144,12 +144,17 @@ case class ScalatronUser(name: String, scalatron: ScalatronImpl) extends Scalatr
           */
         val gameSpecificPackagePath = scalatron.game.gameSpecificPackagePath
         val packagePath = gameSpecificPackagePath + "." + name
-        val packageStatementWithNewline = "package " + packagePath + "\n"
+        val packageStatement = "package " + packagePath
         val patchedSourceFiles = transientSourceFiles.map(sf => {
             val localCode = sf.code
             // CBB: warn the user about conflicts if she embeds her own package name
             // but if(localCode.contains("package")) ... is too dumb
-            val patchedCode = packageStatementWithNewline + localCode
+            val patchedCode =
+                if(sf.filename.endsWith(".java")) {
+                    packageStatement + ";\n" + localCode
+                } else {
+                    packageStatement + "\n" + localCode
+                }
             if(scalatron.verbose) println("  patching '%s' with 'package %s'".format(sf.filename, packagePath))
             SourceFile(sf.filename, patchedCode)
         })
@@ -163,7 +168,9 @@ case class ScalatronUser(name: String, scalatron: ScalatronImpl) extends Scalatr
         // so, as a temporary work-around, we create temp files on disk:
         // TODO: this code should probably exist within writeSourceFiles() - refactor!
         val patchedSourceDirectory = new File(patchedSourceDirectoryPath)
-        if(!patchedSourceDirectory.exists) {
+        if(patchedSourceDirectory.exists) {
+            deleteRecursively(patchedSourceDirectoryPath, atThisLevel = false, verbose = scalatron.verbose)
+        } else {
             if(!patchedSourceDirectory.mkdirs()) {
                 System.err.println("error: cannot create patched source directory at: " + patchedSourceDirectory)
                 throw new IllegalStateException("error: cannot create patched source directory at: " + patchedSourceDirectory)
@@ -424,10 +431,11 @@ object ScalatronUser {
                 val outputDirectoryPath = compileJob.outputDirectoryPath
                 val outputDirectory = new File(outputDirectoryPath)
                 if( outputDirectory.exists() ) {
-                    // it should not exist before we start. If it does, we delete it
-                    deleteRecursively(outputDirectoryPath, scalatron.verbose)
+                    // it should be empty before we start. If it exists, we clear it
+                    deleteRecursively(outputDirectoryPath, atThisLevel = false, verbose = scalatron.verbose)
+                } else {
+                    outputDirectory.mkdirs()
                 }
-                outputDirectory.mkdirs()
 
 
                 // compile the source file, using an Akka Actor with a fixed time-out
@@ -451,8 +459,10 @@ object ScalatronUser {
                         // build the .jar archive file
                         JarBuilder(outputDirectoryPath, jarFilePath, scalatron.verbose)
 
-                        // delete the output directory - it is no longer needed
-                        deleteRecursively(outputDirectoryPath, scalatron.verbose)
+                        // we DO NOT delete the contents of the output directory, even though they are no longer needed
+                        // the directory will be cleared before the next compilation starts, and leaving the files is
+                        // useful when diagnosing problems.
+                        // deleteRecursively(outputDirectoryPath, atThisLevel = false, verbose = scalatron.verbose)
                     }
 
                     // transform compiler output into the BuildResult format expected by the Scalatron API
@@ -463,7 +473,7 @@ object ScalatronUser {
                         compileResult.errorCount,
                         compileResult.warningCount,
                         compileResult.compilerMessages.map(msg => {
-                            val absoluteSourceFilePath = msg.pos.source.path
+                            val absoluteSourceFilePath = msg.pos.sourceFilePath
                             val relativeSourceFilePath =
                                 if(absoluteSourceFilePath.startsWith(sourceDirectoryPrefix)) {
                                     absoluteSourceFilePath.drop(sourceDirectoryPrefix.length)
diff --git a/Scalatron/test/scalatron/scalatron/api/ScalatronApiSpec.scala b/Scalatron/test/scalatron/scalatron/api/ScalatronApiSpec.scala
@@ -363,7 +363,7 @@ object ScalatronApiTest
             result
         } finally {
             // delete the temporary directory
-            FileUtil.deleteRecursively(tmpDirPath, verbose)
+            FileUtil.deleteRecursively(tmpDirPath, atThisLevel = true, verbose = verbose)
         }
     }
 
diff --git a/build.sbt b/build.sbt
@@ -2,6 +2,6 @@ organization := "Scalatron"
 
 name         := "Scalatron"
 
-version in Global := "1.1.0.1"
+version in Global := "1.1.0.2"
 
 scalaVersion := "2.9.1"

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ object ScalatronOutwardDemo`
`227`	`227`
`228`	`228`	`} finally {`
`229`	`229`	`// delete the temporary directory`
`230`		`- FileUtil.deleteRecursively(tmpDirPath)`
	`230`	`+ FileUtil.deleteRecursively(tmpDirPath, atThisLevel = true, verbose = false)`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,5 @@ case class ScalatronSample(name: String, scalatron: ScalatronImpl) extends Scala`
`13`	`13`
`14`	`14`	`def sourceFiles: Iterable[SourceFile] = SourceFileCollection.loadFrom(sampleSourceDirectoryPath)`
`15`	`15`
`16`		`- def delete() { deleteRecursively(sampleDirectoryPath, scalatron.verbose) }`
	`16`	`+ def delete() { deleteRecursively(sampleDirectoryPath, atThisLevel = true, verbose = scalatron.verbose) }`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -363,7 +363,7 @@ object ScalatronApiTest`
`363`	`363`	`result`
`364`	`364`	`} finally {`
`365`	`365`	`// delete the temporary directory`
`366`		`- FileUtil.deleteRecursively(tmpDirPath, verbose)`
	`366`	`+ FileUtil.deleteRecursively(tmpDirPath, atThisLevel = true, verbose = verbose)`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`