diff --git a/main/Build.scala b/main/Build.scala index f0928258c..4bd733720 100644 --- a/main/Build.scala +++ b/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 diff --git a/main/Compile.scala b/main/Compile.scala index 564fd9c64..609294e3b 100644 --- a/main/Compile.scala +++ b/main/Compile.scala @@ -8,7 +8,7 @@ package sbt import inc._ import java.io.File -object Compile +object Compiler { val DefaultMaxErrors = 100 diff --git a/main/Console.scala b/main/Console.scala index 9a2863783..41256857f 100644 --- a/main/Console.scala +++ b/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 diff --git a/main/Default.scala b/main/Default.scala index 881e2dc10..41cd9f8e1 100755 --- a/main/Default.scala +++ b/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 (_ ++ _) diff --git a/main/Keys.scala b/main/Keys.scala index e41565c0d..b88709038 100644 --- a/main/Keys.scala +++ b/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") diff --git a/main/Project.scala b/main/Project.scala index 127b8c87e..9198783eb 100644 --- a/main/Project.scala +++ b/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] diff --git a/main/Test.scala b/main/Test.scala index 0ea9ca54d..c776cbae5 100644 --- a/main/Test.scala +++ b/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]) diff --git a/sbt/package.scala b/sbt/package.scala index d0db38a07..57dc4cd08 100644 --- a/sbt/package.scala +++ b/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) } diff --git a/sbt/src/sbt-test/project/flatten/project/Flat.scala b/sbt/src/sbt-test/project/flatten/project/Flat.scala index 87e94c994..af3e6588d 100644 --- a/sbt/src/sbt-test/project/flatten/project/Flat.scala +++ b/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( diff --git a/sbt/src/sbt-test/tests/arguments/build.sbt b/sbt/src/sbt-test/tests/arguments/build.sbt index 1b660861f..5ec40bea1 100644 --- a/sbt/src/sbt-test/tests/arguments/build.sbt +++ b/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") ++ diff --git a/sbt/src/sbt-test/tests/it/project/B.scala b/sbt/src/sbt-test/tests/it/project/B.scala index c9f942424..085637f61 100644 --- a/sbt/src/sbt-test/tests/it/project/B.scala +++ b/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()