luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

drop more migrated pending items

This commit is contained in:
Mark Harrah 2011-04-20 18:31:37 -04:00
parent defd1ee0d4
commit aba1dd96c9
2 changed files with 0 additions and 630 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

342
sbt_pending/src/main/scala/sbt/DefaultProject.scala
View File

@ -20,62 +20,6 @@ import scala.collection.mutable.ListBuffer
* options, and configuration. */ * options, and configuration. */
abstract class BasicScalaProject extends ScalaProject with BasicDependencyProject with ScalaPaths abstract class BasicScalaProject extends ScalaProject with BasicDependencyProject with ScalaPaths
{ {
/** The explicitly specified class to be run by the 'run' action.
* See http://code.google.com/p/simple-build-tool/wiki/RunningProjectCode for details.*/
def mainClass: Option[String] = None
/** Gets the main class to use. This is used by package and run to determine which main
* class to run or include as the Main-Class attribute.
* If `mainClass` is explicitly specified, it is used. Otherwise, the main class is selected from
* the classes with a main method as automatically detected by the analyzer plugin.
* `promptIfMultipleChoices` controls the behavior when multiple main classes are detected.
* If true, it prompts the user to select which main class to use. If false, it prints a warning
* and returns no main class.*/
def getMainClass(promptIfMultipleChoices: Boolean): Option[String] =
getMainClass(promptIfMultipleChoices, mainCompileConditional, mainClass)
def getMainClass(promptIfMultipleChoices: Boolean, compileConditional: CompileConditional, explicit: Option[String]): Option[String] =
explicit orElse
{
val applications = compileConditional.analysis.allApplications.toList
impl.SelectMainClass(promptIfMultipleChoices, applications) orElse
{
if(!promptIfMultipleChoices && !applications.isEmpty)
warnMultipleMainClasses(log)
None
}
}
def testMainClass: Option[String] = None
def getTestMainClass(promptIfMultipleChoices: Boolean): Option[String] =
getMainClass(promptIfMultipleChoices, testCompileConditional, testMainClass)
/** Specifies the value of the `Class-Path` attribute in the manifest of the main jar. */
def manifestClassPath: Option[String] = None
def dependencies = info.dependencies ++ subProjects.values.toList
lazy val mainCompileConditional = new CompileConditional(mainCompileConfiguration, buildCompiler)
lazy val testCompileConditional = new CompileConditional(testCompileConfiguration, buildCompiler)
def compileOrder = CompileOrder.Mixed
/** The main artifact produced by this project. To redefine the main artifact, override `defaultMainArtifact`
* Additional artifacts are defined by `val`s of type `Artifact`.*/
lazy val mainArtifact = defaultMainArtifact
/** Defines the default main Artifact assigned to `mainArtifact`. By default, this is a jar file with name given
* by `artifactID`.*/
protected def defaultMainArtifact = Artifact(artifactID, "jar", "jar")
import Project._
/** The options provided to the 'compile' action to pass to the Scala compiler.*/
def compileOptions: Seq[CompileOption] = Deprecation :: Nil
/** The options provided to the 'console' action to pass to the Scala interpreter.*/
def consoleOptions: Seq[CompileOption] = compileOptions
/** The options provided to the 'compile' action to pass to the Java compiler. */
def javaCompileOptions: Seq[JavaCompileOption] = Nil
/** The options provided to the 'test-compile' action, defaulting to those for the 'compile' action.*/
def testCompileOptions: Seq[CompileOption] = compileOptions
/** The options provided to the 'test-compile' action to pass to the Java compiler. */
def testJavaCompileOptions: Seq[JavaCompileOption] = javaCompileOptions
/** The options provided to the 'doc' and 'docTest' actions.*/ /** The options provided to the 'doc' and 'docTest' actions.*/
def documentOptions: Seq[ScaladocOption] = def documentOptions: Seq[ScaladocOption] =
documentTitle(name + " " + version + " API") :: documentTitle(name + " " + version + " API") ::
@ -87,15 +31,6 @@ abstract class BasicScalaProject extends ScalaProject with BasicDependencyProjec
TestListeners(testListeners) :: TestListeners(testListeners) ::
TestFilter(includeTest) :: TestFilter(includeTest) ::
Nil Nil
/** The options provided to the clean action. You can add files to be removed and files to be preserved here.*/
def cleanOptions: Seq[CleanOption] =
ClearAnalysis(mainCompileConditional.analysis) ::
ClearAnalysis(testCompileConditional.analysis) ::
historyPath.map(history => Preserve(history)).toList
def packageOptions: Seq[PackageOption] =
manifestClassPath.map(cp => ManifestAttributes( (Attributes.Name.CLASS_PATH, cp) )).toList :::
getMainClass(false).map(MainClass(_)).toList
private def succeededTestPath = testAnalysisPath / "succeeded-tests" private def succeededTestPath = testAnalysisPath / "succeeded-tests"
protected final def quickOptions(failedOnly: Boolean) = protected final def quickOptions(failedOnly: Boolean) =
@ -105,179 +40,6 @@ abstract class BasicScalaProject extends ScalaProject with BasicDependencyProjec
TestFilter(new impl.TestQuickFilter(analysis, failedOnly, path, log)) :: TestListeners(new impl.TestStatusReporter(path, log) :: Nil) :: Nil TestFilter(new impl.TestQuickFilter(analysis, failedOnly, path, log)) :: TestListeners(new impl.TestStatusReporter(path, log) :: Nil) :: Nil
} }
def consoleInit = ""
protected def includeTest(test: String): Boolean = true
/** This is called to create the initial directories when a user makes a new project from
* sbt.*/
override final def initializeDirectories()
{
FileUtilities.createDirectories(directoriesToCreate, log) match
{
case Some(errorMessage) => log.error("Could not initialize directory structure: " + errorMessage)
case None => log.success("Successfully initialized directory structure.")
}
}
import Configurations._
/** The managed configuration to use when determining the classpath for a Scala interpreter session.*/
def consoleConfiguration = Test
/** A PathFinder that provides the classpath to pass to scaladoc. It is the same as the compile classpath
* by default. */
def docClasspath = compileClasspath
/** A PathFinder that provides the classpath to pass to the compiler.*/
def compileClasspath = fullClasspath(Compile) +++ optionalClasspath +++ providedClasspath
/** A PathFinder that provides the classpath to use when unit testing.*/
def testClasspath = fullClasspath(Test) +++ optionalClasspath +++ providedClasspath
/** A PathFinder that provides the classpath to use when running the class specified by 'getMainClass'.*/
def runClasspath = fullClasspath(Runtime) +++ optionalClasspath +++ providedClasspath
/** A PathFinder that provides the classpath to use for a Scala interpreter session.*/
def consoleClasspath = fullClasspath(consoleConfiguration) +++ optionalClasspath +++ providedClasspath
/** A PathFinder that corresponds to Maven's optional scope. It includes any managed libraries in the
* 'optional' configuration for this project only.*/
def optionalClasspath = managedClasspath(Optional)
/** A PathFinder that corresponds to Maven's provided scope. It includes any managed libraries in the
* 'provided' configuration for this project only.*/
def providedClasspath = managedClasspath(Provided)
/** A PathFinder that contains the jars that should be included in a comprehensive package. This is
* by default the 'runtime' classpath excluding the 'provided' classpath.*/
def publicClasspath = runClasspath --- providedClasspath
/** This returns the unmanaged classpath for only this project for the given configuration. It by
* default includes the main compiled classes for this project and the libraries in this project's
* unmanaged library directory (lib) and the managed directory for the specified configuration. It
* also adds the resource directories appropriate to the configuration.
* The Provided and Optional configurations are treated specially; they are empty
* by default.*/
def fullUnmanagedClasspath(config: Configuration) =
{
config match
{
case CompilerPlugin => unmanagedClasspath
case Runtime => runUnmanagedClasspath
case Test => testUnmanagedClasspath
case Provided | Optional => Path.emptyPathFinder
case _ => mainUnmanagedClasspath
}
}
/** The unmanaged base classpath. By default, the unmanaged classpaths for test and run include this classpath. */
protected def mainUnmanagedClasspath = mainCompilePath +++ mainResourcesOutputPath +++ unmanagedClasspath
/** The unmanaged classpath for the run configuration. By default, it includes the base classpath returned by
* `mainUnmanagedClasspath`.*/
protected def runUnmanagedClasspath = mainUnmanagedClasspath +++ mainDependencies.scalaCompiler
/** The unmanaged classpath for the test configuration. By default, it includes the run classpath, which includes the base
* classpath returned by `mainUnmanagedClasspath`.*/
protected def testUnmanagedClasspath = testCompilePath +++ testResourcesOutputPath +++ testDependencies.scalaCompiler +++ runUnmanagedClasspath
/** An analysis of the jar dependencies of the main Scala sources. It is only valid after main source compilation.
* See the LibraryDependencies class for details. */
final def mainDependencies = new LibraryDependencies(this, mainCompileConditional)
/** An analysis of the jar dependencies of the test Scala sources. It is only valid after test source compilation.
* See the LibraryDependencies class for details. */
final def testDependencies = new LibraryDependencies(this, testCompileConditional)
/** The list of test frameworks to use for testing. Note that adding frameworks to this list
* for an active project currently requires an explicit 'clean' to properly update the set of tests to
* run*/
def testFrameworks: Seq[TestFramework] =
{
import TestFrameworks.{JUnit, ScalaCheck, ScalaTest, Specs, ScalaCheckCompat, ScalaTestCompat, SpecsCompat}
ScalaCheck :: Specs :: ScalaTest :: ScalaCheckCompat :: ScalaTestCompat :: SpecsCompat :: JUnit :: Nil
}
/** The list of listeners for testing. */
def testListeners: Seq[TestReportListener] = TestLogger(log) :: Nil
def mainLabel = "main"
def testLabel = "test"
def mainCompileConfiguration: CompileConfiguration = new MainCompileConfig
def testCompileConfiguration: CompileConfiguration = new TestCompileConfig
abstract class BaseCompileConfig extends CompileConfiguration
{
def log = BasicScalaProject.this.log
def projectPath = info.projectPath
def baseCompileOptions: Seq[CompileOption]
def options = optionsAsString(baseCompileOptions.filter(!_.isInstanceOf[MaxCompileErrors]))
def maxErrors = maximumErrors(baseCompileOptions)
def compileOrder = BasicScalaProject.this.compileOrder
protected def getFingerprints(frameworks: Seq[TestFramework]): Fingerprints =
{
import org.scalatools.testing.{SubclassFingerprint, AnnotatedFingerprint}
val (loader, tempDir) = TestFramework.createTestLoader(classpath.get, buildScalaInstance)
xsbt.FileUtilities.delete(tempDir.asFile)
val annotations = new ListBuffer[String]
val superclasses = new ListBuffer[String]
frameworks flatMap { _.create(loader, log) } flatMap(TestFramework.getTests) foreach {
case s: SubclassFingerprint => superclasses += s.superClassName
case a: AnnotatedFingerprint => annotations += a.annotationName
case _ => ()
}
Fingerprints(superclasses.toList, annotations.toList)
}
}
class MainCompileConfig extends BaseCompileConfig
{
def baseCompileOptions = compileOptions
def label = mainLabel
def sourceRoots = mainSourceRoots
def sources = mainSources
def outputDirectory = mainCompilePath
def classpath = compileClasspath
def analysisPath = mainAnalysisPath
def fingerprints = Fingerprints(Nil, Nil)
def javaOptions = javaOptionsAsString(javaCompileOptions)
}
class TestCompileConfig extends BaseCompileConfig
{
def baseCompileOptions = testCompileOptions
def label = testLabel
def sourceRoots = testSourceRoots
def sources = testSources
def outputDirectory = testCompilePath
def classpath = testClasspath
def analysisPath = testAnalysisPath
def fingerprints = getFingerprints(testFrameworks)
def javaOptions = javaOptionsAsString(testJavaCompileOptions)
}
/** Configures forking the compiler and runner. Use ForkScalaCompiler, ForkScalaRun or mix together.*/
def fork: Option[ForkScala] = None
def forkRun: Option[ForkScala] = forkRun(None, Nil)
def forkRun(workingDirectory: File): Option[ForkScala] = forkRun(Some(workingDirectory), Nil)
def forkRun(jvmOptions: Seq[String]): Option[ForkScala] = forkRun(None, jvmOptions)
def forkRun(workingDirectory0: Option[File], jvmOptions: Seq[String]): Option[ForkScala] =
{
val si = buildScalaInstance
Some(new ForkScalaRun {
override def scalaJars = si.libraryJar :: si.compilerJar :: Nil
override def workingDirectory: Option[File] = workingDirectory0
override def runJVMOptions: Seq[String] = jvmOptions
})
}
private def doCompile(conditional: CompileConditional) = conditional.run
implicit def defaultRunner: ScalaRun =
{
fork match
{
case Some(fr: ForkScalaRun) => new ForkRun(fr)
case _ => new Run(buildScalaInstance)
}
}
def basicConsoleTask = consoleTask(consoleClasspath, consoleOptions, consoleInit)
protected def runTask(mainClass: String): MethodTask = task { args => runTask(Some(mainClass), runClasspath, args) dependsOn(compile, copyResources) }
protected def compileAction = task { doCompile(mainCompileConditional) } describedAs MainCompileDescription
protected def testCompileAction = task { doCompile(testCompileConditional) } dependsOn compile describedAs TestCompileDescription
protected def cleanAction = cleanTask(outputPath, cleanOptions) describedAs CleanDescription
protected def testRunAction = task { args => runTask(getTestMainClass(true), testClasspath, args) dependsOn(testCompile, copyResources) } describedAs TestRunDescription
protected def runAction = task { args => runTask(getMainClass(true), runClasspath, args) dependsOn(compile, copyResources) } describedAs RunDescription
protected def consoleQuickAction = basicConsoleTask describedAs ConsoleQuickDescription
protected def consoleAction = basicConsoleTask.dependsOn(testCompile, copyResources, copyTestResources) describedAs ConsoleDescription
protected def docAction = scaladocTask(mainLabel, mainSources, mainDocPath, docClasspath, documentOptions).dependsOn(compile) describedAs DocDescription
protected def docTestAction = scaladocTask(testLabel, testSources, testDocPath, docClasspath, documentOptions).dependsOn(testCompile) describedAs TestDocDescription
protected def testAction = defaultTestTask(testOptions) protected def testAction = defaultTestTask(testOptions)
protected def testOnlyAction = testOnlyTask(testOptions) protected def testOnlyAction = testOnlyTask(testOptions)
@ -289,74 +51,15 @@ abstract class BasicScalaProject extends ScalaProject with BasicDependencyProjec
protected def defaultTestTask(testOptions: => Seq[TestOption]) = protected def defaultTestTask(testOptions: => Seq[TestOption]) =
testTask(testFrameworks, testClasspath, testCompileConditional.analysis, testOptions).dependsOn(testCompile, copyResources, copyTestResources) describedAs TestDescription testTask(testFrameworks, testClasspath, testCompileConditional.analysis, testOptions).dependsOn(testCompile, copyResources, copyTestResources) describedAs TestDescription
override def packageToPublishActions: Seq[ManagedTask] = `package` :: Nil
protected def packageAction = packageTask(packagePaths, jarPath, packageOptions).dependsOn(compile) describedAs PackageDescription
protected def packageTestAction = packageTask(packageTestPaths, packageTestJar).dependsOn(testCompile) describedAs TestPackageDescription
protected def packageDocsAction = packageTask(mainDocPath ###, packageDocsJar, Recursive).dependsOn(doc) describedAs DocPackageDescription
protected def packageSrcAction = packageTask(packageSourcePaths, packageSrcJar) describedAs SourcePackageDescription
protected def packageTestSrcAction = packageTask(packageTestSourcePaths, packageTestSrcJar) describedAs TestSourcePackageDescription
protected def packageProjectAction = zipTask(packageProjectPaths, packageProjectZip) describedAs ProjectPackageDescription
protected def docAllAction = (doc && docTest) describedAs DocAllDescription protected def docAllAction = (doc && docTest) describedAs DocAllDescription
protected def packageAllAction = task { None} dependsOn(`package`, packageTest, packageSrc, packageTestSrc, packageDocs) describedAs PackageAllDescription protected def packageAllAction = task { None} dependsOn(`package`, packageTest, packageSrc, packageTestSrc, packageDocs) describedAs PackageAllDescription
protected def graphSourcesAction = graphSourcesTask(graphSourcesPath, mainSourceRoots, mainCompileConditional.analysis).dependsOn(compile) protected def graphSourcesAction = graphSourcesTask(graphSourcesPath, mainSourceRoots, mainCompileConditional.analysis).dependsOn(compile)
protected def graphPackagesAction = graphPackagesTask(graphPackagesPath, mainSourceRoots, mainCompileConditional.analysis).dependsOn(compile) protected def graphPackagesAction = graphPackagesTask(graphPackagesPath, mainSourceRoots, mainCompileConditional.analysis).dependsOn(compile)
protected def incrementVersionAction = task { incrementVersionNumber(); None } describedAs IncrementVersionDescription protected def incrementVersionAction = task { incrementVersionNumber(); None } describedAs IncrementVersionDescription
protected def releaseAction = (test && packageAll && incrementVersion) describedAs ReleaseDescription
protected def copyResourcesAction = syncPathsTask(mainResources, mainResourcesOutputPath) describedAs CopyResourcesDescription
protected def copyTestResourcesAction = syncPathsTask(testResources, testResourcesOutputPath) describedAs CopyTestResourcesDescription
lazy val compile = compileAction
lazy val testCompile = testCompileAction
lazy val clean = cleanAction
lazy val run = runAction
lazy val consoleQuick = consoleQuickAction
lazy val console = consoleAction
lazy val doc = docAction
lazy val docTest = docTestAction
lazy val test = testAction
lazy val testRun = testRunAction
lazy val `package` = packageAction
lazy val packageTest = packageTestAction
lazy val packageDocs = packageDocsAction
lazy val packageSrc = packageSrcAction
lazy val packageTestSrc = packageTestSrcAction
lazy val packageProject = packageProjectAction
lazy val docAll = docAllAction
lazy val packageAll = packageAllAction
lazy val graphSrc = graphSourcesAction
lazy val graphPkg = graphPackagesAction
lazy val incrementVersion = incrementVersionAction
lazy val release = releaseAction
lazy val copyResources = copyResourcesAction
lazy val copyTestResources = copyTestResourcesAction
lazy val testQuick = testQuickAction
lazy val testFailed = testFailedAction
lazy val testOnly = testOnlyAction
lazy val javap = javapTask(runClasspath, mainCompileConditional, mainCompilePath) lazy val javap = javapTask(runClasspath, mainCompileConditional, mainCompilePath)
lazy val testJavap = javapTask(testClasspath, testCompileConditional, testCompilePath) lazy val testJavap = javapTask(testClasspath, testCompileConditional, testCompilePath)
def jarsOfProjectDependencies = Path.lazyPathFinder {
topologicalSort.dropRight(1) flatMap { p =>
p match
{
case bpp: BasicScalaPaths => List(bpp.jarPath)
case _ => Nil
}
}
}
override def deliverScalaDependencies: Iterable[ModuleID] =
{
val snapshot = mainDependencies.snapshot
mapScalaModule(snapshot.scalaLibrary, ScalaArtifacts.LibraryID) ++
mapScalaModule(snapshot.scalaCompiler, ScalaArtifacts.CompilerID)
}
override def watchPaths = mainSources +++ testSources +++ mainResources +++ testResources
private def mapScalaModule(in: Iterable[File], id: String) = in.map(jar => ModuleID(ScalaArtifacts.Organization, id, buildScalaVersion) from(jar.toURI.toURL.toString))
} }
abstract class BasicWebScalaProject extends BasicScalaProject with WebScalaProject with WebScalaPaths abstract class BasicWebScalaProject extends BasicScalaProject with WebScalaProject with WebScalaPaths
{ p => { p =>
@ -512,48 +215,3 @@ object BasicWebScalaProject
val JettyReloadDescription = val JettyReloadDescription =
"Forces a reload of a web application running in a Jetty server started by 'jetty-run'. Does nothing if Jetty is not running." "Forces a reload of a web application running in a Jetty server started by 'jetty-run'. Does nothing if Jetty is not running."
} }
/** Analyzes the dependencies of a project after compilation. All methods except `snapshot` return a
* `PathFinder`. The underlying calculations are repeated for each call to PathFinder.get. */
final class LibraryDependencies(project: Project, conditional: CompileConditional) extends NotNull
{
/** Library jars located in unmanaged or managed dependency paths.*/
def libraries: PathFinder = Path.finder(snapshot.libraries)
/** Library jars located outside of the project.*/
def external: PathFinder = Path.finder(snapshot.external)
/** The Scala library jar.*/
def scalaLibrary: PathFinder = Path.finder(snapshot.scalaLibrary)
/** The Scala compiler jar.*/
def scalaCompiler: PathFinder = Path.finder(snapshot.scalaCompiler)
/** All jar dependencies.*/
def all: PathFinder = Path.finder(snapshot.all)
/** The Scala library and compiler jars.*/
def scalaJars: PathFinder = Path.finder(snapshot.scalaJars)
/** Returns an object that has all analyzed dependency information frozen at the time of this method call. */
def snapshot = new Dependencies
private def rootProjectDirectory = project.rootProject.info.projectPath
final class Dependencies
{
import LibraryDependencies._
val all = conditional.analysis.allExternals.filter(ClasspathUtilities.isArchive).map(_.getAbsoluteFile)
private[this] val (internal, externalAll) = all.toList.partition(jar => Path.relativize(rootProjectDirectory, jar).isDefined)
private[this] val (bootScalaJars, librariesNoScala) = internal.partition(isScalaJar)
private[this] val (externalScalaJars, externalNoScala) = externalAll.partition(isScalaJar)
val scalaJars = externalScalaJars ::: bootScalaJars
val (scalaLibrary, scalaCompiler) = scalaJars.partition(isScalaLibraryJar)
def external = externalNoScala
def libraries = librariesNoScala
}
}
private object LibraryDependencies
{
private def ScalaLibraryPrefix = ScalaArtifacts.LibraryID
private def ScalaCompilerPrefix = ScalaArtifacts.CompilerID
private def ScalaJarPrefixes = List(ScalaCompilerPrefix, ScalaLibraryPrefix)
private def isScalaJar(file: File) = ClasspathUtilities.isArchive(file) && ScalaJarPrefixes.exists(isNamed(file))
private def isScalaLibraryJar(file: File) = isNamed(file)(ScalaLibraryPrefix)
private def isNamed(file: File)(name: String) = file.getName.startsWith(name)
}

