From dfb0a9ec8ce4360c0b3aac0c11d62f572be69514 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Wed, 6 Apr 2011 21:00:48 -0400 Subject: [PATCH] put remaining keys in Keys --- main/Aggregation.scala | 3 +-- main/Build.scala | 26 +++++--------------------- main/Defaults.scala | 9 ++++----- main/Keys.scala | 21 +++++++++++++++++++-- main/Output.scala | 2 +- main/Structure.scala | 4 ++-- 6 files changed, 32 insertions(+), 33 deletions(-) diff --git a/main/Aggregation.scala b/main/Aggregation.scala index 8e314b0b3..1f1268159 100644 --- a/main/Aggregation.scala +++ b/main/Aggregation.scala @@ -6,8 +6,7 @@ package sbt import CommandSupport.logger import Project.ScopedKey import Load.BuildStructure - import EvaluateTask.parseResult - import Keys.{aggregate, showSuccess, showTiming, timingFormat} + import Keys.{aggregate, parseResult, showSuccess, showTiming, timingFormat} import sbt.complete.Parser import java.net.URI import Parser._ diff --git a/main/Build.scala b/main/Build.scala index 65cf0db94..ef4dcf079 100644 --- a/main/Build.scala +++ b/main/Build.scala @@ -12,7 +12,8 @@ package sbt import complete.DefaultParsers.validID import Compiler.{Compilers,Inputs} import Project.{inScope, ScopedKey, ScopeLocal, Setting} - import Keys.{appConfiguration, baseDirectory, configuration, streams, thisProject, thisProjectRef} + import Keys.{appConfiguration, baseDirectory, configuration, streams, Streams, TaskStreams, thisProject, thisProjectRef} + import Keys.{dummyState, dummyStreamsManager, isDummy, parseResult, resolvedScoped, streamsManager, taskDefinitionKey} import TypeFunctions.{Endo,Id} import tools.nsc.reporters.ConsoleReporter import Build.{analyzed, data} @@ -110,29 +111,14 @@ object EvaluateTask import Project.display import std.{TaskExtra,Transform} import TaskExtra._ - import BuildStreams.{Streams, TaskStreams} + import Keys.state val SystemProcessors = Runtime.getRuntime.availableProcessors - val isDummyTask = AttributeKey[Boolean]("is-dummy-task") - val taskDefinitionKey = AttributeKey[ScopedKey[_]]("task-definition-key") - val (state, dummyState) = dummy[State]("state") - val (streamsManager, dummyStreamsManager) = dummy[Streams]("streams-manager") - val resolvedScoped = SettingKey[ScopedKey[_]]("resolved-scoped") - private[sbt] val parseResult: TaskKey[_] = TaskKey("$parse-result") - def injectSettings: Seq[Project.Setting[_]] = Seq( (state in GlobalScope) ::= dummyState, (streamsManager in GlobalScope) ::= dummyStreamsManager ) - - def dummy[T](name: String): (TaskKey[T], Task[T]) = (TaskKey[T](name), dummyTask(name)) - def dummyTask[T](name: String): Task[T] = - { - val base: Task[T] = task( error("Dummy task '" + name + "' did not get converted to a full task.") ) named name - base.copy(info = base.info.set(isDummyTask, true)) - } - def isDummy(t: Task[_]): Boolean = t.info.attributes.get(isDummyTask) getOrElse false def evalPluginDef(log: Logger)(pluginDef: BuildStructure, state: State): Seq[Attributed[File]] = { @@ -332,7 +318,7 @@ object Load // additionally, set the task axis to the defining key if it is not set def finalTransforms(ss: Seq[Setting[_]]): Seq[Setting[_]] = { - import EvaluateTask.{parseResult, resolvedScoped} + import Keys.{parseResult, resolvedScoped} def isSpecial(key: AttributeKey[_]) = key == streams.key || key == resolvedScoped.key || key == parseResult.key def mapSpecial(to: ScopedKey[_]) = new (ScopedKey ~> ScopedKey){ def apply[T](key: ScopedKey[T]) = if(isSpecial(key.key)) @@ -351,7 +337,7 @@ object Load ss.map(s => s mapReferenced mapSpecial(s.key) mapInit setDefining ) } def setDefinitionKey[T](tk: Task[T], key: ScopedKey[_]): Task[T] = - if(EvaluateTask isDummy tk) tk else Task(tk.info.set(EvaluateTask.taskDefinitionKey, key), tk.work) + if(isDummy(tk)) tk else Task(tk.info.set(Keys.taskDefinitionKey, key), tk.work) def structureIndex(settings: Settings[Scope]): StructureIndex = new StructureIndex(Index.stringToKeyMap(settings), Index.taskToKeyMap(settings), KeyIndex(settings.allKeys( (s,k) => ScopedKey(s,k)))) @@ -683,8 +669,6 @@ object BuildStreams import Project.display import std.{TaskExtra,Transform} - type Streams = std.Streams[ScopedKey[_]] - type TaskStreams = std.TaskStreams[ScopedKey[_]] val GlobalPath = "$global" val BuildUnitPath = "$build" diff --git a/main/Defaults.scala b/main/Defaults.scala index fdaf684fe..13ca44ee8 100755 --- a/main/Defaults.scala +++ b/main/Defaults.scala @@ -8,7 +8,6 @@ package sbt import compiler.Discovery import Project.{inConfig, Initialize, inScope, inTask, ScopedKey, Setting} import Configurations.{Compile => CompileConf, Test => TestConf} - import EvaluateTask.resolvedScoped import complete._ import std.TaskExtra._ @@ -81,7 +80,7 @@ object Defaults showSuccess :== true, commands :== Nil, retrieveManaged :== false, - settings <<= EvaluateTask.state map { state => Project.structure(state).data } + settings <<= state map { state => Project.structure(state).data } )) def projectCore: Seq[Setting[_]] = Seq( name <<= thisProject(_.id), @@ -157,7 +156,7 @@ object Defaults watch <<= watchSetting ) - def inAllConfigurations[T](key: ScopedTask[T]): Initialize[Task[Seq[T]]] = (EvaluateTask.state, thisProjectRef) flatMap { (state, ref) => + def inAllConfigurations[T](key: ScopedTask[T]): Initialize[Task[Seq[T]]] = (state, thisProjectRef) flatMap { (state, ref) => val structure = Project structure state val configurations = Project.getProject(ref, structure).toList.flatMap(_.configurations) configurations.flatMap { conf => @@ -165,7 +164,7 @@ object Defaults } join } def watchTransitiveSourcesTask: Initialize[Task[Seq[File]]] = - (EvaluateTask.state, thisProjectRef) flatMap { (s, base) => + (state, thisProjectRef) flatMap { (s, base) => inAllDependencies(base, watchSources.setting, Project structure s).join.map(_.flatten) } def watchSourcesTask: Initialize[Task[Seq[File]]] = Seq(sources, resources).map(inAllConfigurations).join { _.join.map(_.flatten.flatten) } @@ -323,7 +322,7 @@ object Defaults def discoverMainClasses(analysis: inc.Analysis): Seq[String] = Discovery.applications(Tests.allDefs(analysis)) collect { case (definition, discovered) if(discovered.hasMain) => definition.name } - def consoleProjectTask = (EvaluateTask.state, streams, initialCommands in consoleProject) map { (state, s, extra) => Console.sbt(state, extra)(s.log); println() } + def consoleProjectTask = (state, streams, initialCommands in consoleProject) map { (state, s, extra) => Console.sbt(state, extra)(s.log); println() } def consoleTask: Initialize[Task[Unit]] = consoleTask(fullClasspath, console) def consoleQuickTask = consoleTask(externalDependencyClasspath, consoleQuick) def consoleTask(classpath: TaskKey[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] = (compilers, classpath, scalacOptions in task, initialCommands in task, streams) map { diff --git a/main/Keys.scala b/main/Keys.scala index d3cd5a8fa..dee340e03 100644 --- a/main/Keys.scala +++ b/main/Keys.scala @@ -4,7 +4,7 @@ package sbt import java.io.File - import EvaluateTask.resolvedScoped + import Project.ScopedKey import complete._ import inc.Analysis import std.TaskExtra._ @@ -207,5 +207,22 @@ object Keys // special val settings = TaskKey[Settings[Scope]]("settings") - val streams = TaskKey[BuildStreams.TaskStreams]("streams") + val streams = TaskKey[TaskStreams]("streams") + val isDummyTask = AttributeKey[Boolean]("is-dummy-task") + val taskDefinitionKey = AttributeKey[ScopedKey[_]]("task-definition-key") + val (state, dummyState) = dummy[State]("state") + val (streamsManager, dummyStreamsManager) = dummy[Streams]("streams-manager") + val resolvedScoped = SettingKey[ScopedKey[_]]("resolved-scoped") + private[sbt] val parseResult: TaskKey[_] = TaskKey("$parse-result") + + type Streams = std.Streams[ScopedKey[_]] + type TaskStreams = std.TaskStreams[ScopedKey[_]] + + def dummy[T](name: String): (TaskKey[T], Task[T]) = (TaskKey[T](name), dummyTask(name)) + def dummyTask[T](name: String): Task[T] = + { + val base: Task[T] = task( error("Dummy task '" + name + "' did not get converted to a full task.") ) named name + base.copy(info = base.info.set(isDummyTask, true)) + } + def isDummy(t: Task[_]): Boolean = t.info.attributes.get(isDummyTask) getOrElse false } \ No newline at end of file diff --git a/main/Output.scala b/main/Output.scala index 5b931efbe..6a853f75a 100644 --- a/main/Output.scala +++ b/main/Output.scala @@ -4,7 +4,7 @@ package sbt import java.util.regex.Pattern - import BuildStreams.{Streams, TaskStreams} + import Keys.{Streams, TaskStreams} import Project.ScopedKey object Output diff --git a/main/Structure.scala b/main/Structure.scala index 74ea556b0..2e5cc41c0 100644 --- a/main/Structure.scala +++ b/main/Structure.scala @@ -47,10 +47,10 @@ object InputTask // This interface allows the Parser to be constructed using other Settings, but not Tasks (which is desired). // The action can be constructed using Settings and Tasks and with the parse result injected into a Task. // This is the ugly part, requiring hooks in injectStreams and Act to handle the dummy task for the parse result. - // However, this is results in a minimal interface to the full capabilities of an InputTask + // However, this is results in a minimal interface to the full capabilities of an InputTask for users def apply[I,T](p: Initialize[State => Parser[I]])(action: TaskKey[I] => Initialize[Task[T]]): Initialize[InputTask[T]] = { - val key = EvaluateTask.parseResult.asInstanceOf[TaskKey[I]] + val key = Keys.parseResult.asInstanceOf[TaskKey[I]] p.zipWith(action(key)) { (parserF, act) => new InputDynamic[T] {