From 6ddeca12a2bd8d827785f4d87126f49786a8bb6d Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Sun, 16 Oct 2011 17:27:36 -0400 Subject: [PATCH] merge Scoped{Setting,Task,Input} and {Setting,Task,Input}Key --- main/Defaults.scala | 54 ++++++++++++++++++------------------ main/Project.scala | 14 +++++----- main/Structure.scala | 65 ++++++++++++++++++++------------------------ sbt/package.scala | 7 +++++ 4 files changed, 71 insertions(+), 69 deletions(-) diff --git a/main/Defaults.scala b/main/Defaults.scala index 018fd2f64..de40ec43b 100644 --- a/main/Defaults.scala +++ b/main/Defaults.scala @@ -30,7 +30,7 @@ package sbt object Defaults extends BuildCommon { - def configSrcSub(key: ScopedSetting[File]): Initialize[File] = (key in ThisScope.copy(config = Global), configuration) { (src, conf) => src / nameForSrc(conf.name) } + def configSrcSub(key: SettingKey[File]): Initialize[File] = (key in ThisScope.copy(config = Global), configuration) { (src, conf) => src / nameForSrc(conf.name) } def nameForSrc(config: String) = if(config == "compile") "main" else config def prefix(config: String) = if(config == "compile") "" else config + "-" @@ -215,9 +215,9 @@ object Defaults extends BuildCommon watch <<= watchSetting ) - def generate(generators: ScopedSetting[Seq[Task[Seq[File]]]]): Initialize[Task[Seq[File]]] = generators {_.join.map(_.flatten) } + def generate(generators: SettingKey[Seq[Task[Seq[File]]]]): Initialize[Task[Seq[File]]] = generators {_.join.map(_.flatten) } - def inAllConfigurations[T](key: ScopedTask[T]): Initialize[Task[Seq[T]]] = (state, thisProjectRef) flatMap { (state, ref) => + def inAllConfigurations[T](key: TaskKey[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 => @@ -353,7 +353,7 @@ object Defaults extends BuildCommon def collectFiles(dirs: ScopedTaskable[Seq[File]], filter: ScopedTaskable[FileFilter], excludes: ScopedTaskable[FileFilter]): Initialize[Task[Seq[File]]] = (dirs, filter, excludes) map { (d,f,excl) => d.descendentsExcept(f,excl).get } - def artifactPathSetting(art: ScopedSetting[Artifact]) = (crossTarget, projectID, art, scalaVersion in artifactName, artifactName) { (t, module, a, sv, toString) => t / toString(sv, module, a) asFile } + def artifactPathSetting(art: SettingKey[Artifact]) = (crossTarget, projectID, art, scalaVersion in artifactName, artifactName) { (t, module, a, sv, toString) => t / toString(sv, module, a) asFile } def artifactSetting = ((artifact, artifactClassifier).identity zipWith configuration.?) { case ((a,classifier),cOpt) => val cPart = cOpt flatMap { c => if(c == Compile) None else Some(c.name) } val combined = cPart.toList ++ classifier.toList @@ -404,7 +404,7 @@ object Defaults extends BuildCommon IO.delete(clean) IO.move(mappings.map(_.swap)) } - def runMainTask(classpath: ScopedTask[Classpath], scalaRun: ScopedTask[ScalaRun]): Initialize[InputTask[Unit]] = + def runMainTask(classpath: TaskKey[Classpath], scalaRun: TaskKey[ScalaRun]): Initialize[InputTask[Unit]] = { import DefaultParsers._ InputTask( loadForParser(discoveredMainClasses)( (s, names) => runMainParser(s, names getOrElse Nil) ) ) { result => @@ -414,7 +414,7 @@ object Defaults extends BuildCommon } } - def runTask(classpath: ScopedTask[Classpath], mainClassTask: ScopedTask[Option[String]], scalaRun: ScopedTask[ScalaRun]): Initialize[InputTask[Unit]] = + def runTask(classpath: TaskKey[Classpath], mainClassTask: TaskKey[Option[String]], scalaRun: TaskKey[ScalaRun]): Initialize[InputTask[Unit]] = inputTask { result => (classpath, mainClassTask, scalaRun, streams, result) map { (cp, main, runner, s, args) => val mainClass = main getOrElse error("No main class detected.") @@ -432,7 +432,7 @@ object Defaults extends BuildCommon new Run(si, trap, tmp) } - def docSetting(key: ScopedTask[File]): Seq[Setting[_]] = inTask(key)(Seq( + def docSetting(key: TaskKey[File]): Seq[Setting[_]] = inTask(key)(Seq( cacheDirectory ~= (_ / key.key.label), target <<= docDirectory, // deprecate docDirectory in favor of 'target in doc'; remove when docDirectory is removed scaladocOptions <<= scalacOptions, // deprecate scaladocOptions in favor of 'scalacOptions in doc'; remove when scaladocOptions is removed @@ -460,7 +460,7 @@ object Defaults extends BuildCommon def consoleProjectTask = (state, streams, initialCommands in consoleProject) map { (state, s, extra) => ConsoleProject(state, extra)(s.log); println() } def consoleTask: Initialize[Task[Unit]] = consoleTask(fullClasspath, console) def consoleQuickTask = consoleTask(externalDependencyClasspath, consoleQuick) - def consoleTask(classpath: ScopedTask[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] = (compilers in task, classpath in task, scalacOptions in task, initialCommands in task, streams) map { + def consoleTask(classpath: TaskKey[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] = (compilers in task, classpath in task, scalacOptions in task, initialCommands in task, streams) map { (cs, cp, options, initCommands, s) => (new Console(cs.scalac))(data(cp), options, initCommands, s.log).foreach(msg => error(msg)) println() @@ -535,7 +535,7 @@ object Defaults extends BuildCommon recurse ?? Nil } - def inDependencies[T](key: ScopedSetting[T], default: ProjectRef => T, includeRoot: Boolean = true, classpath: Boolean = true, aggregate: Boolean = false): Initialize[Seq[T]] = + def inDependencies[T](key: SettingKey[T], default: ProjectRef => T, includeRoot: Boolean = true, classpath: Boolean = true, aggregate: Boolean = false): Initialize[Seq[T]] = Project.bind( (loadedBuild, thisProjectRef).identity ) { case (lb, base) => transitiveDependencies(base, lb, includeRoot, classpath, aggregate) map ( ref => (key in ref) ?? default(ref) ) join ; } @@ -584,7 +584,7 @@ object Classpaths def concatDistinct[T](a: ScopedTaskable[Seq[T]], b: ScopedTaskable[Seq[T]]): Initialize[Task[Seq[T]]] = (a,b) map { (x,y) => (x ++ y).distinct } def concat[T](a: ScopedTaskable[Seq[T]], b: ScopedTaskable[Seq[T]]): Initialize[Task[Seq[T]]] = (a,b) map ( _ ++ _) - def concatSettings[T](a: ScopedSetting[Seq[T]], b: ScopedSetting[Seq[T]]): Initialize[Seq[T]] = (a,b)(_ ++ _) + def concatSettings[T](a: SettingKey[Seq[T]], b: SettingKey[Seq[T]]): Initialize[Seq[T]] = (a,b)(_ ++ _) lazy val configSettings: Seq[Setting[_]] = Seq( externalDependencyClasspath <<= concat(unmanagedClasspath, managedClasspath), @@ -605,9 +605,9 @@ object Classpaths } ) def defaultPackageKeys = Seq(packageBin, packageSrc, packageDoc) - lazy val defaultPackages: Seq[ScopedTask[File]] = + lazy val defaultPackages: Seq[TaskKey[File]] = for(task <- defaultPackageKeys; conf <- Seq(Compile, Test)) yield (task in conf) - lazy val defaultArtifactTasks: Seq[ScopedTask[File]] = makePom +: defaultPackages + lazy val defaultArtifactTasks: Seq[TaskKey[File]] = makePom +: defaultPackages def findClasspathConfig(map: Configuration => Configuration, thisConfig: Configuration, delegate: Task[Option[Configuration]], up: Task[UpdateReport]): Task[Configuration] = (delegate :^: up :^: KNil) map { case delegated :+: report :+: HNil => @@ -617,14 +617,14 @@ object Classpaths search find { defined contains _.name } getOrElse notFound } - def packaged(pkgTasks: Seq[ScopedTask[File]]): Initialize[Task[Map[Artifact, File]]] = + def packaged(pkgTasks: Seq[TaskKey[File]]): Initialize[Task[Map[Artifact, File]]] = enabledOnly(packagedArtifact.task, pkgTasks) apply (_.join.map(_.toMap)) - def artifactDefs(pkgTasks: Seq[ScopedTask[File]]): Initialize[Seq[Artifact]] = + def artifactDefs(pkgTasks: Seq[TaskKey[File]]): Initialize[Seq[Artifact]] = enabledOnly(artifact, pkgTasks) - def enabledOnly[T](key: ScopedSetting[T], pkgTasks: Seq[ScopedTask[File]]): Initialize[Seq[T]] = + def enabledOnly[T](key: SettingKey[T], pkgTasks: Seq[TaskKey[File]]): Initialize[Seq[T]] = ( forallIn(key, pkgTasks) zipWith forallIn(publishArtifact, pkgTasks) ) ( _ zip _ collect { case (a, true) => a } ) - def forallIn[T](key: ScopedSetting[T], pkgTasks: Seq[ScopedTask[_]]): Initialize[Seq[T]] = + def forallIn[T](key: SettingKey[T], pkgTasks: Seq[TaskKey[_]]): Initialize[Seq[T]] = pkgTasks.map( pkg => key in pkg.scope in pkg ).join val publishSettings: Seq[Setting[_]] = Seq( @@ -1041,7 +1041,7 @@ trait BuildExtra extends BuildCommon def addCompilerPlugin(dependency: ModuleID): Setting[Seq[ModuleID]] = libraryDependencies += compilerPlugin(dependency) - def addArtifact(a: Artifact, taskDef: ScopedTask[File]): SettingsDefinition = + def addArtifact(a: Artifact, taskDef: TaskKey[File]): SettingsDefinition = { val pkgd = packagedArtifacts <<= (packagedArtifacts, taskDef) map ( (pas,file) => pas updated (a, file) ) seq( artifacts += a, pkgd ) @@ -1083,7 +1083,7 @@ trait BuildExtra extends BuildCommon toError(r.run(mainClass, data(cp), arguments, s.log)) } - def fullRunInputTask(scoped: ScopedInput[Unit], config: Configuration, mainClass: String, baseArguments: String*): Setting[InputTask[Unit]] = + def fullRunInputTask(scoped: InputKey[Unit], config: Configuration, mainClass: String, baseArguments: String*): Setting[InputTask[Unit]] = scoped <<= inputTask { result => ( initScoped(scoped.scopedKey, runnerInit) zipWith (fullClasspath in config, streams, result).identityMap) { (rTask, t) => (t :^: rTask :^: KNil) map { case (cp, s, args) :+: r :+: HNil => @@ -1091,7 +1091,7 @@ trait BuildExtra extends BuildCommon } } } - def fullRunTask(scoped: ScopedTask[Unit], config: Configuration, mainClass: String, arguments: String*): Setting[Task[Unit]] = + def fullRunTask(scoped: TaskKey[Unit], config: Configuration, mainClass: String, arguments: String*): Setting[Task[Unit]] = scoped <<= ( initScoped(scoped.scopedKey, runnerInit) zipWith (fullClasspath in config, streams).identityMap ) { case (rTask, t) => (t :^: rTask :^: KNil) map { case (cp, s) :+: r :+: HNil => toError(r.run(mainClass, data(cp), arguments, s.log)) @@ -1139,27 +1139,27 @@ trait BuildCommon } // these are intended for use in input tasks for creating parsers - def getFromContext[T](task: ScopedTask[T], context: ScopedKey[_], s: State): Option[T] = + def getFromContext[T](task: TaskKey[T], context: ScopedKey[_], s: State): Option[T] = SessionVar.get(SessionVar.resolveContext(task.scopedKey, context.scope, s), s) - def loadFromContext[T](task: ScopedTask[T], context: ScopedKey[_], s: State)(implicit f: sbinary.Format[T]): Option[T] = + def loadFromContext[T](task: TaskKey[T], context: ScopedKey[_], s: State)(implicit f: sbinary.Format[T]): Option[T] = SessionVar.load(SessionVar.resolveContext(task.scopedKey, context.scope, s), s) // intended for use in constructing InputTasks - def loadForParser[P,T](task: ScopedTask[T])(f: (State, Option[T]) => Parser[P])(implicit format: sbinary.Format[T]): Initialize[State => Parser[P]] = + def loadForParser[P,T](task: TaskKey[T])(f: (State, Option[T]) => Parser[P])(implicit format: sbinary.Format[T]): Initialize[State => Parser[P]] = loadForParserI(task)(Project value f)(format) - def loadForParserI[P,T](task: ScopedTask[T])(init: Initialize[(State, Option[T]) => Parser[P]])(implicit format: sbinary.Format[T]): Initialize[State => Parser[P]] = + def loadForParserI[P,T](task: TaskKey[T])(init: Initialize[(State, Option[T]) => Parser[P]])(implicit format: sbinary.Format[T]): Initialize[State => Parser[P]] = (resolvedScoped, init)( (ctx, f) => (s: State) => f( s, loadFromContext(task, ctx, s)(format)) ) - def getForParser[P,T](task: ScopedTask[T])(init: (State, Option[T]) => Parser[P]): Initialize[State => Parser[P]] = + def getForParser[P,T](task: TaskKey[T])(init: (State, Option[T]) => Parser[P]): Initialize[State => Parser[P]] = getForParserI(task)(Project value init) - def getForParserI[P,T](task: ScopedTask[T])(init: Initialize[(State, Option[T]) => Parser[P]]): Initialize[State => Parser[P]] = + def getForParserI[P,T](task: TaskKey[T])(init: Initialize[(State, Option[T]) => Parser[P]]): Initialize[State => Parser[P]] = (resolvedScoped, init)( (ctx, f) => (s: State) => f(s, getFromContext(task, ctx, s)) ) // these are for use for constructing Tasks - def loadPrevious[T](task: ScopedTask[T])(implicit f: sbinary.Format[T]): Initialize[Task[Option[T]]] = + def loadPrevious[T](task: TaskKey[T])(implicit f: sbinary.Format[T]): Initialize[Task[Option[T]]] = (state, resolvedScoped) map { (s, ctx) => loadFromContext(task, ctx, s)(f) } - def getPrevious[T](task: ScopedTask[T]): Initialize[Task[Option[T]]] = + def getPrevious[T](task: TaskKey[T]): Initialize[Task[Option[T]]] = (state, resolvedScoped) map { (s, ctx) => getFromContext(task, ctx, s) } } \ No newline at end of file diff --git a/main/Project.scala b/main/Project.scala index 39f48084c..b439591d5 100644 --- a/main/Project.scala +++ b/main/Project.scala @@ -67,13 +67,13 @@ final case class Extracted(structure: BuildStructure, session: SessionSettings, lazy val currentUnit = structure units currentRef.build lazy val currentProject = currentUnit defined currentRef.project lazy val currentLoader: ClassLoader = currentUnit.loader - def get[T](key: ScopedTask[T]): Task[T] = get(key.task) - def get[T](key: ScopedSetting[T]) = getOrError(inCurrent(key), key.key) - def getOpt[T](key: ScopedSetting[T]): Option[T] = structure.data.get(inCurrent(key), key.key) - private[this] def inCurrent[T](key: ScopedSetting[T]): Scope = if(key.scope.project == This) key.scope.copy(project = Select(currentRef)) else key.scope + def get[T](key: TaskKey[T]): Task[T] = get(key.task) + def get[T](key: SettingKey[T]) = getOrError(inCurrent(key), key.key) + def getOpt[T](key: SettingKey[T]): Option[T] = structure.data.get(inCurrent(key), key.key) + private[this] def inCurrent[T](key: SettingKey[T]): Scope = if(key.scope.project == This) key.scope.copy(project = Select(currentRef)) else key.scope @deprecated("This method does not apply state changes requested during task execution. Use 'runTask' instead, which does.", "0.11.1") - def evalTask[T](key: ScopedTask[T], state: State): T = runTask(key, state)._2 - def runTask[T](key: ScopedTask[T], state: State): (State, T) = + def evalTask[T](key: TaskKey[T], state: State): T = runTask(key, state)._2 + def runTask[T](key: TaskKey[T], state: State): (State, T) = { import EvaluateTask._ val rkey = Project.mapScope(Scope.resolveScope(GlobalScope, currentRef.build, rootProject) )( key.scopedKey ) @@ -169,7 +169,7 @@ object Project extends Init[Scope] with ProjectExtra onLoad(updateCurrent( newState )) } def orIdentity[T](opt: Option[T => T]): T => T = opt getOrElse idFun - def getHook[T](key: ScopedSetting[T => T], data: Settings[Scope]): T => T = orIdentity(key in GlobalScope get data) + def getHook[T](key: SettingKey[T => T], data: Settings[Scope]): T => T = orIdentity(key in GlobalScope get data) def getHooks(data: Settings[Scope]): (State => State, State => State) = (getHook(Keys.onLoad, data), getHook(Keys.onUnload, data)) def current(state: State): ProjectRef = session(state).current diff --git a/main/Structure.scala b/main/Structure.scala index 9df3baaed..3c6414dff 100644 --- a/main/Structure.scala +++ b/main/Structure.scala @@ -70,40 +70,35 @@ object InputTask apply(Project.value(p))(action) } -sealed trait Scoped { def scope: Scope; def key: AttributeKey[_] } +sealed trait Scoped { def scope: Scope; val key: AttributeKey[_] } sealed trait ScopedTaskable[T] extends Scoped -sealed trait ScopedSetting[T] extends ScopedTaskable[T] with KeyedInitialize[T] with Scoped.ScopingSetting[ScopedSetting[T]] with Scoped.DefinableSetting[T] with Scoped.ListSetting[T, Id] +sealed trait SettingKey[T] extends ScopedTaskable[T] with KeyedInitialize[T] with Scoped.ScopingSetting[SettingKey[T]] with Scoped.DefinableSetting[T] with Scoped.ListSetting[T, Id] { - def key: AttributeKey[T] + val key: AttributeKey[T] def scopedKey: ScopedKey[T] = ScopedKey(scope, key) - def in(scope: Scope): ScopedSetting[T] = Scoped.scopedSetting(Scope.replaceThis(this.scope)(scope), this.key) + def in(scope: Scope): SettingKey[T] = Scoped.scopedSetting(Scope.replaceThis(this.scope)(scope), this.key) protected[this] def make[S](other: Initialize[S])(f: (T, S) => T): Setting[T] = this <<= (this, other)(f) } -sealed trait ScopedTask[T] extends ScopedTaskable[T] with KeyedInitialize[Task[T]] with Scoped.ScopingSetting[ScopedTask[T]] with Scoped.ListSetting[T, Task] with Scoped.DefinableTask[T] +sealed trait TaskKey[T] extends ScopedTaskable[T] with KeyedInitialize[Task[T]] with Scoped.ScopingSetting[TaskKey[T]] with Scoped.ListSetting[T, Task] with Scoped.DefinableTask[T] { - def key: AttributeKey[Task[T]] + val key: AttributeKey[Task[T]] def scopedKey: ScopedKey[Task[T]] = ScopedKey(scope, key) - def in(scope: Scope): ScopedTask[T] = Scoped.scopedTask(Scope.replaceThis(this.scope)(scope), this.key) + def in(scope: Scope): TaskKey[T] = Scoped.scopedTask(Scope.replaceThis(this.scope)(scope), this.key) protected[this] def make[S](other: Initialize[Task[S]])(f: (T, S) => T): Setting[Task[T]] = this <<= (this, other) { (a,b) => (a,b) map f } } -sealed trait ScopedInput[T] extends Scoped with KeyedInitialize[InputTask[T]] with Scoped.ScopingSetting[ScopedInput[T]] with Scoped.DefinableSetting[InputTask[T]] +sealed trait InputKey[T] extends Scoped with KeyedInitialize[InputTask[T]] with Scoped.ScopingSetting[InputKey[T]] with Scoped.DefinableSetting[InputTask[T]] { - def key: AttributeKey[InputTask[T]] + val key: AttributeKey[InputTask[T]] def scopedKey: ScopedKey[InputTask[T]] = ScopedKey(scope, key) - def in(scope: Scope): ScopedInput[T] = Scoped.scopedInput(Scope.replaceThis(this.scope)(scope), this.key) + def in(scope: Scope): InputKey[T] = Scoped.scopedInput(Scope.replaceThis(this.scope)(scope), this.key) } -sealed trait Key[T] extends Scoped { final def scope: Scope = Scope.ThisScope } -final class SettingKey[T] private(val key: AttributeKey[T]) extends Key[T] with ScopedSetting[T] -final class TaskKey[T] private(val key: AttributeKey[Task[T]]) extends Key[T] with ScopedTask[T] -final class InputKey[T] private(val key: AttributeKey[InputTask[T]]) extends Key[InputTask[T]] with ScopedInput[T] - object Scoped { - implicit def taskScopedToKey[T](s: ScopedTask[T]): ScopedKey[Task[T]] = ScopedKey(s.scope, s.key) - implicit def inputScopedToKey[T](s: ScopedInput[T]): ScopedKey[InputTask[T]] = ScopedKey(s.scope, s.key) + implicit def taskScopedToKey[T](s: TaskKey[T]): ScopedKey[Task[T]] = ScopedKey(s.scope, s.key) + implicit def inputScopedToKey[T](s: InputKey[T]): ScopedKey[InputTask[T]] = ScopedKey(s.scope, s.key) sealed trait ScopingSetting[Result] { @@ -119,9 +114,9 @@ object Scoped def in(p: ScopeAxis[Reference], c: ScopeAxis[ConfigKey], t: ScopeAxis[AttributeKey[_]]): Result = in( Scope(p, c, t, This) ) } - def scopedSetting[T](s: Scope, k: AttributeKey[T]): ScopedSetting[T] = new ScopedSetting[T] { val scope = s; val key = k} - def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): ScopedInput[T] = new ScopedInput[T] { val scope = s; val key = k } - def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): ScopedTask[T] = new ScopedTask[T] { val scope = s; val key = k } + def scopedSetting[T](s: Scope, k: AttributeKey[T]): SettingKey[T] = new SettingKey[T] { val scope = s; val key = k} + def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): InputKey[T] = new InputKey[T] { val scope = s; val key = k } + def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): TaskKey[T] = new TaskKey[T] { val scope = s; val key = k } sealed trait ListSetting[S, M[_]] { @@ -154,17 +149,17 @@ object Scoped def flatMap[T](f: S => Task[T]): Initialize[Task[T]] = init(f) } sealed trait DefinableTask[S] - { self: ScopedTask[S] => + { self: TaskKey[S] => private[sbt] def :==(value: S): Setting[Task[S]] = :=(value) private[sbt] def ::=(value: Task[S]): Setting[Task[S]] = Project.setting(scopedKey, Project.value( value )) def := (value: => S): Setting[Task[S]] = ::=(mktask(value)) - private[sbt] def :== (v: ScopedSetting[S]): Setting[Task[S]] = <<=( v(constant)) + private[sbt] def :== (v: SettingKey[S]): Setting[Task[S]] = <<=( v(constant)) def ~= (f: S => S): Setting[Task[S]] = Project.update(scopedKey)( _ map f ) def <<= (app: Initialize[Task[S]]): Setting[Task[S]] = Project.setting(scopedKey, app) - def task: ScopedSetting[Task[S]] = scopedSetting(scope, key) + def task: SettingKey[Task[S]] = scopedSetting(scope, key) def get(settings: Settings[Scope]): Option[Task[S]] = settings.get(scope, key) @deprecated("A call to 'identity' is no longer necessary and can be removed.") @@ -193,10 +188,10 @@ object Scoped import SessionVar.{persistAndSet, resolveContext, set, transform} def updateState(f: (State, S) => State): Initialize[Task[S]] = i(t => transform(t, f)) - def storeAs(key: ScopedTask[S])(implicit f: sbinary.Format[S]): Initialize[Task[S]] = (Keys.resolvedScoped, i) { (scoped, task) => + def storeAs(key: TaskKey[S])(implicit f: sbinary.Format[S]): Initialize[Task[S]] = (Keys.resolvedScoped, i) { (scoped, task) => transform(task, (state, value) => persistAndSet( resolveContext(key, scoped.scope, state), state, value)(f)) } - def keepAs(key: ScopedTask[S]): Initialize[Task[S]] = + def keepAs(key: TaskKey[S]): Initialize[Task[S]] = (i, Keys.resolvedScoped)( (t,scoped) => transform(t, (state,value) => set(resolveContext(key, scoped.scope, state), state, value) ) ) def triggeredBy(tasks: AnyInitTask*): Initialize[Task[S]] = nonLocal(tasks, Keys.triggeredBy) @@ -219,15 +214,15 @@ object Scoped } - implicit def richFileSetting(s: ScopedSetting[File]): RichFileSetting = new RichFileSetting(s) - implicit def richFilesSetting(s: ScopedSetting[Seq[File]]): RichFilesSetting = new RichFilesSetting(s) + implicit def richFileSetting(s: SettingKey[File]): RichFileSetting = new RichFileSetting(s) + implicit def richFilesSetting(s: SettingKey[Seq[File]]): RichFilesSetting = new RichFilesSetting(s) - final class RichFileSetting(s: ScopedSetting[File]) extends RichFileBase + final class RichFileSetting(s: SettingKey[File]) extends RichFileBase { def /(c: String): Initialize[File] = s { _ / c } protected[this] def map0(f: PathFinder => PathFinder) = s(file => finder(f)(file :: Nil)) } - final class RichFilesSetting(s: ScopedSetting[Seq[File]]) extends RichFileBase + final class RichFilesSetting(s: SettingKey[Seq[File]]) extends RichFileBase { def /(s: String): Initialize[Seq[File]] = map0 { _ / s } protected[this] def map0(f: PathFinder => PathFinder) = s(finder(f)) @@ -243,7 +238,7 @@ object Scoped /* * Reduced and combine provide support for mixed Setting/Task flatMap/map. - * The general idea is to take a KList of ScopedTaskables, which are either ScopedSettings or ScopedTasks, + * The general idea is to take a KList of ScopedTaskables, which are either SettingKeys or TaskKeys, * and uniformly provide multi-flatMap/map for constructing a new Task. * For example: {{{ (SettingKeyA, TaskKeyB) flatMap { (a,b) => ... } }}} */ @@ -272,8 +267,8 @@ object Scoped def prependTaskable[H](key: ScopedTaskable[H]): Reduced[_,_,H :+: HLv] = key match { - case ss: ScopedSetting[H] => prependSetting(ss) - case st: ScopedTask[H] => prependTask(scopedSetting(st.scope, st.key)) + case ss: SettingKey[H] => prependSetting(ss) + case st: TaskKey[H] => prependTask(scopedSetting(st.scope, st.key)) } def combine[D[_],S](c: Combine[D], f: Results[HLv] => D[S]): Initialize[Task[S]] = @@ -488,7 +483,7 @@ object InputKey apply( AttributeKey[InputTask[T]](label, description, extendScoped(extend1, extendN)) ) def apply[T](akey: AttributeKey[InputTask[T]]): InputKey[T] = - new InputKey[T](akey) + new InputKey[T] { val key = akey; def scope = Scope.ThisScope } } object TaskKey { @@ -499,7 +494,7 @@ object TaskKey apply( AttributeKey[Task[T]](label, description, extendScoped(extend1, extendN)) ) def apply[T](akey: AttributeKey[Task[T]]): TaskKey[T] = - new TaskKey[T](akey) + new TaskKey[T] { val key = akey; def scope = Scope.ThisScope } def local[T: Manifest]: TaskKey[T] = apply[T](AttributeKey.local[Task[T]]) } @@ -512,7 +507,7 @@ object SettingKey apply( AttributeKey[T](label, description, extendScoped(extend1, extendN)) ) def apply[T](akey: AttributeKey[T]): SettingKey[T] = - new SettingKey[T](akey) + new SettingKey[T] { val key = akey; def scope = Scope.ThisScope } def local[T: Manifest]: SettingKey[T] = apply[T](AttributeKey.local[T]) } \ No newline at end of file diff --git a/sbt/package.scala b/sbt/package.scala index 46bfc5a47..e36dfafef 100644 --- a/sbt/package.scala +++ b/sbt/package.scala @@ -4,6 +4,13 @@ package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtra with sbt.impl.DependencyBuilders with sbt.PathExtra with sbt.ProjectExtra with sbt.DependencyFilterExtra with sbt.BuildExtra { + @deprecated("Use SettingKey, which is a drop-in replacement.", "0.11.1") + type ScopedSetting[T] = SettingKey[T] + @deprecated("Use TaskKey, which is a drop-in replacement.", "0.11.1") + type ScopedTask[T] = TaskKey[T] + @deprecated("Use InputKey, which is a drop-in replacement.", "0.11.1") + type ScopedInput[T] = InputKey[T] + type Setting[T] = Project.Setting[T] type ScopedKey[T] = Project.ScopedKey[T] type SettingsDefinition = Project.SettingsDefinition