From 602c1759a18852612488fbed784ddda0e9d3dda3 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Sun, 23 Jun 2013 19:57:30 -0400 Subject: [PATCH] Make ExecuteProgress listener configurable via executeProgress setting. Experimental, so everything is private[sbt]. --- main/src/main/scala/sbt/EvaluateTask.scala | 32 ++++++++++++++++------ main/src/main/scala/sbt/Keys.scala | 4 +++ 2 files changed, 27 insertions(+), 9 deletions(-) diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala index 3992c738a..c51107064 100644 --- a/main/src/main/scala/sbt/EvaluateTask.scala +++ b/main/src/main/scala/sbt/EvaluateTask.scala @@ -14,7 +14,7 @@ package sbt import std.Transform.{DummyTaskMap,TaskAndValue} import TaskName._ -final case class EvaluateConfig(cancelable: Boolean, restrictions: Seq[Tags.Rule], checkCycles: Boolean = false) +final case class EvaluateConfig(cancelable: Boolean, restrictions: Seq[Tags.Rule], checkCycles: Boolean = false, progress: ExecuteProgress[Task] = EvaluateTask.defaultProgress) final case class PluginData(dependencyClasspath: Seq[Attributed[File]], definitionClasspath: Seq[Attributed[File]], resolvers: Option[Seq[Resolver]], report: Option[UpdateReport]) { val classpath: Seq[Attributed[File]] = definitionClasspath ++ dependencyClasspath @@ -32,17 +32,28 @@ object EvaluateTask import TaskExtra._ import Keys.state + private[sbt] def defaultProgress: ExecuteProgress[Task] = + if(java.lang.Boolean.getBoolean("sbt.task.timings")) new TaskTimings else ExecuteProgress.empty[Task] + val SystemProcessors = Runtime.getRuntime.availableProcessors - def defaultConfig(state: State): EvaluateConfig = - EvaluateConfig(false, restrictions(state)) + + @deprecated("Use extractedConfig.", "0.13.0") + def defaultConfig(state: State): EvaluateConfig = + { + val extracted = Project.extract(state) + defaultConfig(extracted, extracted.structure) + } + + @deprecated("Use extractedConfig.", "0.13.0") def defaultConfig(extracted: Extracted, structure: BuildStructure) = - EvaluateConfig(false, restrictions(extracted, structure)) + EvaluateConfig(false, restrictions(extracted, structure), progress = executeProgress(extracted, structure)) def extractedConfig(extracted: Extracted, structure: BuildStructure): EvaluateConfig = { val workers = restrictions(extracted, structure) val canCancel = cancelable(extracted, structure) - EvaluateConfig(cancelable = canCancel, restrictions = workers) + val progress = executeProgress(extracted, structure) + EvaluateConfig(cancelable = canCancel, restrictions = workers, progress = progress) } def defaultRestrictions(maxWorkers: Int) = Tags.limitAll(maxWorkers) :: Nil @@ -63,6 +74,10 @@ object EvaluateTask 1 def cancelable(extracted: Extracted, structure: BuildStructure): Boolean = getSetting(Keys.cancelable, false, extracted, structure) + + private[sbt] def executeProgress(extracted: Extracted, structure: BuildStructure): ExecuteProgress[Task] = + getSetting(Keys.executeProgress, new Keys.TaskProgress(defaultProgress), extracted, structure).progress + def getSetting[T](key: SettingKey[T], default: T, extracted: Extracted, structure: BuildStructure): T = key in extracted.currentRef get structure.data getOrElse default @@ -76,7 +91,7 @@ object EvaluateTask { val root = ProjectRef(pluginDef.root, Load.getRootProject(pluginDef.units)(pluginDef.root)) val pluginKey = pluginData - val config = defaultConfig(Project.extract(state), pluginDef) + val config = extractedConfig(Project.extract(state), pluginDef) val evaluated = apply(pluginDef, ScopedKey(pluginKey.scope, pluginKey.key), state, root, config) val (newS, result) = evaluated getOrElse sys.error("Plugin data does not exist for plugin definition at " + pluginDef.root) Project.runUnloadHooks(newS) // discard states @@ -91,7 +106,7 @@ object EvaluateTask * If the task is not defined, None is returned. The provided task key is resolved against the current project `ref`. * Task execution is configured according to settings defined in the loaded project.*/ def apply[T](structure: BuildStructure, taskKey: ScopedKey[Task[T]], state: State, ref: ProjectRef): Option[(State, Result[T])] = - apply[T](structure, taskKey, state, ref, defaultConfig(Project.extract(state), structure)) + apply[T](structure, taskKey, state, ref, extractedConfig(Project.extract(state), structure)) /** Evaluates `taskKey` and returns the new State and the result of the task wrapped in Some. * If the task is not defined, None is returned. The provided task key is resolved against the current project `ref`. @@ -163,8 +178,7 @@ object EvaluateTask case _ => true } def run() = { - val progress = if(java.lang.Boolean.getBoolean("sbt.task.timings")) new TaskTimings else ExecuteProgress.empty[Task] - val x = new Execute[Task]( Execute.config(config.checkCycles, overwriteNode), triggers, progress)(taskToNode) + val x = new Execute[Task]( Execute.config(config.checkCycles, overwriteNode), triggers, config.progress)(taskToNode) val (newState, result) = try applyResults(x.runKeep(root)(service), state, root) catch { case inc: Incomplete => (state, Inc(inc)) } diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index fc36f7c87..09d1eb0a0 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -334,6 +334,10 @@ object Keys val resolvedScoped = Def.resolvedScoped val pluginData = TaskKey[PluginData]("plugin-data", "Information from the plugin build needed in the main build definition.", DTask) + // wrapper to work around SI-2915 + private[sbt] final class TaskProgress(val progress: ExecuteProgress[Task]) + private[sbt] val executeProgress = SettingKey[TaskProgress]("executeProgress", "Experimental task execution listener.", DTask) + val triggeredBy = Def.triggeredBy val runBefore = Def.runBefore