move sbt.internal.util.Logger into sbt.util

internal/util-logging/src/main/scala/sbt/internal/util/BasicLogger.scala

@@ -3,15 +3,17 @@
  */
 package sbt.internal.util
 
+import sbt.util._
+
 /** Implements the level-setting methods of Logger.*/
 abstract class BasicLogger extends AbstractLogger {
-  private var traceEnabledVar = java.lang.Integer.MAX_VALUE
+  private var traceEnabledVar: Int = java.lang.Integer.MAX_VALUE
   private var level: Level.Value = Level.Info
   private var successEnabledVar = true
-  def successEnabled = synchronized { successEnabledVar }
+  def successEnabled: Boolean = synchronized { successEnabledVar }
   def setSuccessEnabled(flag: Boolean): Unit = synchronized { successEnabledVar = flag }
-  def getLevel = synchronized { level }
+  def getLevel: Level.Value = synchronized { level }
   def setLevel(newLevel: Level.Value): Unit = synchronized { level = newLevel }
   def setTrace(level: Int): Unit = synchronized { traceEnabledVar = level }
-  def getTrace = synchronized { traceEnabledVar }
+  def getTrace: Int = synchronized { traceEnabledVar }
 }

internal/util-logging/src/main/scala/sbt/internal/util/BufferedLogger.scala

@@ -3,6 +3,7 @@
  */
 package sbt.internal.util
 
+import sbt.util._
 import scala.collection.mutable.ListBuffer
 
 /**

internal/util-logging/src/main/scala/sbt/internal/util/ConsoleLogger.scala

@@ -3,6 +3,7 @@
  */
 package sbt.internal.util
 
+import sbt.util._
 import java.io.{ BufferedWriter, PrintStream, PrintWriter }
 import java.util.Locale
 

internal/util-logging/src/main/scala/sbt/internal/util/ConsoleOut.scala

@@ -1,5 +1,6 @@
 package sbt.internal.util
 
