put configurations into default build scope

main/Build.scala

@@ -9,7 +9,7 @@ package sbt
 	import classpath.ClasspathUtilities
 	import scala.annotation.tailrec
 	import collection.mutable
-	import Compile.{Compilers,Inputs}
+	import Compiler.{Compilers,Inputs}
 	import Project.{inScope, ScopedKey, ScopeLocal, Setting}
 	import Keys.{appConfiguration, configuration, thisProject, thisProjectRef}
 	import TypeFunctions.{Endo,Id}
@@ -21,7 +21,7 @@ package sbt
 trait Build
 {
 	def projects: Seq[Project]
-	def settings: Seq[Setting[_]] = Default.buildCore
+	def settings: Seq[Setting[_]] = Defaults.buildCore
 }
 trait Plugin
 {
@@ -220,7 +220,7 @@ object Load
 		val loader = getClass.getClassLoader
 		val provider = state.configuration.provider
 		val classpath = provider.mainClasspath ++ provider.scalaProvider.jars
-		val compilers = Compile.compilers(state.configuration, log)
+		val compilers = Compiler.compilers(state.configuration, log)
 		val evalPluginDef = EvaluateTask.evalPluginDef(log) _
 		val delegates = memo(defaultDelegates)
 		val inject: Seq[Project.Setting[_]] = ((appConfiguration in GlobalScope) :== state.configuration) +: EvaluateTask.injectSettings
@@ -516,8 +516,8 @@ object Load
 
 	def build(classpath: Seq[File], sources: Seq[File], target: File, compilers: Compilers, log: Logger): (Inputs, inc.Analysis) =
 	{
-		val inputs = Compile.inputs(classpath, sources, target, Nil, Nil, Nil, Compile.DefaultMaxErrors)(compilers, log)
-		val analysis = Compile(inputs, log)
+		val inputs = Compiler.inputs(classpath, sources, target, Nil, Nil, Nil, Compiler.DefaultMaxErrors)(compilers, log)
+		val analysis = Compiler(inputs, log)
 		(inputs, analysis)
 	}
 
@@ -543,7 +543,7 @@ object Load
 	def discover(analysis: inc.Analysis, subclasses: String*): Seq[String] =
 	{
 		val subclassSet = subclasses.toSet
-		val ds = Discovery(subclassSet, Set.empty)(Test.allDefs(analysis))
+		val ds = Discovery(subclassSet, Set.empty)(Tests.allDefs(analysis))
 		ds.flatMap {
 			case (definition, Discovered(subs,_,_,true)) =>
 				if((subs & subclassSet).isEmpty) Nil else definition.name :: Nil

main/Compile.scala

@@ -8,7 +8,7 @@ package sbt
 	import inc._
 	import java.io.File
 
-object Compile
+object Compiler
 {
 	val DefaultMaxErrors = 100
 

main/Console.scala

@@ -26,10 +26,8 @@ final class Console(compiler: AnalyzingCompiler)
 }
 object Console
 {
-	val SbtInitial = "import sbt._, Process._, current._"
-	
 	def apply(conf: build.Compile)(implicit log: Logger): Console = new Console( compiler(conf) )
-	def apply(conf: Compile.Inputs): Console = new Console( conf.compilers.scalac )
+	def apply(conf: Compiler.Inputs): Console = new Console( conf.compilers.scalac )
 
 	def compiler(conf: build.Compile)(implicit log: Logger): AnalyzingCompiler =
 	{
@@ -41,7 +39,7 @@ object Console
 		val extracted = Project extract state
 		val bindings = ("state" -> state) :: ("extracted" -> extracted ) :: Nil
 		val unit = extracted.currentUnit
-		val compiler = Compile.compilers(state.configuration, log).scalac
+		val compiler = Compiler.compilers(state.configuration, log).scalac
 		val imports = Load.getImports(unit.unit) ++ Load.importAll(bindings.map(_._1))
 		val importString = imports.mkString("", ";\n", ";\n\n")
 		val initCommands = importString + extra

main/Default.scala

@@ -17,7 +17,7 @@ package sbt
 	import descriptor.ModuleDescriptor, id.ModuleRevisionId
 	import Types._
 
-object Default
+object Defaults
 {
 	import Path._
 	import GlobFilter._
@@ -106,7 +106,7 @@ object Default
 	)
 
 	def compileBase = Seq(
-		compilers <<= (scalaInstance, appConfiguration, streams) map { (si, app, s) => Compile.compilers(si)(app, s.log) },
+		compilers <<= (scalaInstance, appConfiguration, streams) map { (si, app, s) => Compiler.compilers(si)(app, s.log) },
 		javacOptions in GlobalScope :== Nil,
 		scalacOptions in GlobalScope :== Nil,
 		scalaInstance <<= (appConfiguration, scalaVersion){ (app, version) => ScalaInstance(version, app.provider.scalaProvider.launcher) },
@@ -172,16 +172,16 @@ object Default
 			frameworks.flatMap(f => f.create(loader, s.log).map( x => (f,x)).toIterable).toMap
 		},
 		definedTests <<= (loadedTestFrameworks, compile, streams) map { (frameworkMap, analysis, s) =>
-			val tests = Test.discover(frameworkMap.values.toSeq, analysis, s.log)._1
+			val tests = Tests.discover(frameworkMap.values.toSeq, analysis, s.log)._1
 			IO.writeLines(s.text(CompletionsID), tests.map(_.name).distinct)
 			tests
 		},
 		testListeners <<= (streams in test) map ( s => TestLogger(s.log) :: Nil ),
-		testOptions <<= testListeners map { listeners => Test.Listeners(listeners) :: Nil },
+		testOptions <<= testListeners map { listeners => Tests.Listeners(listeners) :: Nil },
 		executeTests <<= (streams in test, loadedTestFrameworks, testOptions, testLoader, definedTests) flatMap {
-			(s, frameworkMap, options, loader, discovered) => Test(frameworkMap, loader, discovered, options, s.log)
+			(s, frameworkMap, options, loader, discovered) => Tests(frameworkMap, loader, discovered, options, s.log)
 		},
-		test <<= (executeTests, streams) map { (results, s) => Test.showResults(s.log, results) },
+		test <<= (executeTests, streams) map { (results, s) => Tests.showResults(s.log, results) },
 		testOnly <<= testOnlyTask
 	)
 
@@ -189,9 +189,9 @@ object Default
 	InputTask(resolvedScoped(testOnlyParser)) ( result =>  
 		(streams, loadedTestFrameworks, testOptions, testLoader, definedTests, result) flatMap {
 			case (s, frameworks, opts, loader, discovered, (tests, frameworkOptions)) =>
-				val modifiedOpts = Test.Filter(if(tests.isEmpty) _ => true else tests.toSet ) +: Test.Argument(frameworkOptions : _*) +: opts
-				Test(frameworks, loader, discovered, modifiedOpts, s.log) map { results =>
-					Test.showResults(s.log, results)
+				val modifiedOpts = Tests.Filter(if(tests.isEmpty) _ => true else tests.toSet ) +: Tests.Argument(frameworkOptions : _*) +: opts
+				Tests(frameworks, loader, discovered, modifiedOpts, s.log) map { results =>
+					Tests.showResults(s.log, results)
 				}
 		}
 	)
@@ -279,7 +279,7 @@ object Default
 	def mainRunTask = run <<= runTask(fullClasspath in Configurations.Runtime, mainClass in run, runner in run)
 
 	def discoverMainClasses(analysis: inc.Analysis): Seq[String] =
-		Discovery.applications(Test.allDefs(analysis)) collect { case (definition, discovered) if(discovered.hasMain) => definition.name }
+		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 consoleTask: Initialize[Task[Unit]] = consoleTask(fullClasspath, console)
@@ -290,14 +290,14 @@ object Default
 			println()
 	}
 	
-	def compileTask = (compileInputs, streams) map { (i,s) => Compile(i,s.log) }
+	def compileTask = (compileInputs, streams) map { (i,s) => Compiler(i,s.log) }
 	def compileInputsTask =
 		(dependencyClasspath, sources, javaSourceRoots, compilers, javacOptions, scalacOptions, cacheDirectory, classDirectory, streams) map {
 		(cp, srcs, javaRoots, cs, javacOpts, scalacOpts, cacheDir, classes, s) =>
 			val classpath = classes +: data(cp)
 			val analysis = analysisMap(cp)
 			val cache = cacheDir / "compile"
-			Compile.inputs(classpath, srcs, classes, scalacOpts, javacOpts, javaRoots, analysis, cache, 100)(cs, s.log)
+			Compiler.inputs(classpath, srcs, classes, scalacOpts, javacOpts, javaRoots, analysis, cache, 100)(cs, s.log)
 		}
 
 	def copyResourcesTask =
@@ -375,7 +375,7 @@ object Classpaths
 		import GlobFilter._
 		import Keys._
 		import Scope.ThisScope
-		import Default._
+		import Defaults._
 		import Attributed.{blank, blankSeq}
 
 	def concat[T](a: ScopedTaskable[Seq[T]], b: ScopedTaskable[Seq[T]]): Initialize[Task[Seq[T]]] = (a,b) map (_ ++ _)

main/Keys.scala

@@ -65,7 +65,7 @@ object Keys
 	val scalacOptions = SettingKey[Seq[String]]("scalac-options")
 	val javacOptions = SettingKey[Seq[String]]("javac-options")
 	val initialCommands = SettingKey[String]("initial-commands")
-	val compileInputs = TaskKey[Compile.Inputs]("compile-inputs")
+	val compileInputs = TaskKey[Compiler.Inputs]("compile-inputs")
 	val scalaInstance = SettingKey[ScalaInstance]("scala-instance")
 	val scalaVersion = SettingKey[String]("scala-version")
 
@@ -76,7 +76,7 @@ object Keys
 	val consoleQuick = TaskKey[Unit]("console-quick")
 	val consoleProject = TaskKey[Unit]("console-project")
 	val compile = TaskKey[Analysis]("compile")
-	val compilers = TaskKey[Compile.Compilers]("compilers")
+	val compilers = TaskKey[Compiler.Compilers]("compilers")
 	val doc = TaskKey[File]("doc")
 	val copyResources = TaskKey[Traversable[(File,File)]]("copy-resources")
 	val resources = TaskKey[Seq[File]]("resources")
@@ -109,7 +109,7 @@ object Keys
 	val testLoader = TaskKey[ClassLoader]("test-loader")
 	val loadedTestFrameworks = TaskKey[Map[TestFramework,Framework]]("loaded-test-frameworks")
 	val definedTests = TaskKey[Seq[TestDefinition]]("defined-tests")
-	val executeTests = TaskKey[Test.Output]("execute-tests")
+	val executeTests = TaskKey[Tests.Output]("execute-tests")
 	val test = TaskKey[Unit]("test")
 	val testOnly = InputKey[Unit]("test-only")
 	val testOptions = TaskKey[Seq[TestOption]]("test-options")

main/Project.scala

@@ -60,7 +60,7 @@ final case class Extracted(structure: Load.BuildStructure, session: SessionSetti
 
 object Project extends Init[Scope]
 {
-	def defaultSettings: Seq[Setting[_]] = Default.defaultSettings
+	def defaultSettings: Seq[Setting[_]] = Defaults.defaultSettings
 
 	sealed trait ClasspathDep[PR <: ProjectReference] { def project: PR; def configuration: Option[String] }
 	final case class ResolvedClasspathDependency(project: ProjectRef, configuration: Option[String]) extends ClasspathDep[ProjectRef]

main/Test.scala

@@ -16,7 +16,7 @@ package sbt
 	import java.io.File
 
 sealed trait TestOption
-object Test
+object Tests
 {
 	type Output = (TestResult.Value, Map[String,TestResult.Value])
 	

sbt/package.scala

@@ -11,6 +11,18 @@ package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtr
 		if(m.isDefined) Some(m.get) else None
 	def uri(s: String): URI = new URI(s)
 	def file(s: String): File = new File(s)
+	
+		import sbt.{Configurations => C}
+	def Compile = C.Compile
+	def Test = C.Test
+	def Runtime = C.Runtime
+	def IntegrationTest = C.IntegrationTest
+	def Default = C.Default
+	def Javadoc = C.Javadoc
+	def Sources = C.Sources
+	def Provided = C.Provided
+	def System = C.System
+	def Optional = C.Optional
 
 	implicit def globFilter(expression: String): NameFilter = GlobFilter(expression)
 }

sbt/src/sbt-test/project/flatten/project/Flat.scala

@@ -6,7 +6,7 @@ object Flat extends Build
 {
 	lazy val projects = Seq(root)
 	lazy val root = Project("root", file("."),
-		settings = Default.defaultSettings ++ forConfig(Compile, "src") ++ forConfig(Test, "test-src") ++ baseSettings
+		settings = Defaults.defaultSettings ++ forConfig(Compile, "src") ++ forConfig(Test, "test-src") ++ baseSettings
 	)
 
 	def baseSettings = Seq(

sbt/src/sbt-test/tests/arguments/build.sbt

@@ -1,7 +1,7 @@
 libraryDependencies += "org.scalatest" % "scalatest" % "1.3"
 
 testOptions in Configurations.Test ++= {
-	def args(path: String, args: String*): Seq[TestOption] = if(file(path).exists) Test.Argument(args : _*) :: Nil else Nil
+	def args(path: String, args: String*): Seq[TestOption] = if(file(path).exists) Tests.Argument(args : _*) :: Nil else Nil
 //
 	args("success1", "-n", "test2 test3") ++
 	args("success2", "-n", "test2") ++

sbt/src/sbt-test/tests/it/project/B.scala

@@ -8,7 +8,7 @@ object B extends Build
 		Project("root", file("."))
 			.configs( it )
 			.settings( LibraryDependencies += specs )
-			.settings( Default.itSettings : _*)
+			.settings( Defaults.itSettings : _*)
 
 	lazy val it = Configurations.IntegrationTest
 	lazy val specs = "org.scala-tools.testing" %% "specs" % "1.6.7.2" % "it,test" intransitive()