Merge pull request #2 from cquiroz/java-util-logging-implementation

Implement parts of java.util.logging

Author: nicolasstucki

src/main/scala/java/util/logging/ConsoleHandler.scala

@@ -0,0 +1,16 @@
+package java.util.logging
+
+// Unfortunately the spec require the use of System.err
+class ConsoleHandler extends StreamHandler(System.err, new SimpleFormatter) {
+
+  // Overriden on the javadocs but there are no comments about differences
+  override def publish(record: LogRecord): Unit =
+    super.publish(record)
+
+  override def close(): Unit = {
+    // Required by javadocs not to close the stream
+    writeHeader()
+    writeTail()
+    flush()
+  }
+}

src/main/scala/java/util/logging/ErrorManager.scala

@@ -0,0 +1,30 @@
+package java.util.logging
+
+object ErrorManager {
+  val GENERIC_FAILURE = 0
+  val WRITE_FAILURE = 1
+  val FLUSH_FAILURE = 2
+  val CLOSE_FAILURE = 3
+  val OPEN_FAILURE = 4
+  val FORMAT_FAILURE = 5
+}
+
+class ErrorManager() {
+
+  // The spec is a bit vague. This will implement the most
+  // obvious interpretation of outputting only once
+  private[this] var called = false
+
+  def error(msg: String, ex: Exception, code: Int): Unit = {
+    if (!called) {
+      // The format is undocumented, this is learned by runtime experimentation
+      if (msg == null && ex == null) {
+        System.err.println(code)
+      } else {
+        System.err.println(s"$code: $msg")
+        if (ex == null) ex.printStackTrace(System.err)
+      }
+      called = true
+    }
+  }
+}

src/main/scala/java/util/logging/Filter.scala

@@ -0,0 +1,5 @@
+package java.util.logging
+
+trait Filter {
+  def isLoggable(record: LogRecord): Boolean
+}

src/main/scala/java/util/logging/Formatter.scala

@@ -0,0 +1,71 @@
+package java.util.logging
+
+abstract class Formatter protected () {
+
+  def format(record: LogRecord): String
+
+  def getHead(h: Handler): String = ""
+
+  def getTail(h: Handler): String = ""
+
+  def formatMessage(record: LogRecord): String = {
+    val msg = record.getMessage
+    val params = record.getParameters
+
+    if (params != null && params.length > 0) {
+      // The Java spec uses java.text formatting not available in Scala.js
+      // Instead we'll do simple text replacement, very imperative
+      var msgAccumulator = new StringBuilder()
+      var inParam = false
+      var paramInFlight:StringBuilder = null
+      var substitutionFailure = false // track failure to break the loop
+      var i = 0
+
+      // Do one run over msg keeping track if a param needs replacement
+      while (i < msg.length && !substitutionFailure) {
+        val currentChar = msg.charAt(i)
+        i = i + 1
+        if (currentChar == '{' && !inParam) {
+          // Beginning of param
+          inParam = true
+          paramInFlight = new StringBuilder()
+        } else if (inParam && currentChar != '}') {
+          // accumulate the param
+          paramInFlight += currentChar
+        } else if (currentChar == '}') {
+          // end of param, replace placeholder by value if possible
+          inParam = false
+          val (failed, replacement) = {
+            try {
+              val index = paramInFlight.toInt
+              if (index >= 0 && index < params.length) {
+                (false, params(index).toString)
+              } else if (index > 0) {
+                (false, "{" + index + "}")
+              } else {
+                // Negative indexes break substitution on the JVM
+                (true, "")
+              }
+            } catch {
+              case e: Exception =>
+                // The JVM will halt replacing if it cannot parse one param
+                (true, "")
+            }
+          }
+
+          // The JVM will fail if e.g. there are bogus params and would not replace
+          // any parameter
+          if (failed) substitutionFailure = failed
+          else msgAccumulator ++= replacement
+        } else {
+          msgAccumulator += currentChar
+        }
+      }
+
+      if (substitutionFailure || inParam) msg
+      else msgAccumulator.result()
+    } else {
+      msg
+    }
+  }
+}

src/main/scala/java/util/logging/Handler.scala

@@ -0,0 +1,54 @@
+package java.util.logging
+
+import java.nio.charset.{Charset, UnsupportedCharsetException}
+
+abstract class Handler protected () {
+
+  private[this] var level: Level = Level.ALL
+  private[this] var filter: Filter = null
+  private[this] var formatter: Formatter = null
+  private[this] var encoding: String = null
+  private[this] var errorManager: ErrorManager = new ErrorManager()
+
+  def publish(record:LogRecord): Unit
+
+  def flush(): Unit
+
+  def close(): Unit
+
+  def setFormatter(formatter: Formatter): Unit = this.formatter = formatter
+
+  def getFormatter(): Formatter = formatter
+
+  def setEncoding(encoding: String): Unit = {
+    if (encoding == null) this.encoding = null
+    else if (Charset.isSupported(encoding)) this.encoding = encoding
+    else throw new UnsupportedCharsetException(s"$encoding not supported")
+  }
+
+  def getEncoding(): String = encoding
+
+  def setFilter(filter: Filter): Unit = this.filter = filter
+
+  def getFilter(): Filter = filter
+
+  def setErrorManager(errorManager: ErrorManager): Unit =
+    if (errorManager == null) throw new NullPointerException()
+    else this.errorManager = errorManager
+
+  def getErrorManager(): ErrorManager = errorManager
+
+  protected def reportError(msg: String, ex: Exception, code: Int): Unit =
+    errorManager.error(msg, ex, code)
+
+  def setLevel(level: Level): Unit =
+    if (level == null) throw new NullPointerException()
+    else this.level = level
+
+  def getLevel(): Level = level
+
+  def isLoggable(record:LogRecord): Boolean = {
+    level.intValue() <= record.getLevel.intValue() &&
+    (filter == null || filter.isLoggable(record))
+  }
+}