+import sbt.util._
 import java.io.{ BufferedWriter, PrintStream, PrintWriter }
 
 sealed trait ConsoleOut {

internal/util-logging/src/main/scala/sbt/internal/util/FilterLogger.scala

@@ -3,6 +3,8 @@
  */
 package sbt.internal.util
 
+import sbt.util._
+
 /**
  * A filter logger is used to delegate messages but not the logging level to another logger.  This means
  * that messages are logged at the higher of the two levels set by this logger and its delegate.

internal/util-logging/src/main/scala/sbt/internal/util/FullLogger.scala

@@ -3,6 +3,8 @@
  */
 package sbt.internal.util
 
+import sbt.util._
+
 /** Promotes the simple Logger interface to the full AbstractLogger interface. */
 class FullLogger(delegate: Logger) extends BasicLogger {
   override val ansiCodesSupported: Boolean = delegate.ansiCodesSupported

internal/util-logging/src/main/scala/sbt/internal/util/GlobalLogging.scala

@@ -3,6 +3,7 @@
  */
 package sbt.internal.util
 
+import sbt.util._
 import java.io.{ File, PrintWriter }
 
 /**

internal/util-logging/src/main/scala/sbt/internal/util/LoggerWriter.scala

@@ -3,6 +3,8 @@
  */
 package sbt.internal.util
 
+import sbt.util._
+
 /**
  * Provides a `java.io.Writer` interface to a `Logger`.  Content is line-buffered and logged at `level`.
  * A line is delimited by `nl`, which is by default the platform line separator.

internal/util-logging/src/main/scala/sbt/internal/util/MainLogging.scala

@@ -1,5 +1,6 @@
 package sbt.internal.util
 
+import sbt.util._
 import java.io.PrintWriter
 
 object MainLogging {

internal/util-logging/src/main/scala/sbt/internal/util/MultiLogger.scala

@@ -4,6 +4,8 @@
  */
 package sbt.internal.util
 
+import sbt.util._
+
 // note that setting the logging level on this logger has no effect on its behavior, only
 //   on the behavior of the delegates.
 class MultiLogger(delegates: List[AbstractLogger]) extends BasicLogger {

internal/util-logging/src/main/scala/sbt/util/AbtractLogger.scala

@@ -0,0 +1,28 @@
+package sbt.util
+
+abstract class AbstractLogger extends Logger {
+  def getLevel: Level.Value
+  def setLevel(newLevel: Level.Value): Unit
+  def setTrace(flag: Int): Unit
+  def getTrace: Int
+  final def traceEnabled: Boolean = getTrace >= 0
+  def successEnabled: Boolean
+  def setSuccessEnabled(flag: Boolean): Unit
+
+  def atLevel(level: Level.Value): Boolean = level.id >= getLevel.id
+  def control(event: ControlEvent.Value, message: => String): Unit
+
+  def logAll(events: Seq[LogEvent]): Unit
+  /** Defined in terms of other methods in Logger and should not be called from them. */
+  final def log(event: LogEvent): Unit = {
+    event match {
+      case s: Success       => success(s.msg)
+      case l: Log           => log(l.level, l.msg)
+      case t: Trace         => trace(t.exception)
+      case setL: SetLevel   => setLevel(setL.newLevel)
+      case setT: SetTrace   => setTrace(setT.level)
+      case setS: SetSuccess => setSuccessEnabled(setS.enabled)
+      case c: ControlEvent  => control(c.event, c.msg)
+    }
+  }
+}

internal/util-logging/src/main/scala/sbt/util/Level.scala

@@ -1,7 +1,7 @@
 /* sbt -- Simple Build Tool
  * Copyright 2008, 2009 Mark Harrah
  */
-package sbt.internal.util
+package sbt.util
 
 /**
  * An enumeration defining the levels available for logging.  A level includes all of the levels

internal/util-logging/src/main/scala/sbt/util/LogEvent.scala

@@ -1,7 +1,7 @@
 /* sbt -- Simple Build Tool
  * Copyright 2008, 2009 Mark Harrah
  */
-package sbt.internal.util
+package sbt.util
 
 sealed trait LogEvent extends NotNull
 final class Success(val msg: String) extends LogEvent

internal/util-logging/src/main/scala/sbt/util/Logger.scala

@@ -1,39 +1,42 @@
 /* sbt -- Simple Build Tool
  * Copyright 2008, 2009, 2010  Mark Harrah
  */
-package sbt.internal.util
+package sbt.util
 
 import xsbti.{ Logger => xLogger, F0 }
 import xsbti.{ Maybe, Position, Problem, Severity }
 import sys.process.ProcessLogger
+import sbt.internal.util.{ BufferedLogger, FullLogger }
 
 import java.io.File
 
-abstract class AbstractLogger extends Logger {
+/**
-  def getLevel: Level.Value
+ * This is intended to be the simplest logging interface for use by code that wants to log.
-  def setLevel(newLevel: Level.Value): Unit
+ * It does not include configuring the logger.
-  def setTrace(flag: Int): Unit
+ */
-  def getTrace: Int
+abstract class Logger extends xLogger {
-  final def traceEnabled: Boolean = getTrace >= 0
+  final def verbose(message: => String): Unit = debug(message)
-  def successEnabled: Boolean
+  final def debug(message: => String): Unit = log(Level.Debug, message)
-  def setSuccessEnabled(flag: Boolean): Unit
+  final def info(message: => String): Unit = log(Level.Info, message)
+  final def warn(message: => String): Unit = log(Level.Warn, message)
+  final def error(message: => String): Unit = log(Level.Error, message)
+  // Added by sys.process.ProcessLogger
+  final def err(message: => String): Unit = log(Level.Error, message)
+  // sys.process.ProcessLogger
+  final def out(message: => String): Unit = log(Level.Info, message)
 
-  def atLevel(level: Level.Value): Boolean = level.id >= getLevel.id
+  def ansiCodesSupported: Boolean = false
-  def control(event: ControlEvent.Value, message: => String): Unit
 
-  def logAll(events: Seq[LogEvent]): Unit
+  def trace(t: => Throwable): Unit
-  /** Defined in terms of other methods in Logger and should not be called from them. */
+  def success(message: => String): Unit
-  final def log(event: LogEvent): Unit = {
+  def log(level: Level.Value, message: => String): Unit
-    event match {
+
-      case s: Success       => success(s.msg)
+  def debug(msg: F0[String]): Unit = log(Level.Debug, msg)
-      case l: Log           => log(l.level, l.msg)
+  def warn(msg: F0[String]): Unit = log(Level.Warn, msg)
-      case t: Trace         => trace(t.exception)
+  def info(msg: F0[String]): Unit = log(Level.Info, msg)
-      case setL: SetLevel   => setLevel(setL.newLevel)
+  def error(msg: F0[String]): Unit = log(Level.Error, msg)
-      case setT: SetTrace   => setTrace(setT.level)
+  def trace(msg: F0[Throwable]): Unit = trace(msg.apply)
-      case setS: SetSuccess => setSuccessEnabled(setS.enabled)
+  def log(level: Level.Value, msg: F0[String]): Unit = log(level, msg.apply)
-      case c: ControlEvent  => control(c.event, c.msg)
-    }
-  }
 }
 
 object Logger {
@@ -107,32 +110,3 @@ object Logger {
       override def toString = s"[$severity] $pos: $message"
     }
 }
-
-/**
- * This is intended to be the simplest logging interface for use by code that wants to log.
- * It does not include configuring the logger.
- */
-trait Logger extends xLogger {
-  final def verbose(message: => String): Unit = debug(message)
-  final def debug(message: => String): Unit = log(Level.Debug, message)
-  final def info(message: => String): Unit = log(Level.Info, message)
-  final def warn(message: => String): Unit = log(Level.Warn, message)
-  final def error(message: => String): Unit = log(Level.Error, message)
-  // Added by sys.process.ProcessLogger
-  final def err(message: => String): Unit = log(Level.Error, message)
-  // sys.process.ProcessLogger
-  final def out(message: => String): Unit = log(Level.Info, message)
-
-  def ansiCodesSupported: Boolean = false
-
-  def trace(t: => Throwable): Unit
-  def success(message: => String): Unit
-  def log(level: Level.Value, message: => String): Unit
-
-  def debug(msg: F0[String]): Unit = log(Level.Debug, msg)
-  def warn(msg: F0[String]): Unit = log(Level.Warn, msg)
-  def info(msg: F0[String]): Unit = log(Level.Info, msg)
-  def error(msg: F0[String]): Unit = log(Level.Error, msg)
-  def trace(msg: F0[Throwable]): Unit = trace(msg.apply)
-  def log(level: Level.Value, msg: F0[String]): Unit = log(level, msg.apply)
-}

internal/util-logging/src/test/scala/LogWriterTest.scala

@@ -3,6 +3,7 @@
 
 package sbt.internal.util
 
+import sbt.util._
 import org.scalacheck._
 import Arbitrary.{ arbitrary => arb, _ }
 import Gen.{ listOfN, oneOf }

internal/util-logging/src/test/scala/TestLogger.scala

@@ -1,5 +1,7 @@
 package sbt.internal.util
 
+import sbt.util._
+
 object TestLogger {
   def apply[T](f: Logger => T): T =
     {