288
sbt_pending/src/main/scala/sbt/ScalaProject.scala
View File

@ -8,132 +8,6 @@ import java.io.File
import java.util.jar.{Attributes, Manifest} import java.util.jar.{Attributes, Manifest}
import scala.collection.mutable.ListBuffer import scala.collection.mutable.ListBuffer
trait Cleanable extends Project
{
trait CleanOption extends ActionOption
case class ClearAnalysis(analysis: TaskAnalysis[_, _, _]) extends CleanOption
case class Preserve(paths: PathFinder) extends CleanOption
def cleanTask(paths: PathFinder, options: CleanOption*): Task =
cleanTask(paths, options)
def cleanTask(paths: PathFinder, options: => Seq[CleanOption]): Task =
task
{
val cleanOptions = options
val preservePaths = for(Preserve(preservePaths) <- cleanOptions; toPreserve <- preservePaths.get) yield toPreserve
Control.thread(FileUtilities.preserve(preservePaths, log))
{ preserved =>
val pathClean = FileUtilities.clean(paths.get, log)
for(ClearAnalysis(analysis) <- cleanOptions)
{
analysis.clear()
analysis.save()
}
val restored = preserved.restore(log)
pathClean orElse restored
}
}
lazy val cleanPlugins = cleanTask(info.pluginsOutputPath +++ info.pluginsManagedSourcePath +++ info.pluginsManagedDependencyPath)
}
trait SimpleScalaProject extends ExecProject with Cleanable
{
def errorTask(message: String) = task{ Some(message) }
case class CompileOption(val asString: String) extends ActionOption
case class JavaCompileOption(val asString: String) extends ActionOption
def compileOptions(asString: String*): Seq[CompileOption] = asString.map(CompileOption.apply)
def javaCompileOptions(asString: String*): Seq[JavaCompileOption] = asString.map(JavaCompileOption.apply)
val Deprecation = CompileOption(CompileOptions.Deprecation)
val ExplainTypes = CompileOption("-explaintypes")
val Optimize = CompileOption("-optimise")
def Optimise = Optimize
val Verbose = CompileOption(CompileOptions.Verbose)
val Unchecked = CompileOption(CompileOptions.Unchecked)
val DisableWarnings = CompileOption("-nowarn")
def target(target: Target.Value) = CompileOption("-target:" + target)
object Target extends Enumeration
{
val Java1_5 = Value("jvm-1.5")
val Java1_4 = Value("jvm-1.4")
val Msil = Value("msil")
}
}
trait ScalaProject extends SimpleScalaProject with FileTasks with MultiTaskProject with Exec
{
import ScalaProject._
final case class MaxCompileErrors(val value: Int) extends CompileOption("") with ScaladocOption { def asList = Nil }
trait PackageOption extends ActionOption
trait TestOption extends ActionOption
final case class TestSetup(setup: ClassLoader => Unit) extends TestOption
object TestSetup {
def apply(setup: () => Unit) = new TestSetup(_ => setup())
}
final case class TestCleanup(cleanup: ClassLoader => Unit) extends TestOption
object TestCleanup {
def apply(setup: () => Unit) = new TestCleanup(_ => setup())
}
case class ExcludeTests(tests: Iterable[String]) extends TestOption
case class TestListeners(listeners: Iterable[TestReportListener]) extends TestOption
case class TestFilter(filterTest: String => Boolean) extends TestOption
// args for all frameworks
def TestArgument(args: String*): TestArgument = TestArgument(None, args.toList)
// args for a particular test framework
def TestArgument(tf: TestFramework, args: String*): TestArgument = TestArgument(Some(tf), args.toList)
// None means apply to all, Some(tf) means apply to a particular framework only.
case class TestArgument(framework: Option[TestFramework], args: List[String]) extends TestOption
case class JarManifest(m: Manifest) extends PackageOption
{
assert(m != null)
}
case class MainClass(mainClassName: String) extends PackageOption
case class ManifestAttributes(attributes: (Attributes.Name, String)*) extends PackageOption
case object Recursive extends PackageOption
def ManifestAttributes(attributes: (String, String)*): ManifestAttributes =
{
val converted = for( (name,value) <- attributes ) yield (new Attributes.Name(name), value)
new ManifestAttributes(converted : _*)
}
trait ScaladocOption extends ActionOption
{
def asList: List[String]
}
case class SimpleDocOption(optionValue: String) extends ScaladocOption
{
def asList = List(optionValue)
}
case class CompoundDocOption(label: String, value: String) extends ScaladocOption
{
def asList = List(label, value)
}
val LinkSource = SimpleDocOption("-linksource")
val NoComment = SimpleDocOption("-nocomment")
def access(access: Access.Value) = SimpleDocOption("-access:" + access)
def documentBottom(bottomText: String) = CompoundDocOption("-bottom", bottomText)
def documentCharset(charset: String) = CompoundDocOption("-charset", charset)
def documentTitle(title: String) = CompoundDocOption(if(isScala27) "-doctitle" else "-doc-title", title)
def documentFooter(footerText: String) = CompoundDocOption("-footer", footerText)
def documentHeader(headerText: String) = CompoundDocOption("-header", headerText)
def stylesheetFile(path: Path) = CompoundDocOption("-stylesheetfile", path.asFile.getAbsolutePath)
def documentTop(topText: String) = CompoundDocOption("-top", topText)
def windowTitle(title: String) = CompoundDocOption("-windowtitle", title)
object Access extends Enumeration
{
val Public = Value("public")
val Default = Value("protected")
val Private = Value("private")
}
def javapTask(classpath: PathFinder, conditional: => CompileConditional, compilePath: Path) = def javapTask(classpath: PathFinder, conditional: => CompileConditional, compilePath: Path) =
task { args => task { args =>
val cp = classpath +++ Path.fromFile(FileUtilities.scalaLibraryJar) +++ Path.fromFile(FileUtilities.scalaCompilerJar) val cp = classpath +++ Path.fromFile(FileUtilities.scalaLibraryJar) +++ Path.fromFile(FileUtilities.scalaCompilerJar)
@ -145,24 +19,6 @@ trait ScalaProject extends SimpleScalaProject with FileTasks with MultiTaskProje
classes.map(_.replace(java.io.File.separatorChar, '.').toList.dropRight(".class".length).mkString).toSeq classes.map(_.replace(java.io.File.separatorChar, '.').toList.dropRight(".class".length).mkString).toSeq
} }
def consoleTask(classpath: PathFinder): Task = consoleTask(classpath, Nil, "")
def consoleTask(classpath: PathFinder, options: => Seq[CompileOption], initialCommands: => String): Task =
interactiveTask {
(new Console(buildCompiler))(classpath.get, options.map(_.asString), initialCommands, log)
}
def runTask(mainClass: => Option[String], classpath: PathFinder, options: String*)(implicit runner: ScalaRun): Task =
runTask(mainClass, classpath, options)
def runTask(mainClass: => Option[String], classpath: PathFinder, options: => Seq[String])(implicit runner: ScalaRun): Task =
task
{
mainClass match
{
case Some(main) => runner.run(main, classpath.get, options, log)
case None => Some("No main class specified.")
}
}
def syncPathsTask(sources: PathFinder, destinationDirectory: Path): Task = def syncPathsTask(sources: PathFinder, destinationDirectory: Path): Task =
task { FileUtilities.syncPaths(sources, destinationDirectory, log) } task { FileUtilities.syncPaths(sources, destinationDirectory, log) }
def syncTask(sourceDirectory: Path, destinationDirectory: Path): Task = def syncTask(sourceDirectory: Path, destinationDirectory: Path): Task =
@ -170,157 +26,16 @@ trait ScalaProject extends SimpleScalaProject with FileTasks with MultiTaskProje
def copyTask(sources: PathFinder, destinationDirectory: Path): Task = def copyTask(sources: PathFinder, destinationDirectory: Path): Task =
task { FileUtilities.copy(sources.get, destinationDirectory, log).left.toOption } task { FileUtilities.copy(sources.get, destinationDirectory, log).left.toOption }
def testTask(frameworks: Seq[TestFramework], classpath: PathFinder, analysis: CompileAnalysis, options: TestOption*): Task =
testTask(frameworks, classpath, analysis, options)
def testTask(frameworks: Seq[TestFramework], classpath: PathFinder, analysis: CompileAnalysis, options: => Seq[TestOption]): Task =
{
def rawWork =
{
val (begin, work, end) = testTasks(frameworks, classpath, analysis, options)
val beginTasks = begin.map(toTask).toSeq // test setup tasks
val workTasks = work.map(w => toTask(w) dependsOn(beginTasks : _*)) // the actual tests
val endTasks = end.map(toTask).toSeq // tasks that perform test cleanup and are run regardless of success of tests
val endTask = task { None} named("test-cleanup") dependsOn(endTasks : _*)
val rootTask = task { None} named("test-complete") dependsOn(workTasks.toSeq : _*) // the task that depends on all test subtasks
SubWork[Project#Task](rootTask, endTask)
}
def errorTask(e: TestSetupException) = task { Some(e.getMessage) } named("test-setup")
def work =
try { rawWork }
catch { case e: TestSetupException => SubWork[Project#Task](errorTask(e)) }
new CompoundTask(work)
}
private def toTask(testTask: NamedTestTask) = task(testTask.run()) named(testTask.name)
def graphSourcesTask(outputDirectory: Path, roots: PathFinder, analysis: => CompileAnalysis): Task = def graphSourcesTask(outputDirectory: Path, roots: PathFinder, analysis: => CompileAnalysis): Task =
task { DotGraph.sources(analysis, outputDirectory, roots.get, log) } task { DotGraph.sources(analysis, outputDirectory, roots.get, log) }
def graphPackagesTask(outputDirectory: Path, roots: PathFinder, analysis: => CompileAnalysis): Task = def graphPackagesTask(outputDirectory: Path, roots: PathFinder, analysis: => CompileAnalysis): Task =
task { DotGraph.packages(analysis, outputDirectory, roots.get, log) } task { DotGraph.packages(analysis, outputDirectory, roots.get, log) }
def scaladocTask(label: String, sources: PathFinder, outputDirectory: Path, classpath: PathFinder, options: ScaladocOption*): Task =
scaladocTask(label, sources, outputDirectory, classpath, options)
def scaladocTask(label: String, sources: PathFinder, outputDirectory: Path, classpath: PathFinder, options: => Seq[ScaladocOption]): Task =
fileTask(outputDirectory / "index.html" from sources)
{
val optionsLocal = options
val maxErrors = maximumErrors(optionsLocal)
(new Scaladoc(maxErrors, buildCompiler))(label, sources.get, classpath.get, outputDirectory, optionsLocal.flatMap(_.asList), log)
}
def packageTask(sources: PathFinder, outputDirectory: Path, jarName: => String, options: PackageOption*): Task =
packageTask(sources, outputDirectory / jarName, options)
def packageTask(sources: PathFinder, outputDirectory: Path, jarName: => String, options: => Seq[PackageOption]): Task =
packageTask(sources: PathFinder, outputDirectory / jarName, options)
def packageTask(sources: PathFinder, jarPath: => Path, options: PackageOption*): Task =
packageTask(sources, jarPath, options)
def packageTask(sources: PathFinder, jarPath: => Path, options: => Seq[PackageOption]): Task =
fileTask("package", jarPath from sources)
{
import wrap.{MutableMapWrapper,Wrappers}
/** Copies the mappings in a2 to a1, mutating a1. */
def mergeAttributes(a1: Attributes, a2: Attributes)
{
for( (key, value) <- Wrappers.toList(a2))
a1.put(key, value)
}
val manifest = new Manifest
var recursive = false
for(option <- options)
{
option match
{
case JarManifest(mergeManifest) =>
{
mergeAttributes(manifest.getMainAttributes, mergeManifest.getMainAttributes)
val entryMap = new MutableMapWrapper(manifest.getEntries)
for((key, value) <- Wrappers.toList(mergeManifest.getEntries))
{
entryMap.get(key) match
{
case Some(attributes) => mergeAttributes(attributes, value)
case None => entryMap += (key, value)
}
}
}
case Recursive => recursive = true
case MainClass(mainClassName) =>
manifest.getMainAttributes.put(Attributes.Name.MAIN_CLASS, mainClassName)
case ManifestAttributes(attributes @ _*) =>
val main = manifest.getMainAttributes
for( (name, value) <- attributes)
main.put(name, value)
case _ => log.warn("Ignored unknown package option " + option)
}
}
val jarPathLocal = jarPath
FileUtilities.clean(jarPathLocal :: Nil, log) orElse
FileUtilities.jar(sources.get, jarPathLocal, manifest, recursive, log)
}
def zipTask(sources: PathFinder, outputDirectory: Path, zipName: => String): Task = def zipTask(sources: PathFinder, outputDirectory: Path, zipName: => String): Task =
zipTask(sources, outputDirectory / zipName) zipTask(sources, outputDirectory / zipName)
def zipTask(sources: PathFinder, zipPath: => Path): Task = def zipTask(sources: PathFinder, zipPath: => Path): Task =
fileTask("zip", zipPath from sources) { FileUtilities.zip(sources.get, zipPath, false, log) } fileTask("zip", zipPath from sources) { FileUtilities.zip(sources.get, zipPath, false, log) }
def incrementVersionNumber() def incrementVersionNumber()
{
projectVersion.get match
{
case Some(v: BasicVersion) =>
{
val newVersion = incrementImpl(v)
log.info("Changing version to " + newVersion)
projectVersion() = newVersion
}
case a => ()
}
}
protected def incrementImpl(v: BasicVersion): Version = v.incrementMicro
protected def testTasks(frameworks: Seq[TestFramework], classpath: PathFinder, analysis: CompileAnalysis, options: => Seq[TestOption]) =
{
import scala.collection.mutable.HashSet
import scala.collection.mutable.Map
val testFilters = new ListBuffer[String => Boolean]
val excludeTestsSet = new HashSet[String]
val setup, cleanup = new ListBuffer[ClassLoader => Unit]
val testListeners = new ListBuffer[TestReportListener]
val testArgsByFramework = Map[TestFramework, ListBuffer[String]]()
def frameworkArgs(framework: TestFramework): ListBuffer[String] =
testArgsByFramework.getOrElseUpdate(framework, new ListBuffer[String])
for(option <- options)
{
option match
{
case TestFilter(include) => testFilters += include
case ExcludeTests(exclude) => excludeTestsSet ++= exclude
case TestListeners(listeners) => testListeners ++= listeners
case TestSetup(setupFunction) => setup += setupFunction
case TestCleanup(cleanupFunction) => cleanup += cleanupFunction
/**
* There are two cases here.
* The first handles TestArguments in the project file, which
* might have a TestFramework specified.
* The second handles arguments to be applied to all test frameworks.
* -- arguments from the project file that didnt have a framework specified
* -- command line arguments (ex: test-only someClass -- someArg)
* (currently, command line args must be passed to all frameworks)
*/
case TestArgument(Some(framework), args) => frameworkArgs(framework) ++= args
case TestArgument(None, args) => frameworks.foreach { framework => frameworkArgs(framework) ++= args.toList }
}
}
if(excludeTestsSet.size > 0 && log.atLevel(Level.Debug))
{
log.debug("Excluding tests: ")
excludeTestsSet.foreach(test => log.debug("\t" + test))
}
def includeTest(test: TestDefinition) = !excludeTestsSet.contains(test.name) && testFilters.forall(filter => filter(test.name))
val tests = HashSet.empty[TestDefinition] ++ analysis.allTests.map(_.toDefinition).filter(includeTest)
TestFramework.testTasks(frameworks, classpath.get, buildScalaInstance, tests.toSeq, log,
testListeners.readOnly, false, setup.readOnly, cleanup.readOnly, testArgsByFramework)
}
private def flatten[T](i: Iterable[Iterable[T]]) = i.flatMap(x => x)
protected def testQuickMethod(testAnalysis: CompileAnalysis, options: => Seq[TestOption])(toRun: (Seq[TestOption]) => Task) = { protected def testQuickMethod(testAnalysis: CompileAnalysis, options: => Seq[TestOption])(toRun: (Seq[TestOption]) => Task) = {
def analysis = Set() ++ testAnalysis.allTests.map(_.className) def analysis = Set() ++ testAnalysis.allTests.map(_.className)
@ -328,9 +43,6 @@ trait ScalaProject extends SimpleScalaProject with FileTasks with MultiTaskProje
toRun(TestArgument(args:_*) :: TestFilter(includeFunction) :: options.toList) toRun(TestArgument(args:_*) :: TestFilter(includeFunction) :: options.toList)
} }
} }
protected final def maximumErrors[T <: ActionOption](options: Seq[T]) =
(for( MaxCompileErrors(maxErrors) <- options) yield maxErrors).firstOption.getOrElse(DefaultMaximumCompileErrors)
} }
trait WebScalaProject extends ScalaProject trait WebScalaProject extends ScalaProject