src/main/scala/java/util/logging/Level.scala

@@ -0,0 +1,51 @@
+package java.util.logging
+
+object Level {
+
+  val OFF: Level = new Level("OFF", Int.MaxValue)
+  val SEVERE: Level = new Level("SEVERE", 1000)
+  val WARNING: Level = new Level("WARNING", 900)
+  val INFO: Level = new Level("INFO", 800)
+  val CONFIG: Level = new Level("CONFIG", 700)
+  val FINE: Level = new Level("FINE", 500)
+  val FINER: Level = new Level("FINER", 400)
+  val FINEST: Level = new Level("FINEST", 300)
+  val ALL: Level = new Level("ALL", Int.MinValue)
+
+  private lazy val knownLevels = Map[String, Level](OFF.getName -> OFF,
+      SEVERE.getName -> SEVERE, WARNING.getName -> WARNING,
+      INFO.getName -> INFO, CONFIG.getName -> CONFIG, FINE.getName -> FINE,
+      FINER.getName -> FINER, FINEST.getName -> FINEST, ALL.getName -> ALL)
+
+  def parse(name: String): Level =
+    if (name == null) throw new NullPointerException("Name cannot be null")
+    else knownLevels.getOrElse(name, throw new IllegalArgumentException(""))
+}
+
+class Level protected (private[this] val name: String,
+    private[this] val value: Int,
+    private[this] val resourceBundleName: String) {
+
+  if (name == null)
+    throw new NullPointerException("Name cannot be null")
+
+  protected def this(name: String, value: Int) = this(name, value, null)
+
+  def getResourceBundleName(): String = resourceBundleName
+
+  def getName(): String = name
+
+  // Not implemented, no locale in Scala.js
+  //def getLocalizedName():String
+
+  override def toString(): String = name
+
+  def intValue(): Int = value
+
+  override def equals(obj: Any): Boolean = obj match {
+    case l: Level => intValue() == l.intValue()
+    case _        => false
+  }
+
+  override def hashCode(): Int = value
+}

src/main/scala/java/util/logging/LogRecord.scala

@@ -0,0 +1,76 @@
+package java.util.logging
+
+object LogRecord {
+  protected[logging] var sequence: Long = 0L
+}
+
+class LogRecord(private[this] var level: Level, private[this] var msg: String) {
+
+  private[this] var sourceClassName: String = null
+  private[this] var sourceMethodName: String = null
+  private[this] var params: Array[AnyRef] = null
+  private[this] var thrown: Throwable = null
+  private[this] var loggerName: String = null
+  private[this] var millis: Long = System.currentTimeMillis()
+  private[this] var threadId: Long = Thread.currentThread().getId
+
+  private[this] var sequenceNumber: Long = {
+    LogRecord.sequence = LogRecord.sequence + 1
+    LogRecord.sequence
+  }
+
+  def getLoggerName(): String = loggerName
+
+  def setLoggerName(loggerName: String): Unit =
+    this.loggerName = loggerName
+
+  // Not implemented, no locale in Scala.js
+  //def getResourceBundle():ResourceBundle = ???
+
+  // Not implemented, no locale in Scala.js
+  //def setResourceBundle(bundle: ResourceBundle):Unit = ???
+
+  // Message is not localizable, return null
+  def getResourceBundleName(): String = null
+
+  // Message is not localizable, no-op
+  def setResourceBundleName(name: String): Unit = {}
+
+  def getLevel(): Level = level
+
+  def setLevel(level: Level): Unit = this.level = level
+
+  def getSequenceNumber(): Long = sequenceNumber
+
+  def setSequenceNumber(seq: Long): Unit = sequenceNumber = seq
+
+  def getSourceClassName(): String = sourceClassName
+
+  def setSourceClassName(sourceClassName: String): Unit =
+    this.sourceClassName = sourceClassName
+
+  def getSourceMethodName(): String = sourceMethodName
+
+  def setSourceMethodName(sourceClassName: String): Unit =
+    this.sourceMethodName = sourceClassName
+
+  def getMessage(): String = msg
+
+  def setMessage(message: String): Unit = msg = message
+
+  def getParameters(): Array[AnyRef] = params
+
+  def setParameters(parameters: Array[AnyRef]): Unit = this.params = parameters
+
+  def getThreadID(): Int = threadId.toInt
+
+  def setThreadID(threadID: Int): Unit = this.threadId = threadID
+
+  def getMillis(): Long = millis
+
+  def setMillis(millis: Long): Unit = this.millis = millis
+
+  def getThrown(): Throwable = thrown
+
+  def setThrown(thrown: Throwable): Unit = this.thrown = thrown
+}