split out extra tasks, implement logging

This commit is contained in:
Mark Harrah 2010-09-08 14:45:22 -04:00
parent a5ac661115
commit e80de34a6e
3 changed files with 86 additions and 102 deletions

35
main/LogManager.scala Normal file
View File

@ -0,0 +1,35 @@
/* sbt -- Simple Build Tool
* Copyright 2010 Mark Harrah
*/
package sbt
import java.io.PrintWriter
import LogManager._
import std.Transform
object LogManager
{
def construct(context: Transform.Context[Project], settings: Settings) = (task: Task[_], to: PrintWriter) =>
{
val owner = context owner task
val ownerName = owner flatMap ( context ownerName _ ) getOrElse ""
val taskPath = (context staticName task).toList ::: ownerName :: Nil
def level(key: AttributeKey[Level.Value], default: Level.Value): Level.Value = settings.get(key, taskPath) getOrElse default
val screenLevel = level(ScreenLogLevel, Level.Info)
val backingLevel = level(PersistLogLevel, Level.Debug)
val console = ConsoleLogger()
val backed = ConsoleLogger(ConsoleLogger.printWriterOut(to), useColor = false) // TODO: wrap this with a filter that strips ANSI codes
val multi = new MultiLogger(console :: backed :: Nil)
// sets multi to the most verbose for clients that inspect the current level
multi setLevel Level.union(backingLevel, screenLevel)
// set the specific levels
console setLevel screenLevel
backed setLevel backingLevel
multi: Logger
}
val ScreenLogLevel = AttributeKey[Level.Value]("screen log level")
val PersistLogLevel = AttributeKey[Level.Value]("persist log level")
}

46
main/OutputTasks.scala Normal file
View File

@ -0,0 +1,46 @@
/* sbt -- Simple Build Tool
* Copyright 2010 Mark Harrah
*/
package sbt
import std._
import Path._
import TaskExtra._
trait PrintTask
{
def input: Task[Input]
lazy val show = input flatMap { in =>
val m = ReflectUtilities.allVals[Task[_]](this)
val taskStrings = in.splitArgs map { name =>
m(name).merge.map {
case Seq() => "No result for " + name
case Seq( (conf, v) ) => name + ": " + v.toString
case confs => confs map { case (conf, v) => conf + ": " + v } mkString(name + ":\n\t", "\n\t", "\n")
}
}
taskStrings.join.map { _ foreach println }
}
}
trait LastOutput
{
def input: Task[Input]
def streams: Task[TaskStreams]
lazy val last = (streams, input) flatMap { (s: TaskStreams, i: Input) =>
val tasks = ReflectUtilities.allVals[Task[_]](this)
(s.readText( tasks(i.arguments) , update = false ) map { reader =>
val out = s.text()
def readL()
{
val line = reader.readLine()
if(line ne null) {
readL()
out.println(line)
println(line)
}
}
readL()
}).merge
}
}

View File

@ -3,12 +3,12 @@
*/
package sbt
import std._
import Path._
import TaskExtra._
import scala.collection.{mutable, JavaConversions}
import std._
import Path._
import TaskExtra._
import scala.collection.{mutable, JavaConversions}
import java.io.File
import java.io.File
trait SingleProject extends Tasked with PrintTask with TaskExtra with Types
{
@ -44,103 +44,6 @@ object Dummy
val Streams = dummy[TaskStreams](StreamsName)
}
trait PrintTask
{
def input: Task[Input]
lazy val show = input flatMap { in =>
val m = ReflectUtilities.allVals[Task[_]](this)
val taskStrings = in.splitArgs map { name =>
m(name).merge.map {
case Seq() => "No result for " + name
case Seq( (conf, v) ) => name + ": " + v.toString
case confs => confs map { case (conf, v) => conf + ": " + v } mkString(name + ":\n\t", "\n\t", "\n")
}
}
taskStrings.join.map { _ foreach println }
}
}
/*
trait LogManager
{
def makeLogger(context: Context): (Task[_], PrintWriter) => Logger
}
sealed trait Properties
{
def parent: Option[Properties]
def get[T](key: AttributeKey[T]): Option[T]
def sub(name: String): Properties
def set[T](key: AttributeKey[T], value: T): Properties
def s
}
sealed trait Attribute[T]
{
def default: Option[T]
def sub(s: String): Option[Attribute[T]]
def value(s: String): Option[T]
def get(path: List[String]): Option[T]
def set(path: List[String], value: T): Attribute[T]
def setDefault(path: List[String], default: T): Attribute[T]
}
final class MapBackedAttribute[T](val default: Option[T], subs: Map[String, MapBackedAttribute[T]], values: Map[String, T]) extends Attribute[T]
{
def sub(s: String) = subs get s
def value(s: String) = values get s
def get(path: List[String]): Option[T] =
path match {
case Nil => None
case x :: Nil => values get x
case h :: t => (subs get h) flatMap (_ get t ) orElse default
}
def set(path: List[String], value: T): Attribute[T] =
path match {
case Nil => this
case x :: Nil => new MapBackedAttribute(default, subs, values updated( x, value) )
case h :: t =>
val (newSubs, sub) = (subs get h) match {
case Some(s) => (subs, s)
case None => (subs.updated(h, Attribute.empty[T]), Attribute.empty[T])
}
newSubs put (h, sub.set(t, value)
}
def setDefault(path: List[String], default: T): Attribute[T] =
def lastComponent(path: List[String]): Option[MapBackedAttribute[T]] =
path match {
case Nil => this
case x :: Nil => new MapBackedAttribute(default, subs, values updated( x, value) )
case h :: t =>
val (newSubs, sub) = (subs get h) match {
case Some(s) => (subs, s)
case None => (subs.updated(h, Attribute.empty[T]), Attribute.empty[T])
}
newSubs put (h, su
}
trait ConsoleLogManager extends LogManager
{
def makeLogger(context: Context, configuration: Configuration) = (task: Task[_], to: PrintWriter) =>
{
val owner = context owner task
val taskPath = (context ownerName owner).getOrElse("") :: (context staticName task).getOrElse("") ::: Nil
def level(key: AttributeKey[Level.Value], default: Level.Value): Level.Value = select(key) get taskPath getOrElse default
val screenLevel = level(ScreenLogLevel, Level.Info)
val backingLevel = select(PersistLogLevel, Level.Debug)
val console = ConsoleLogger()
val backed = ConsoleLogger(to, useColor = false) // TODO: wrap this with a filter that strips ANSI codes
val multi = new MultiLogger(console :: backed :: Nil)
// sets multi to the most verbose for clients that inspect the current level
multi setLevel Level.union(backingLevel, screenLevel)
// set the specific levels
console setLevel screenLevel
backed setLevel backingLevel
multi: Logger
}
}
*/
object ReflectiveContext
{
import Transform.Context