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

Merge pull request #2226 from sbt/wip/build-imports 

Make object Import to alias types and values
This commit is contained in:
eugene yokota 2015-10-02 04:31:46 -04:00
parent ab1d376e11 7bb934ff8c
commit 2c4583e312
136 changed files with 684 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.travis.yml
View File

@ -18,7 +18,7 @@ env:
- SCRIPTED_TEST="safeUnitTests" - SCRIPTED_TEST="safeUnitTests"
- SCRIPTED_TEST="otherUnitTests" - SCRIPTED_TEST="otherUnitTests"
- SCRIPTED_TEST="scripted actions/*" - SCRIPTED_TEST="scripted actions/*"
- SCRIPTED_TEST="scripted api/*" - SCRIPTED_TEST="scripted apiinfo/*"
- SCRIPTED_TEST="scripted compiler-project/*" - SCRIPTED_TEST="scripted compiler-project/*"
- SCRIPTED_TEST="scripted dependency-management/*1of2" - SCRIPTED_TEST="scripted dependency-management/*1of2"
- SCRIPTED_TEST="scripted dependency-management/*2of2" - SCRIPTED_TEST="scripted dependency-management/*2of2"
@ -35,8 +35,8 @@ env:
- SCRIPTED_TEST="scripted tests/*" - SCRIPTED_TEST="scripted tests/*"
- SCRIPTED_TEST="scripted project-load/*" - SCRIPTED_TEST="scripted project-load/*"
- SCRIPTED_TEST="checkBuildScala211" - SCRIPTED_TEST="checkBuildScala211"
- SCRIPTED_TEST="mavenResolverPluginTest:scripted dependency-management/*1of2 project/transitive-plugins" # - SCRIPTED_TEST="mavenResolverPluginTest:scripted dependency-management/*1of2 project/transitive-plugins"
- SCRIPTED_TEST="mavenResolverPluginTest:scripted dependency-management/*2of2" # - SCRIPTED_TEST="mavenResolverPluginTest:scripted dependency-management/*2of2"
notifications: notifications:
email: email:

1
build.sbt
View File

@ -202,6 +202,7 @@ lazy val mavenResolverPluginProj = (project in file("sbt-maven-resolver")).
dependsOn(sbtProj). dependsOn(sbtProj).
settings( settings(
baseSettings, baseSettings,
sbtBinaryVersion := "1.0.0-SNAPSHOT",
name := "sbt-maven-resolver", name := "sbt-maven-resolver",
libraryDependencies ++= aetherLibs ++ Seq(utilTesting % Test, (libraryManagement % Test).classifier("tests"), libraryManagement % Test), libraryDependencies ++= aetherLibs ++ Seq(utilTesting % Test, (libraryManagement % Test).classifier("tests"), libraryManagement % Test),
sbtPlugin := true sbtPlugin := true

12
main/actions/src/main/scala/sbt/CacheIvy.scala
View File

@ -72,8 +72,8 @@ object CacheIvy {
} }
implicit def updateStatsFormat: Format[UpdateStats] = implicit def updateStatsFormat: Format[UpdateStats] =
wrap[UpdateStats, (Long, Long, Long)](us => (us.resolveTime, us.downloadTime, us.downloadSize), { case (rt, dt, ds) => new UpdateStats(rt, dt, ds, true) }) wrap[UpdateStats, (Long, Long, Long)](us => (us.resolveTime, us.downloadTime, us.downloadSize), { case (rt, dt, ds) => new UpdateStats(rt, dt, ds, true) })
implicit def confReportFormat(implicit m: Format[String], mr: Format[Seq[ModuleReport]], oar: Format[Seq[OrganizationArtifactReport]], mi: Format[Seq[ModuleID]]): Format[ConfigurationReport] = implicit def confReportFormat(implicit m: Format[String], mr: Format[Seq[ModuleReport]], oar: Format[Seq[OrganizationArtifactReport]]): Format[ConfigurationReport] =
wrap[ConfigurationReport, (String, Seq[ModuleReport], Seq[OrganizationArtifactReport], Seq[ModuleID])](r => (r.configuration, r.modules, r.details, r.evicted), { case (c, m, d, v) => new ConfigurationReport(c, m, d, v) }) wrap[ConfigurationReport, (String, Seq[ModuleReport], Seq[OrganizationArtifactReport])](r => (r.configuration, r.modules, r.details), { case (c, m, d) => new ConfigurationReport(c, m, d) })
implicit def moduleReportFormat(implicit cf: Format[Seq[Caller]], ff: Format[File]): Format[ModuleReport] = { implicit def moduleReportFormat(implicit cf: Format[Seq[Caller]], ff: Format[File]): Format[ModuleReport] = {
wrap[ModuleReport, (ModuleID, Seq[(Artifact, File)], Seq[Artifact], Option[String], Option[Long], Option[String], Option[String], Boolean, Option[String], Option[String], Option[String], Option[String], Map[String, String], Option[Boolean], Option[String], Seq[String], Seq[(String, Option[String])], Seq[Caller])]( wrap[ModuleReport, (ModuleID, Seq[(Artifact, File)], Seq[Artifact], Option[String], Option[Long], Option[String], Option[String], Boolean, Option[String], Option[String], Option[String], Option[String], Map[String, String], Option[Boolean], Option[String], Seq[String], Seq[(String, Option[String])], Seq[Caller])](
m => (m.module, m.artifacts, m.missingArtifacts, m.status, m.publicationDate map { _.getTime }, m.resolver, m.artifactResolver, m.evicted, m.evictedData, m.evictedReason, m.problem, m.homepage, m.extraAttributes, m.isDefault, m.branch, m.configurations, m.licenses, m.callers), m => (m.module, m.artifacts, m.missingArtifacts, m.status, m.publicationDate map { _.getTime }, m.resolver, m.artifactResolver, m.evicted, m.evictedData, m.evictedReason, m.problem, m.homepage, m.extraAttributes, m.isDefault, m.branch, m.configurations, m.licenses, m.callers),
@ -142,7 +142,7 @@ object CacheIvy {
implicit def inlineIvyIC: InputCache[InlineIvyConfiguration] = wrapIn implicit def inlineIvyIC: InputCache[InlineIvyConfiguration] = wrapIn
implicit def moduleSettingsIC: InputCache[ModuleSettings] = implicit def moduleSettingsIC: InputCache[ModuleSettings] =
unionInputCache[ModuleSettings, PomConfiguration :+: InlineConfiguration :+: InlineConfigurationWithExcludes :+: EmptyConfiguration :+: IvyFileConfiguration :+: HNil] unionInputCache[ModuleSettings, PomConfiguration :+: InlineConfiguration :+: InlineConfigurationWithExcludes :+: IvyFileConfiguration :+: HNil]
implicit def ivyConfigurationIC: InputCache[IvyConfiguration] = implicit def ivyConfigurationIC: InputCache[IvyConfiguration] =
unionInputCache[IvyConfiguration, InlineIvyConfiguration :+: ExternalIvyConfiguration :+: HNil] unionInputCache[IvyConfiguration, InlineIvyConfiguration :+: ExternalIvyConfiguration :+: HNil]
@ -152,13 +152,11 @@ object CacheIvy {
c.module :+: c.dependencies :+: c.ivyXML :+: c.configurations :+: c.defaultConfiguration.map(_.name) :+: c.module :+: c.dependencies :+: c.ivyXML :+: c.configurations :+: c.defaultConfiguration.map(_.name) :+:
c.ivyScala :+: c.validate :+: c.overrides :+: c.excludes :+: HNil c.ivyScala :+: c.validate :+: c.overrides :+: c.excludes :+: HNil
implicit def moduleConfToHL = (m: ModuleConfiguration) => m.organization :+: m.name :+: m.revision :+: m.resolver :+: HNil implicit def moduleConfToHL = (m: ModuleConfiguration) => m.organization :+: m.name :+: m.revision :+: m.resolver :+: HNil
implicit def emptyToHL = (e: EmptyConfiguration) => e.module :+: e.ivyScala :+: e.validate :+: HNil
implicit def inlineToHL = (c: InlineConfiguration) => c.module :+: c.dependencies :+: c.ivyXML :+: c.configurations :+: c.defaultConfiguration.map(_.name) :+: c.ivyScala :+: c.validate :+: c.overrides :+: HNil implicit def inlineToHL = (c: InlineConfiguration) => c.module :+: c.dependencies :+: c.ivyXML :+: c.configurations :+: c.defaultConfiguration.map(_.name) :+: c.ivyScala :+: c.validate :+: c.overrides :+: HNil
} }
import L4._ import L4._
implicit def inlineWithExcludesIC: InputCache[InlineConfigurationWithExcludes] = wrapIn implicit def inlineWithExcludesIC: InputCache[InlineConfigurationWithExcludes] = wrapIn
implicit def emptyIC: InputCache[EmptyConfiguration] = wrapIn
implicit def inlineIC: InputCache[InlineConfiguration] = wrapIn implicit def inlineIC: InputCache[InlineConfiguration] = wrapIn
implicit def moduleConfIC: InputCache[ModuleConfiguration] = wrapIn implicit def moduleConfIC: InputCache[ModuleConfiguration] = wrapIn
@ -177,7 +175,7 @@ object CacheIvy {
implicit lazy val chainedIC: InputCache[ChainedResolver] = InputCache.lzy(wrapIn) implicit lazy val chainedIC: InputCache[ChainedResolver] = InputCache.lzy(wrapIn)
implicit lazy val resolverIC: InputCache[Resolver] = implicit lazy val resolverIC: InputCache[Resolver] =
unionInputCache[Resolver, ChainedResolver :+: JavaNet1Repository :+: MavenRepository :+: MavenCache :+: FileRepository :+: URLRepository :+: SshRepository :+: SftpRepository :+: RawRepository :+: HNil] unionInputCache[Resolver, ChainedResolver :+: MavenRepository :+: MavenCache :+: FileRepository :+: URLRepository :+: SshRepository :+: SftpRepository :+: RawRepository :+: HNil]
implicit def moduleIC: InputCache[ModuleID] = wrapIn implicit def moduleIC: InputCache[ModuleID] = wrapIn
implicitly[InputCache[Seq[Configuration]]] implicitly[InputCache[Seq[Configuration]]]
@ -235,6 +233,4 @@ object CacheIvy {
implicit def authIC: InputCache[SshAuthentication] = implicit def authIC: InputCache[SshAuthentication] =
unionInputCache[SshAuthentication, PasswordAuthentication :+: KeyFileAuthentication :+: HNil] unionInputCache[SshAuthentication, PasswordAuthentication :+: KeyFileAuthentication :+: HNil]
implicit def javaNet1IC: InputCache[JavaNet1Repository] = singleton(JavaNet1Repository)
} }

12
main/settings/src/main/scala/sbt/Structure.scala
View File

@ -216,7 +216,7 @@ object Scoped {
final class RichInitializeTask[S](i: Initialize[Task[S]]) extends RichInitTaskBase[S, Task] { final class RichInitializeTask[S](i: Initialize[Task[S]]) extends RichInitTaskBase[S, Task] {
protected def onTask[T](f: Task[S] => Task[T]): Initialize[Task[T]] = i apply f protected def onTask[T](f: Task[S] => Task[T]): Initialize[Task[T]] = i apply f
def dependsOn(tasks: AnyInitTask*): Initialize[Task[S]] = (i, Initialize.joinAny[Task, Any](tasks)) { (thisTask, deps) => thisTask.dependsOn(deps: _*) } def dependsOn(tasks: AnyInitTask*): Initialize[Task[S]] = (i, Initialize.joinAny[Task](tasks)) { (thisTask, deps) => thisTask.dependsOn(deps: _*) }
def failure: Initialize[Task[Incomplete]] = i(_.failure) def failure: Initialize[Task[Incomplete]] = i(_.failure)
def result: Initialize[Task[Result[S]]] = i(_.result) def result: Initialize[Task[Result[S]]] = i(_.result)
@ -224,12 +224,12 @@ object Scoped {
def xtriggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy) def xtriggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy)
def triggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy) def triggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy)
def runBefore[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.runBefore) def runBefore[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.runBefore)
private[this] def nonLocal[T](tasks: Seq[Initialize[Task[T]]], key: AttributeKey[Seq[Task[_]]]): Initialize[Task[S]] = private[this] def nonLocal(tasks: Seq[AnyInitTask], key: AttributeKey[Seq[Task[_]]]): Initialize[Task[S]] =
(Initialize.joinAny[Task, T](tasks), i) { (ts, i) => i.copy(info = i.info.set(key, ts)) } (Initialize.joinAny[Task](tasks), i) { (ts, i) => i.copy(info = i.info.set(key, ts)) }
} }
final class RichInitializeInputTask[S](i: Initialize[InputTask[S]]) extends RichInitTaskBase[S, InputTask] { final class RichInitializeInputTask[S](i: Initialize[InputTask[S]]) extends RichInitTaskBase[S, InputTask] {
protected def onTask[T](f: Task[S] => Task[T]): Initialize[InputTask[T]] = i(_ mapTask f) protected def onTask[T](f: Task[S] => Task[T]): Initialize[InputTask[T]] = i(_ mapTask f)
def dependsOn(tasks: AnyInitTask*): Initialize[InputTask[S]] = (i, Initialize.joinAny[Task, Any](tasks)) { (thisTask, deps) => thisTask.mapTask(_.dependsOn(deps: _*)) } def dependsOn(tasks: AnyInitTask*): Initialize[InputTask[S]] = (i, Initialize.joinAny[Task](tasks)) { (thisTask, deps) => thisTask.mapTask(_.dependsOn(deps: _*)) }
} }
sealed abstract class RichInitTaskBase[S, R[_]] { sealed abstract class RichInitTaskBase[S, R[_]] {
@ -259,7 +259,7 @@ object Scoped {
def mapFailure[T](f: Incomplete => T): Initialize[R[T]] = mapR(f compose failM) def mapFailure[T](f: Incomplete => T): Initialize[R[T]] = mapR(f compose failM)
} }
type AnyInitTask = Initialize[Task[Any]] // forSome { type T } type AnyInitTask = Initialize[Task[T]] forSome { type T }
implicit def richTaskSeq[T](in: Seq[Initialize[Task[T]]]): RichTaskSeq[T] = new RichTaskSeq(in) implicit def richTaskSeq[T](in: Seq[Initialize[Task[T]]]): RichTaskSeq[T] = new RichTaskSeq(in)
final class RichTaskSeq[T](keys: Seq[Initialize[Task[T]]]) { final class RichTaskSeq[T](keys: Seq[Initialize[Task[T]]]) {
@ -268,7 +268,7 @@ object Scoped {
} }
implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq = new RichAnyTaskSeq(in) implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq = new RichAnyTaskSeq(in)
final class RichAnyTaskSeq(keys: Seq[AnyInitTask]) { final class RichAnyTaskSeq(keys: Seq[AnyInitTask]) {
def dependOn: Initialize[Task[Unit]] = Initialize.joinAny[Task, Any](keys).apply(deps => nop.dependsOn(deps: _*)) def dependOn: Initialize[Task[Unit]] = Initialize.joinAny[Task](keys).apply(deps => nop.dependsOn(deps: _*))
} }
implicit def richFileSetting(s: SettingKey[File]): RichFileSetting = new RichFileSetting(s) implicit def richFileSetting(s: SettingKey[File]): RichFileSetting = new RichFileSetting(s)

2
main/src/main/scala/sbt/BuildUtil.scala
View File

@ -71,7 +71,7 @@ object BuildUtil {
} }
} }
def baseImports: Seq[String] = "import sbt._, Keys._, dsl._" :: Nil def baseImports: Seq[String] = "import sbt._, Keys._, dsl._, Import._" :: Nil
def getImports(unit: BuildUnit): Seq[String] = unit.plugins.detected.imports ++ unit.definitions.dslDefinitions.imports def getImports(unit: BuildUnit): Seq[String] = unit.plugins.detected.imports ++ unit.definitions.dslDefinitions.imports

1
main/src/main/scala/sbt/Defaults.scala
View File

@ -25,6 +25,7 @@ import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint }
import sbt.librarymanagement._ import sbt.librarymanagement._
import sbt.internal.librarymanagement._ import sbt.internal.librarymanagement._
import sbt.internal.librarymanagement.syntax._
import sbt.internal.util._ import sbt.internal.util._
import sbt.util.Level import sbt.util.Level

4
project/Dependencies.scala
View File

@ -9,10 +9,10 @@ object Dependencies {
lazy val scala211 = "2.11.7" lazy val scala211 = "2.11.7"
// sbt modules // sbt modules
val utilVersion = "0.1.0-M3" val utilVersion = "0.1.0-M5"
val ioVersion = "1.0.0-M3" val ioVersion = "1.0.0-M3"
val incremenalcompilerVersion = "0.1.0-M1-168cb7a4877917e01917e35b9b82a62afe5c2a01" val incremenalcompilerVersion = "0.1.0-M1-168cb7a4877917e01917e35b9b82a62afe5c2a01"
val librarymanagementVersion = "0.1.0-M2" val librarymanagementVersion = "0.1.0-M4"
lazy val sbtIO = "org.scala-sbt" %% "io" % ioVersion lazy val sbtIO = "org.scala-sbt" %% "io" % ioVersion
lazy val utilCollection = "org.scala-sbt" %% "util-collection" % utilVersion lazy val utilCollection = "org.scala-sbt" %% "util-collection" % utilVersion
lazy val utilLogging = "org.scala-sbt" %% "util-logging" % utilVersion lazy val utilLogging = "org.scala-sbt" %% "util-logging" % utilVersion

440
sbt/src/main/scala/Import.scala Normal file
View File

@ -0,0 +1,440 @@
package sbt
object Import {
// sbt.io
val AllPassFilter = sbt.io.AllPassFilter
val DirectoryFilter = sbt.io.DirectoryFilter
type ExactFilter = sbt.io.ExactFilter
val ExistsFileFilter = sbt.io.ExistsFileFilter
val FileFilter = sbt.io.FileFilter
type FileFilter = sbt.io.FileFilter
val GlobFilter = sbt.io.GlobFilter
val Hash = sbt.io.Hash
val HiddenFileFilter = sbt.io.HiddenFileFilter
val IO = sbt.io.IO
type Mapper = sbt.io.Mapper
val NameFilter = sbt.io.NameFilter
type NameFilter = sbt.io.NameFilter
val NothingFilter = sbt.io.NothingFilter
val Path = sbt.io.Path
type PathExtra = sbt.io.PathExtra
val PathFinder = sbt.io.PathFinder
type PathFinder = sbt.io.PathFinder
type PathLow = sbt.io.PathLow
type PatternFilter = sbt.io.PatternFilter
type RichFile = sbt.io.RichFile
type SimpleFileFilter = sbt.io.SimpleFileFilter
type SimpleFilter = sbt.io.SimpleFilter
type TestError = sbt.io.TestError
type TestException = sbt.io.TestException
type TestRuntimeException = sbt.io.TestRuntimeException
// sbt.util
type AbstractLogger = sbt.util.AbstractLogger
val ControlEvent = sbt.util.ControlEvent
type ControlEvent = sbt.util.ControlEvent
val Level = sbt.util.Level
type Log = sbt.util.Log
type LogEvent = sbt.util.LogEvent
val Logger = sbt.util.Logger
type Logger = sbt.util.Logger
type SetLevel = sbt.util.SetLevel
type SetSuccess = sbt.util.SetSuccess
type SetTrace = sbt.util.SetTrace
type Success = sbt.util.Success
type Trace = sbt.util.Trace
// sbt.internal.util
val AList = sbt.internal.util.AList
type AbstractRMap[K[_], V[_]] = sbt.internal.util.AbstractRMap[K, V]
type AlreadyHandledException = sbt.internal.util.AlreadyHandledException
val AttributeEntry = sbt.internal.util.AttributeEntry
type AttributeEntry[T] = sbt.internal.util.AttributeEntry[T]
val AttributeKey = sbt.internal.util.AttributeKey
type AttributeKey[T] = sbt.internal.util.AttributeKey[T]
val AttributeMap = sbt.internal.util.AttributeMap
type AttributeMap = sbt.internal.util.AttributeMap
val Attributed = sbt.internal.util.Attributed
type Attributed[D] = sbt.internal.util.Attributed[D]
type BasicCache[I, O] = sbt.internal.util.BasicCache[I, O]
type BasicCacheImplicits = sbt.internal.util.BasicCacheImplicits
type BasicLogger = sbt.internal.util.BasicLogger
type BufferedLogger = sbt.internal.util.BufferedLogger
val Cache = sbt.internal.util.Cache
type Cache[I, O] = sbt.internal.util.Cache[I, O]
val CacheIO = sbt.internal.util.CacheIO
type CacheImplicits = sbt.internal.util.CacheImplicits
val ChangeReport = sbt.internal.util.ChangeReport
type ChangeReport[T] = sbt.internal.util.ChangeReport[T]
type Changed[O] = sbt.internal.util.Changed[O]
val Classes = sbt.internal.util.Classes
val ConsoleLogger = sbt.internal.util.ConsoleLogger
type ConsoleLogger = sbt.internal.util.ConsoleLogger
val ConsoleOut = sbt.internal.util.ConsoleOut
type ConsoleOut = sbt.internal.util.ConsoleOut
val Dag = sbt.internal.util.Dag
type Dag[Node <: Dag[Node]] = sbt.internal.util.Dag[Node]
type DelegatingPMap[K[_], V[_]] = sbt.internal.util.DelegatingPMap[K, V]
val Difference = sbt.internal.util.Difference
type Difference = sbt.internal.util.Difference
type EmptyChangeReport[T] = sbt.internal.util.EmptyChangeReport[T]
val ErrorHandling = sbt.internal.util.ErrorHandling
type EvaluateSettings[Scope] = sbt.internal.util.EvaluateSettings[Scope]
val EvaluationState = sbt.internal.util.EvaluationState
val ExitHook = sbt.internal.util.ExitHook
type ExitHook = sbt.internal.util.ExitHook
val ExitHooks = sbt.internal.util.ExitHooks
type FeedbackProvidedException = sbt.internal.util.FeedbackProvidedException
val FileFunction = sbt.internal.util.FileFunction
val FileInfo = sbt.internal.util.FileInfo
type FileInfo = sbt.internal.util.FileInfo
type FilePosition = sbt.internal.util.FilePosition
val FilesInfo = sbt.internal.util.FilesInfo
type FilesInfo[F <: FileInfo] = sbt.internal.util.FilesInfo[F]
type FilterLogger = sbt.internal.util.FilterLogger
type Fn1[A, B] = sbt.internal.util.Fn1[A, B]
val FullLogger = sbt.internal.util.FullLogger
type FullLogger = sbt.internal.util.FullLogger
val FullReader = sbt.internal.util.FullReader
type FullReader = sbt.internal.util.FullReader
val GlobalLogBacking = sbt.internal.util.GlobalLogBacking
type GlobalLogBacking = sbt.internal.util.GlobalLogBacking
val GlobalLogging = sbt.internal.util.GlobalLogging
type GlobalLogging = sbt.internal.util.GlobalLogging
val HCons = sbt.internal.util.HCons
type HCons[H, T <: HList] = sbt.internal.util.HCons[H, T]
val HList = sbt.internal.util.HList
type HList = sbt.internal.util.HList
type HListCacheImplicits = sbt.internal.util.HListCacheImplicits
val HNil = sbt.internal.util.HNil
type HNil = sbt.internal.util.HNil
type HashFileInfo = sbt.internal.util.HashFileInfo
type HashModifiedFileInfo = sbt.internal.util.HashModifiedFileInfo
val IDSet = sbt.internal.util.IDSet
type IDSet[T] = sbt.internal.util.IDSet[T]
val IMap = sbt.internal.util.IMap
type IMap[K[_], V[_]] = sbt.internal.util.IMap[K, V]
type Init[Scope] = sbt.internal.util.Init[Scope]
val InputCache = sbt.internal.util.InputCache
type InputCache[I] = sbt.internal.util.InputCache[I]
type JLine = sbt.internal.util.JLine
val KCons = sbt.internal.util.KCons
type KCons[H, +T <: KList[M], +M[_]] = sbt.internal.util.KCons[H, T, M]
type KList[+M[_]] = sbt.internal.util.KList[M]
val KNil = sbt.internal.util.KNil
type KNil = sbt.internal.util.KNil
val LinePosition = sbt.internal.util.LinePosition
type LinePosition = sbt.internal.util.LinePosition
val LineRange = sbt.internal.util.LineRange
type LineRange = sbt.internal.util.LineRange
type LineReader = sbt.internal.util.LineReader
val LoggerWriter = sbt.internal.util.LoggerWriter
type LoggerWriter = sbt.internal.util.LoggerWriter
val MainLogging = sbt.internal.util.MainLogging
type MessageOnlyException = sbt.internal.util.MessageOnlyException
type ModifiedFileInfo = sbt.internal.util.ModifiedFileInfo
type MultiLogger = sbt.internal.util.MultiLogger
val MultiLoggerConfig = sbt.internal.util.MultiLoggerConfig
type MultiLoggerConfig = sbt.internal.util.MultiLoggerConfig
val NoPosition = sbt.internal.util.NoPosition
val PMap = sbt.internal.util.PMap
type PMap[K[_], V[_]] = sbt.internal.util.PMap[K, V]
val Param = sbt.internal.util.Param
type Param[A[_], B[_]] = sbt.internal.util.Param[A, B]
type PlainFileInfo = sbt.internal.util.PlainFileInfo
type RMap[K[_], V[_]] = sbt.internal.util.RMap[K, V]
val RangePosition = sbt.internal.util.RangePosition
type RangePosition = sbt.internal.util.RangePosition
val Relation = sbt.internal.util.Relation
type Relation[A, B] = sbt.internal.util.Relation[A, B]
type SBinaryFormats = sbt.internal.util.SBinaryFormats
val ScalaKeywords = sbt.internal.util.ScalaKeywords
type Settings[Scope] = sbt.internal.util.Settings[Scope]
type SharedAttributeKey[T] = sbt.internal.util.SharedAttributeKey[T]
val Show = sbt.internal.util.Show
type Show[T] = sbt.internal.util.Show[T]
val ShowLines = sbt.internal.util.ShowLines
type ShowLines[A] = sbt.internal.util.ShowLines[A]
val Signals = sbt.internal.util.Signals
val SimpleReader = sbt.internal.util.SimpleReader
type SimpleReader = sbt.internal.util.SimpleReader
type SourcePosition = sbt.internal.util.SourcePosition
val StackTrace = sbt.internal.util.StackTrace
type SuppressedTraceContext = sbt.internal.util.SuppressedTraceContext
type Timestamp = sbt.internal.util.Timestamp
val Tracked = sbt.internal.util.Tracked
type Tracked = sbt.internal.util.Tracked
type TranslatedException = sbt.internal.util.TranslatedException
type TranslatedIOException = sbt.internal.util.TranslatedIOException
val TypeFunctions = sbt.internal.util.TypeFunctions
type TypeFunctions = sbt.internal.util.TypeFunctions
val Types = sbt.internal.util.Types
type Types = sbt.internal.util.Types
type UnionImplicits = sbt.internal.util.UnionImplicits
type UnprintableException = sbt.internal.util.UnprintableException
val Util = sbt.internal.util.Util
val ~> = sbt.internal.util.~>
type ~>[-K[_], +V[_]] = sbt.internal.util.~>[K, V]
// sbt.internal.util.complete
object complete {
val Completion = sbt.internal.util.complete.Completion
type Completion = sbt.internal.util.complete.Completion
val Completions = sbt.internal.util.complete.Completions
type Completions = sbt.internal.util.complete.Completions
val DefaultParsers = sbt.internal.util.complete.DefaultParsers
type DisplayOnly = sbt.internal.util.complete.DisplayOnly
val EditDistance = sbt.internal.util.complete.EditDistance
type ExampleSource = sbt.internal.util.complete.ExampleSource
val FileExamples = sbt.internal.util.complete.FileExamples
type FileExamples = sbt.internal.util.complete.FileExamples
val Finite = sbt.internal.util.complete.Finite
type Finite = sbt.internal.util.complete.Finite
val FixedSetExamples = sbt.internal.util.complete.FixedSetExamples
type FixedSetExamples = sbt.internal.util.complete.FixedSetExamples
val History = sbt.internal.util.complete.History
val HistoryCommands = sbt.internal.util.complete.HistoryCommands
val Infinite = sbt.internal.util.complete.Infinite
val JLineCompletion = sbt.internal.util.complete.JLineCompletion
val Parser = sbt.internal.util.complete.Parser
type Parser[+T] = sbt.internal.util.complete.Parser[T]
type ParserMain = sbt.internal.util.complete.ParserMain
val Parsers = sbt.internal.util.complete.Parsers
type Parsers = sbt.internal.util.complete.Parsers
val ProcessError = sbt.internal.util.complete.ProcessError
type Suggestion = sbt.internal.util.complete.Suggestion
type Token = sbt.internal.util.complete.Token
val TokenCompletions = sbt.internal.util.complete.TokenCompletions
type TokenCompletions = sbt.internal.util.complete.TokenCompletions
val TypeString = sbt.internal.util.complete.TypeString
type TypeString = sbt.internal.util.complete.TypeString
val UpperBound = sbt.internal.util.complete.UpperBound
type UpperBound = sbt.internal.util.complete.UpperBound
}
// sbt.internal.util.appmacro
object appmacro {
import scala.reflect._
import macros._
type BuilderResult[C <: Context with Singleton] = sbt.internal.util.appmacro.BuilderResult[C]
val ContextUtil = sbt.internal.util.appmacro.ContextUtil
type ContextUtil[C <: Context] = sbt.internal.util.appmacro.ContextUtil[C]
type Convert = sbt.internal.util.appmacro.Convert
val Converted = sbt.internal.util.appmacro.Converted
type Converted[C <: Context with Singleton] = sbt.internal.util.appmacro.Converted[C]
val Instance = sbt.internal.util.appmacro.Instance
type Instance = sbt.internal.util.appmacro.Instance
val KListBuilder = sbt.internal.util.appmacro.KListBuilder
val MixedBuilder = sbt.internal.util.appmacro.MixedBuilder
type MonadInstance = sbt.internal.util.appmacro.MonadInstance
type TupleBuilder = sbt.internal.util.appmacro.TupleBuilder
val TupleNBuilder = sbt.internal.util.appmacro.TupleNBuilder
}
// sbt.internal.util.logic
object logic {
val Atom = sbt.internal.util.logic.Atom
type Atom = sbt.internal.util.logic.Atom
val Clause = sbt.internal.util.logic.Clause
type Clause = sbt.internal.util.logic.Clause
val Clauses = sbt.internal.util.logic.Clauses
type Clauses = sbt.internal.util.logic.Clauses
val Formula = sbt.internal.util.logic.Formula
type Formula = sbt.internal.util.logic.Formula
type Literal = sbt.internal.util.logic.Literal
val Logic = sbt.internal.util.logic.Logic
val Negated = sbt.internal.util.logic.Negated
type Negated = sbt.internal.util.logic.Negated
}
// sbt.librarymanagement
val Artifact = sbt.librarymanagement.Artifact
type Artifact = sbt.librarymanagement.Artifact
val Caller = sbt.librarymanagement.Caller
type Caller = sbt.librarymanagement.Caller
val ChainedResolver = sbt.librarymanagement.ChainedResolver
type ChainedResolver = sbt.librarymanagement.ChainedResolver
val CircularDependencyLevel = sbt.librarymanagement.CircularDependencyLevel
type CircularDependencyLevel = sbt.librarymanagement.CircularDependencyLevel
val Configuration = sbt.librarymanagement.Configuration
type Configuration = sbt.librarymanagement.Configuration
val ConfigurationReport = sbt.librarymanagement.ConfigurationReport
type ConfigurationReport = sbt.librarymanagement.ConfigurationReport
val Configurations = sbt.librarymanagement.Configurations
val ConflictManager = sbt.librarymanagement.ConflictManager
type ConflictManager = sbt.librarymanagement.ConflictManager
val ConflictWarning = sbt.librarymanagement.ConflictWarning
type ConflictWarning = sbt.librarymanagement.ConflictWarning
val Credentials = sbt.librarymanagement.Credentials
type Credentials = sbt.librarymanagement.Credentials
val CrossVersion = sbt.librarymanagement.CrossVersion
type CrossVersion = sbt.librarymanagement.CrossVersion
val DefaultMavenRepository = sbt.librarymanagement.DefaultMavenRepository
val Developer = sbt.librarymanagement.Developer
type Developer = sbt.librarymanagement.Developer
type DirectCredentials = sbt.librarymanagement.DirectCredentials
val EvictionPair = sbt.librarymanagement.EvictionPair
type EvictionPair = sbt.librarymanagement.EvictionPair
val EvictionWarning = sbt.librarymanagement.EvictionWarning
type EvictionWarning = sbt.librarymanagement.EvictionWarning
val EvictionWarningOptions = sbt.librarymanagement.EvictionWarningOptions
type EvictionWarningOptions = sbt.librarymanagement.EvictionWarningOptions
val ExclusionRule = sbt.librarymanagement.ExclusionRule
type ExclusionRule = sbt.librarymanagement.ExclusionRule
type FileCredentials = sbt.librarymanagement.FileCredentials
val FileRepository = sbt.librarymanagement.FileRepository
type FileRepository = sbt.librarymanagement.FileRepository
val IvyScala = sbt.librarymanagement.IvyScala
type IvyScala = sbt.librarymanagement.IvyScala
val JCenterRepository = sbt.librarymanagement.JCenterRepository
val JavaNet2Repository = sbt.librarymanagement.JavaNet2Repository
val MavenCache = sbt.librarymanagement.MavenCache
type MavenCache = sbt.librarymanagement.MavenCache
val MavenRepository = sbt.librarymanagement.MavenRepository
type MavenRepository = sbt.librarymanagement.MavenRepository
val ModuleConfiguration = sbt.librarymanagement.ModuleConfiguration
type ModuleConfiguration = sbt.librarymanagement.ModuleConfiguration
val ModuleID = sbt.librarymanagement.ModuleID
type ModuleID = sbt.librarymanagement.ModuleID
val ModuleInfo = sbt.librarymanagement.ModuleInfo
type ModuleInfo = sbt.librarymanagement.ModuleInfo
val ModuleReport = sbt.librarymanagement.ModuleReport
type ModuleReport = sbt.librarymanagement.ModuleReport
val OrganizationArtifactReport = sbt.librarymanagement.OrganizationArtifactReport
type OrganizationArtifactReport = sbt.librarymanagement.OrganizationArtifactReport
val Patterns = sbt.librarymanagement.Patterns
type Patterns = sbt.librarymanagement.Patterns
type PatternsBasedRepository = sbt.librarymanagement.PatternsBasedRepository
type RawRepository = sbt.librarymanagement.RawRepository
val RepositoryHelpers = sbt.librarymanagement.RepositoryHelpers
val Resolver = sbt.librarymanagement.Resolver
type Resolver = sbt.librarymanagement.Resolver
val SbtArtifacts = sbt.librarymanagement.SbtArtifacts
val ScalaArtifacts = sbt.librarymanagement.ScalaArtifacts
val ScalaVersion = sbt.librarymanagement.ScalaVersion
type ScalaVersion = sbt.librarymanagement.ScalaVersion
val ScmInfo = sbt.librarymanagement.ScmInfo
type ScmInfo = sbt.librarymanagement.ScmInfo
val SftpRepository = sbt.librarymanagement.SftpRepository
type SftpRepository = sbt.librarymanagement.SftpRepository
type SshBasedRepository = sbt.librarymanagement.SshBasedRepository
val SshRepository = sbt.librarymanagement.SshRepository
type SshRepository = sbt.librarymanagement.SshRepository
val URLRepository = sbt.librarymanagement.URLRepository
type URLRepository = sbt.librarymanagement.URLRepository
val UpdateOptions = sbt.librarymanagement.UpdateOptions
type UpdateOptions = sbt.librarymanagement.UpdateOptions
val UpdateReport = sbt.librarymanagement.UpdateReport
type UpdateReport = sbt.librarymanagement.UpdateReport
val UpdateStats = sbt.librarymanagement.UpdateStats
type UpdateStats = sbt.librarymanagement.UpdateStats
val VersionNumber = sbt.librarymanagement.VersionNumber
type VersionNumber = sbt.librarymanagement.VersionNumber
type VersionNumberCompatibility = sbt.librarymanagement.VersionNumberCompatibility
// sbt.internal.librarymanagement
type ArtifactFilter = sbt.internal.librarymanagement.ArtifactFilter
val ComponentManager = sbt.internal.librarymanagement.ComponentManager
type ComponentManager = sbt.internal.librarymanagement.ComponentManager
type ConfigurationFilter = sbt.internal.librarymanagement.ConfigurationFilter
val ConfigurationReportLite = sbt.internal.librarymanagement.ConfigurationReportLite
type ConfigurationReportLite = sbt.internal.librarymanagement.ConfigurationReportLite
val ConvertResolver = sbt.internal.librarymanagement.ConvertResolver
val CustomPomParser = sbt.internal.librarymanagement.CustomPomParser
type CustomPomParser = sbt.internal.librarymanagement.CustomPomParser
val CustomXmlParser = sbt.internal.librarymanagement.CustomXmlParser
type DeliverConfiguration = sbt.internal.librarymanagement.DeliverConfiguration
val DependencyFilter = sbt.internal.librarymanagement.DependencyFilter
type DependencyFilter = sbt.internal.librarymanagement.DependencyFilter
type DependencyFilterExtra = sbt.internal.librarymanagement.DependencyFilterExtra
val ExternalIvyConfiguration = sbt.internal.librarymanagement.ExternalIvyConfiguration
type ExternalIvyConfiguration = sbt.internal.librarymanagement.ExternalIvyConfiguration
val GetClassifiersConfiguration = sbt.internal.librarymanagement.GetClassifiersConfiguration
type GetClassifiersConfiguration = sbt.internal.librarymanagement.GetClassifiersConfiguration
val GetClassifiersModule = sbt.internal.librarymanagement.GetClassifiersModule
type GetClassifiersModule = sbt.internal.librarymanagement.GetClassifiersModule
val IfMissing = sbt.internal.librarymanagement.IfMissing
type IfMissing = sbt.internal.librarymanagement.IfMissing
type ModuleSettings = sbt.internal.librarymanagement.ModuleSettings
val InlineConfiguration = sbt.internal.librarymanagement.InlineConfiguration
type InlineConfiguration = sbt.internal.librarymanagement.InlineConfiguration
val InlineConfigurationWithExcludes = sbt.internal.librarymanagement.InlineConfigurationWithExcludes
type InlineConfigurationWithExcludes = sbt.internal.librarymanagement.InlineConfigurationWithExcludes
type InlineIvyConfiguration = sbt.internal.librarymanagement.InlineIvyConfiguration
type InvalidComponent = sbt.internal.librarymanagement.InvalidComponent
val IvyActions = sbt.internal.librarymanagement.IvyActions
type IvyCache = sbt.internal.librarymanagement.IvyCache
val IvyConfiguration = sbt.internal.librarymanagement.IvyConfiguration
type IvyConfiguration = sbt.internal.librarymanagement.IvyConfiguration
val IvyFileConfiguration = sbt.internal.librarymanagement.IvyFileConfiguration
type IvyFileConfiguration = sbt.internal.librarymanagement.IvyFileConfiguration
type IvyPaths = sbt.internal.librarymanagement.IvyPaths
val IvyRetrieve = sbt.internal.librarymanagement.IvyRetrieve
val IvySbt = sbt.internal.librarymanagement.IvySbt
type IvySbt = sbt.internal.librarymanagement.IvySbt
val IvyUtil = sbt.internal.librarymanagement.IvyUtil
val JsonUtil = sbt.internal.librarymanagement.JsonUtil
val LogicalClock = sbt.internal.librarymanagement.LogicalClock
type LogicalClock = sbt.internal.librarymanagement.LogicalClock
val MakePom = sbt.internal.librarymanagement.MakePom
type MakePom = sbt.internal.librarymanagement.MakePom
val MakePomConfiguration = sbt.internal.librarymanagement.MakePomConfiguration
type MakePomConfiguration = sbt.internal.librarymanagement.MakePomConfiguration
type ModuleFilter = sbt.internal.librarymanagement.ModuleFilter
type NotInCache = sbt.internal.librarymanagement.NotInCache
val PomConfiguration = sbt.internal.librarymanagement.PomConfiguration
type PomConfiguration = sbt.internal.librarymanagement.PomConfiguration
val ProjectResolver = sbt.internal.librarymanagement.ProjectResolver
type ProjectResolver = sbt.internal.librarymanagement.ProjectResolver
type PublishConfiguration = sbt.internal.librarymanagement.PublishConfiguration
val ResolutionCache = sbt.internal.librarymanagement.ResolutionCache
type ResolutionCache = sbt.internal.librarymanagement.ResolutionCache
type ResolveException = sbt.internal.librarymanagement.ResolveException
type ResolverAdapter = sbt.internal.librarymanagement.ResolverAdapter
type RetrieveConfiguration = sbt.internal.librarymanagement.RetrieveConfiguration
val SbtExclusionRule = sbt.internal.librarymanagement.SbtExclusionRule
type SbtExclusionRule = sbt.internal.librarymanagement.SbtExclusionRule
val StringUtilities = sbt.internal.librarymanagement.StringUtilities
val UnresolvedWarning = sbt.internal.librarymanagement.UnresolvedWarning
type UnresolvedWarning = sbt.internal.librarymanagement.UnresolvedWarning
val UnresolvedWarningConfiguration = sbt.internal.librarymanagement.UnresolvedWarningConfiguration
type UnresolvedWarningConfiguration = sbt.internal.librarymanagement.UnresolvedWarningConfiguration
type UpdateConfiguration = sbt.internal.librarymanagement.UpdateConfiguration
val UpdateLogging = sbt.internal.librarymanagement.UpdateLogging
val UpdateReportLite = sbt.internal.librarymanagement.UpdateReportLite
type UpdateReportLite = sbt.internal.librarymanagement.UpdateReportLite
// sbt.internal.inc.classpath
object classpath {
type CachedClassLoader = sbt.internal.inc.classpath.CachedClassLoader
type ClassFilter = sbt.internal.inc.classpath.ClassFilter
type ClassLoaderCache = sbt.internal.inc.classpath.ClassLoaderCache
type ClasspathFilter = sbt.internal.inc.classpath.ClasspathFilter
val ClasspathUtilities = sbt.internal.inc.classpath.ClasspathUtilities
type DifferentLoaders = sbt.internal.inc.classpath.DifferentLoaders
type DualEnumeration[T] = sbt.internal.inc.classpath.DualEnumeration[T]
type DualLoader = sbt.internal.inc.classpath.DualLoader
type ExcludePackagesFilter = sbt.internal.inc.classpath.ExcludePackagesFilter
type FilteredLoader = sbt.internal.inc.classpath.FilteredLoader
type FixedResources = sbt.internal.inc.classpath.FixedResources
type IncludePackagesFilter = sbt.internal.inc.classpath.IncludePackagesFilter
type LoaderBase = sbt.internal.inc.classpath.LoaderBase
type NativeCopyConfig = sbt.internal.inc.classpath.NativeCopyConfig
type NativeCopyLoader = sbt.internal.inc.classpath.NativeCopyLoader
type NullLoader = sbt.internal.inc.classpath.NullLoader
type PackageFilter = sbt.internal.inc.classpath.PackageFilter
type RawResources = sbt.internal.inc.classpath.RawResources
val RawURL = sbt.internal.inc.classpath.RawURL
type SelfFirstLoader = sbt.internal.inc.classpath.SelfFirstLoader
}
val IncOptions = sbt.internal.inc.IncOptions
type Analysis = sbt.internal.inc.Analysis
val Analysis = sbt.internal.inc.Analysis
val ClassfileManager = sbt.internal.inc.ClassfileManager
type ScalaInstance = sbt.internal.inc.ScalaInstance
val ScalaInstance = sbt.internal.inc.ScalaInstance
}

3
sbt/src/sbt-test/actions/aggregate/project/Marker.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
import Project.Initialize import Project.Initialize
trait Marker trait Marker
@ -14,4 +15,4 @@ trait Marker
else else
IO touch toMark IO touch toMark
} }
} }

1
sbt/src/sbt-test/actions/aggregate/project/TestProject.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
object SingleBuild extends Build with Marker object SingleBuild extends Build with Marker
{ {

3
sbt/src/sbt-test/actions/compile-time-only/changes/A1.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Def.Initialize import Def.Initialize
import complete.{DefaultParsers, Parser} import complete.{DefaultParsers, Parser}
@ -11,4 +12,4 @@ object A {
val x3: Initialize[Int] = Def.setting { 3 } val x3: Initialize[Int] = Def.setting { 3 }
val y3 = Def.setting { x3.value } val y3 = Def.setting { x3.value }
} }

3
sbt/src/sbt-test/actions/compile-time-only/changes/A3.scala
View File

@ -1,8 +1,9 @@
import sbt._ import sbt._
import Import._
import Def.Initialize import Def.Initialize
import complete.{DefaultParsers, Parser} import complete.{DefaultParsers, Parser}
object A { object A {
val x1: Initialize[Parser[Int]] = Def.setting { DefaultParsers.success(3) } val x1: Initialize[Parser[Int]] = Def.setting { DefaultParsers.success(3) }
val y1 = Def.task { x1.parsed } val y1 = Def.task { x1.parsed }
} }

1
sbt/src/sbt-test/actions/depends-on/project/B.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
// tests that errors are properly propagated for dependsOn, map, and flatMap // tests that errors are properly propagated for dependsOn, map, and flatMap
object B extends Build object B extends Build

4
sbt/src/sbt-test/actions/eval-is-safe-and-sound/build.sbt
View File

@ -19,7 +19,7 @@ configClassCountFile := (target.value / "config-count")
numConfigClasses := { numConfigClasses := {
val cdir = (baseDirectory in ThisBuild).value / "project/target/config-classes" val cdir = (baseDirectory in ThisBuild).value / "project/target/config-classes"
(cdir.*** --- cdir).get.length (cdir.allPaths --- cdir).get.length
} }
saveNumConfigClasses := { saveNumConfigClasses := {
@ -46,4 +46,4 @@ checkNumConfigClasses := {
val previous = previousConfigCount.value val previous = previousConfigCount.value
val current = numConfigClasses.value val current = numConfigClasses.value
assert(previous == current, s"Failed to delete extra configuration classes. Expected: $previous, Found: $current") assert(previous == current, s"Failed to delete extra configuration classes. Expected: $previous, Found: $current")
} }

20
sbt/src/sbt-test/actions/join/build.sbt Normal file
View File

@ -0,0 +1,20 @@
lazy val intTask = taskKey[Int]("int")
lazy val root = (project in file(".")).
dependsOn(b, c).
settings(
intTask in Compile := {
// a sequence of tasks could be joined together
Seq(b, c).map(p => intTask in (p, Compile)).join.map( as => (1 /: as)(_ + _) ).value
}
)
lazy val b = (project in file("b")).
settings(
intTask in Compile := 1
)
lazy val c = (project in file("c")).
settings{
intTask in Compile := 2
}

11
sbt/src/sbt-test/actions/join/project/Build.scala
View File

@ -1,11 +0,0 @@
import sbt._
import Keys._
object Build extends Build
{
lazy val root = Project("root", file(".")) dependsOn(b,c) settings(
compile in Compile <<= Seq(b, c).map(p => compile in (p, Compile)).join.map( as => (inc.Analysis.Empty /: as)(_ ++ _) )
)
lazy val b = Project("b", file("b"))
lazy val c = Project("c", file("c"))
}

1
sbt/src/sbt-test/actions/reload/changes/Changed.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
object TestBuild extends Build object TestBuild extends Build
{ {

1
sbt/src/sbt-test/actions/reload/external/project/Ext.scala vendored
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
object Ext extends Build object Ext extends Build
{ {

1
sbt/src/sbt-test/actions/reload/project/TestProject.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
object TestBuild extends Build object TestBuild extends Build
{ {

1
sbt/src/sbt-test/actions/run-task/project/B.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build object B extends Build
{ {

3
sbt/src/sbt-test/actions/state/project/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
import complete.Parser import complete.Parser
import complete.DefaultParsers._ import complete.DefaultParsers._
import sbinary.DefaultProtocol._ import sbinary.DefaultProtocol._
@ -47,4 +48,4 @@ object MyBuild extends Build
def dummyTask = (key: Any) => maxErrors map { _ => () } def dummyTask = (key: Any) => maxErrors map { _ => () }
def str(o: Option[Int]) = o match { case None => "blue"; case Some(i) => i.toString } def str(o: Option[Int]) = o match { case None => "blue"; case Some(i) => i.toString }
} }

1
sbt/src/sbt-test/actions/update-state-fail/project/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object TestBuild extends Build object TestBuild extends Build
{ {

0
sbt/src/sbt-test/api/basic/src/main/scala/testCase/FooUser.scala → sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/FooUser.scala
View File

0
sbt/src/sbt-test/api/basic/src/main/scala/testCase/JFoo.java → sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/JFoo.java
View File

0
sbt/src/sbt-test/api/basic/src/main/scala/testCase/annotations.scala → sbt/src/sbt-test/apiinfo/basic/src/main/scala/testCase/annotations.scala
View File

0
sbt/src/sbt-test/api/basic/test → sbt/src/sbt-test/apiinfo/basic/test
View File

2
sbt/src/sbt-test/api/extracted/build.sbt → sbt/src/sbt-test/apiinfo/extracted/build.sbt
View File

@ -28,7 +28,7 @@ myTask in (sub, Compile) := "sub compile"
testTask("testRunTaskSubCompile", "sub compile", myTask in (sub, Compile)) testTask("testRunTaskSubCompile", "sub compile", myTask in (sub, Compile))
def argFunction(f: String => String) = Def.inputTask { def argFunction(f: String => String) = Def.inputTask {
import sbt.complete.Parsers._ import complete.Parsers._
f((OptSpace ~> StringBasic).parsed) f((OptSpace ~> StringBasic).parsed)
} }

0
sbt/src/sbt-test/api/extracted/test → sbt/src/sbt-test/apiinfo/extracted/test
View File

4
sbt/src/sbt-test/api/show-circular-structure/build.sbt → sbt/src/sbt-test/apiinfo/show-circular-structure/build.sbt
View File

@ -1,8 +1,8 @@
logLevel := Level.Debug logLevel := Level.Debug
incOptions ~= { _.copy(apiDebug = true) } incOptions ~= { _.withApiDebug(true) }
TaskKey[Unit]("show-apis") <<= (compile in Compile, scalaSource in Compile, javaSource in Compile) map { (a: sbt.inc.Analysis, scalaSrc: java.io.File, javaSrc: java.io.File) => TaskKey[Unit]("show-apis") <<= (compile in Compile, scalaSource in Compile, javaSource in Compile) map { (a: sbt.internal.inc.Analysis, scalaSrc: java.io.File, javaSrc: java.io.File) =>
val aApi = a.apis.internalAPI(scalaSrc / "A.scala").api val aApi = a.apis.internalAPI(scalaSrc / "A.scala").api
val jApi = a.apis.internalAPI(javaSrc / "test/J.java").api val jApi = a.apis.internalAPI(javaSrc / "test/J.java").api
import xsbt.api.DefaultShowAPI import xsbt.api.DefaultShowAPI

0
sbt/src/sbt-test/api/show-circular-structure/src/main/java/test/J.java → sbt/src/sbt-test/apiinfo/show-circular-structure/src/main/java/test/J.java
View File

0
sbt/src/sbt-test/api/show-circular-structure/src/main/scala/A.scala → sbt/src/sbt-test/apiinfo/show-circular-structure/src/main/scala/A.scala
View File

0
sbt/src/sbt-test/api/show-circular-structure/test → sbt/src/sbt-test/apiinfo/show-circular-structure/test
View File

2
sbt/src/sbt-test/api/unstable-existential-names/build.sbt → sbt/src/sbt-test/apiinfo/unstable-existential-names/build.sbt
View File

@ -1,6 +1,6 @@
// checks number of compilation iterations performed since last `clean` run // checks number of compilation iterations performed since last `clean` run
InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) => InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) =>
(argTask, compile in Compile) map { (args: Seq[String], a: sbt.inc.Analysis) => (argTask, compile in Compile) map { (args: Seq[String], a: sbt.internal.inc.Analysis) =>
assert(args.size == 1) assert(args.size == 1)
val expectedIterationsNumber = args(0).toInt val expectedIterationsNumber = args(0).toInt
val allCompilationsSize = a.compilations.allCompilations.size val allCompilationsSize = a.compilations.allCompilations.size

0
sbt/src/sbt-test/api/unstable-existential-names/changes/Foo1.scala → sbt/src/sbt-test/apiinfo/unstable-existential-names/changes/Foo1.scala
View File

0
sbt/src/sbt-test/api/unstable-existential-names/src/main/scala/Bar.scala → sbt/src/sbt-test/apiinfo/unstable-existential-names/src/main/scala/Bar.scala
View File

0
sbt/src/sbt-test/api/unstable-existential-names/src/main/scala/Foo.scala → sbt/src/sbt-test/apiinfo/unstable-existential-names/src/main/scala/Foo.scala
View File

0
sbt/src/sbt-test/api/unstable-existential-names/test → sbt/src/sbt-test/apiinfo/unstable-existential-names/test
View File

2
sbt/src/sbt-test/compiler-project/error-in-invalidated/build.sbt
View File

@ -1 +1 @@
incOptions := sbt.inc.IncOptions.Default incOptions := IncOptions.Default

2
sbt/src/sbt-test/compiler-project/inc-package-class-dependency/build.sbt
View File

@ -1,5 +1,5 @@
TaskKey[Unit]("verify-binary-deps") <<= (compile in Compile, classDirectory in Compile, baseDirectory) map { TaskKey[Unit]("verify-binary-deps") <<= (compile in Compile, classDirectory in Compile, baseDirectory) map {
(a: sbt.inc.Analysis, classDir: java.io.File, base: java.io.File) => (a: sbt.internal.inc.Analysis, classDir: java.io.File, base: java.io.File) =>
val nestedPkgClass = classDir / "test/nested.class" val nestedPkgClass = classDir / "test/nested.class"
val fooSrc = base / "src/main/scala/test/nested/Foo.scala" val fooSrc = base / "src/main/scala/test/nested/Foo.scala"
assert(!a.relations.binaryDeps(fooSrc).contains(nestedPkgClass), a.relations.toString) assert(!a.relations.binaryDeps(fooSrc).contains(nestedPkgClass), a.relations.toString)

2
sbt/src/sbt-test/compiler-project/inc-pickled-existential/build.sbt
View File

@ -2,7 +2,7 @@ logLevel := Level.Debug
// dumps analysis into target/analysis-dump.txt file // dumps analysis into target/analysis-dump.txt file
InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) => InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) =>
(argTask, compile in Compile) map { (args: Seq[String], a: sbt.inc.Analysis) => (argTask, compile in Compile) map { (args: Seq[String], a: Analysis) =>
assert(args.size == 1) assert(args.size == 1)
val expectedIterationsNumber = args(0).toInt val expectedIterationsNumber = args(0).toInt
assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber)) assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber))

2
sbt/src/sbt-test/compiler-project/inc-pickled-refinement/build.sbt
View File

@ -1,5 +1,5 @@
InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) => InputKey[Unit]("check-number-of-compiler-iterations") <<= inputTask { (argTask: TaskKey[Seq[String]]) =>
(argTask, compile in Compile) map { (args: Seq[String], a: sbt.inc.Analysis) => (argTask, compile in Compile) map { (args: Seq[String], a: Analysis) =>
assert(args.size == 1) assert(args.size == 1)
val expectedIterationsNumber = args(0).toInt val expectedIterationsNumber = args(0).toInt
assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber)) assert(a.compilations.allCompilations.size == expectedIterationsNumber, "a.compilations.allCompilations.size = %d (expected %d)".format(a.compilations.allCompilations.size, expectedIterationsNumber))

2
sbt/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt
View File

@ -5,7 +5,7 @@ scalaVersion := "2.10.4"
crossScalaVersions := List("2.10.4", "2.11.0") crossScalaVersions := List("2.10.4", "2.11.0")
incOptions := incOptions.value.withNewClassfileManager( incOptions := incOptions.value.withNewClassfileManager(
sbt.inc.ClassfileManager.transactional( ClassfileManager.transactional(
crossTarget.value / "classes.bak", crossTarget.value / "classes.bak",
(streams in (Compile, compile)).value.log (streams in (Compile, compile)).value.log
) )

41
sbt/src/sbt-test/dependency-management/artifact/build.sbt Normal file
View File

@ -0,0 +1,41 @@
import sbt.internal.inc.classpath.ClasspathUtilities
lazy val checkFull = TaskKey[Unit]("check-full")
lazy val check = TaskKey[Unit]("check")
lazy val root = (project in file(".")).
settings(
ivyPaths <<= (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))),
publishTo := Some(Resolver.file("Test Publish Repo", file("test-repo"))),
resolvers <+= baseDirectory { base => "Test Repo" at (base / "test-repo").toURI.toString },
moduleName := artifactID,
projectID <<= baseDirectory { base => (if(base / "retrieve" exists) retrieveID else publishedID) },
artifact in (Compile, packageBin) := mainArtifact,
libraryDependencies <<= (libraryDependencies, baseDirectory) { (deps, base) => deps ++ (if(base / "retrieve" exists) publishedID :: Nil else Nil) },
// needed to add a jar with a different type to the managed classpath
unmanagedClasspath in Compile <+= scalaInstance.map(_.libraryJar),
classpathTypes := Set(tpe),
check <<= checkTask(dependencyClasspath),
checkFull <<= checkTask(fullClasspath)
)
// define strings for defining the artifact
def artifactID = "test"
def ext = "test2"
def classifier = "test3"
def tpe = "test1"
def vers = "1.1"
def org = "test"
def mainArtifact = Artifact(artifactID, tpe, ext, classifier)
// define the IDs to use for publishing and retrieving
def publishedID = org % artifactID % vers artifacts(mainArtifact)
def retrieveID = org % "test-retrieve" % "2.0"
// check that the test class is on the compile classpath, either because it was compiled or because it was properly retrieved
def checkTask(classpath: TaskKey[Classpath]) = (classpath in Compile, scalaInstance) map { (cp, si) =>
val loader = ClasspathUtilities.toLoader(cp.files, si.loader)
try { Class.forName("test.Test", false, loader); () }
catch { case _: ClassNotFoundException | _: NoClassDefFoundError => sys.error("Dependency not retrieved properly") }
}

44
sbt/src/sbt-test/dependency-management/artifact/project/ArtifactTest.scala
View File

@ -1,44 +0,0 @@
import sbt._
import Keys._
object ArtifactTest extends Build
{
lazy val root = Project("root", file(".")) settings(
ivyPaths <<= (baseDirectory, target)( (dir, t) => new IvyPaths(dir, Some(t / "ivy-cache"))),
publishTo := Some(Resolver.file("Test Publish Repo", file("test-repo"))),
resolvers <+= baseDirectory { base => "Test Repo" at (base / "test-repo").toURI.toString },
moduleName := artifactID,
projectID <<= baseDirectory { base => (if(base / "retrieve" exists) retrieveID else publishedID) },
artifact in (Compile, packageBin) := mainArtifact,
libraryDependencies <<= (libraryDependencies, baseDirectory) { (deps, base) => deps ++ (if(base / "retrieve" exists) publishedID :: Nil else Nil) },
// needed to add a jar with a different type to the managed classpath
unmanagedClasspath in Compile <+= scalaInstance.map(_.libraryJar),
classpathTypes := Set(tpe),
check <<= checkTask(dependencyClasspath),
checkFull <<= checkTask(fullClasspath)
)
lazy val checkFull = TaskKey[Unit]("check-full")
lazy val check = TaskKey[Unit]("check")
// define strings for defining the artifact
def artifactID = "test"
def ext = "test2"
def classifier = "test3"
def tpe = "test1"
def vers = "1.1"
def org = "test"
def mainArtifact = Artifact(artifactID, tpe, ext, classifier)
// define the IDs to use for publishing and retrieving
def publishedID = org % artifactID % vers artifacts(mainArtifact)
def retrieveID = org % "test-retrieve" % "2.0"
// check that the test class is on the compile classpath, either because it was compiled or because it was properly retrieved
def checkTask(classpath: TaskKey[Classpath]) = (classpath in Compile, scalaInstance) map { (cp, si) =>
val loader = sbt.classpath.ClasspathUtilities.toLoader(cp.files, si.loader)
try { Class.forName("test.Test", false, loader); () }
catch { case _: ClassNotFoundException | _: NoClassDefFoundError => sys.error("Dependency not retrieved properly") }
}
}

1
sbt/src/sbt-test/dependency-management/cache-resolver/changes/def/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build { object B extends Build {

2
sbt/src/sbt-test/dependency-management/cache-update/build.sbt
View File

@ -13,7 +13,7 @@ lazy val root = (project in file(".")).
dependencyOverrides in ThisBuild += "com.github.nscala-time" %% "nscala-time" % "1.0.0", dependencyOverrides in ThisBuild += "com.github.nscala-time" %% "nscala-time" % "1.0.0",
libraryDependencies += "com.github.nscala-time" %% "nscala-time" % "1.0.0", libraryDependencies += "com.github.nscala-time" %% "nscala-time" % "1.0.0",
check := { check := {
import sbt.Cache._, sbt.CacheIvy.updateIC import Cache._, CacheIvy.updateIC
implicit val updateCache = updateIC implicit val updateCache = updateIC
type In = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil type In = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil
val s = (streams in update).value val s = (streams in update).value

1
sbt/src/sbt-test/dependency-management/delegate/project/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build object B extends Build
{ {

21
sbt/src/sbt-test/dependency-management/exclude-scala/build.sbt Normal file
View File

@ -0,0 +1,21 @@
lazy val scalaOverride = taskKey[Unit]("Check that the proper version of Scala is on the classpath.")
lazy val root = (project in file(".")).
settings(
libraryDependencies <++= baseDirectory(dependencies),
scalaVersion := "2.9.2",
autoScalaLibrary <<= baseDirectory(base => !(base / "noscala").exists ),
scalaOverride <<= check("scala.App")
)
def check(className: String): Def.Initialize[Task[Unit]] = fullClasspath in Compile map { cp =>
val existing = cp.files.filter(_.getName contains "scala-library")
println("Full classpath: " + cp.mkString("\n\t", "\n\t", ""))
println("scala-library.jar: " + existing.mkString("\n\t", "\n\t", ""))
val loader = classpath.ClasspathUtilities.toLoader(existing)
Class.forName(className, false, loader)
}
def dependencies(base: File) =
if( ( base / "stm").exists ) ("org.scala-tools" % "scala-stm_2.8.2" % "0.6") :: Nil
else Nil

27
sbt/src/sbt-test/dependency-management/exclude-scala/project/ExcludeScala.scala
View File

@ -1,27 +0,0 @@
import sbt._
import Keys._
object ExcludeScala extends Build
{
lazy val root = Project("root", file(".")) settings(
libraryDependencies <++= baseDirectory(dependencies),
scalaVersion := "2.9.2",
autoScalaLibrary <<= baseDirectory(base => !(base / "noscala").exists ),
scalaOverride <<= check("scala.App")
)
def check(className: String): Def.Initialize[Task[Unit]] = fullClasspath in Compile map { cp =>
val existing = cp.files.filter(_.getName contains "scala-library")
println("Full classpath: " + cp.mkString("\n\t", "\n\t", ""))
println("scala-library.jar: " + existing.mkString("\n\t", "\n\t", ""))
val loader = classpath.ClasspathUtilities.toLoader(existing)
Class.forName(className, false, loader)
}
lazy val scalaOverride = taskKey[Unit]("Check that the proper version of Scala is on the classpath.")
def dependencies(base: File) =
if( ( base / "stm").exists )
("org.scala-tools" % "scala-stm_2.8.2" % "0.6") :: Nil
else
Nil
}

1
sbt/src/sbt-test/dependency-management/exclude-transitive/project/TestProject.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
object TestProject extends Build object TestProject extends Build

1
sbt/src/sbt-test/dependency-management/force/project/TestProject.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
object TestProject extends Build object TestProject extends Build

0
sbt/src/sbt-test/dependency-management/gh-1484-npe/test → sbt/src/sbt-test/dependency-management/gh-1484-npe/pending
View File

3
sbt/src/sbt-test/dependency-management/info/project/InfoTest.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
import scala.xml._ import scala.xml._
@ -39,4 +40,4 @@ object InfoTest extends Build
if( deliveredWithCustom(d) ) sys.error("Expected empty 'info' tag, got: \n" + (d \ "info")) else () if( deliveredWithCustom(d) ) sys.error("Expected empty 'info' tag, got: \n" + (d \ "info")) else ()
} }
def deliveredWithCustom(d: NodeSeq) = (d \ "info" \ "license").nonEmpty && (d \ "info" \ "description").nonEmpty def deliveredWithCustom(d: NodeSeq) = (d \ "info" \ "license").nonEmpty && (d \ "info" \ "description").nonEmpty
} }

2
sbt/src/sbt-test/dependency-management/inline-dependencies-a/build.sbt
View File

@ -1,3 +1,5 @@
import sbt.internal.librarymanagement.syntax._
libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5" libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5"
ivyPaths <<= baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy-home"))) ivyPaths <<= baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy-home")))

1
sbt/src/sbt-test/dependency-management/invalidate-internal/project/P.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object P extends Build object P extends Build
{ {

2
sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt
View File

@ -1,3 +1,5 @@
import sbt.internal.librarymanagement.syntax._
seq(externalIvySettings(), externalIvyFile()) seq(externalIvySettings(), externalIvyFile())
TaskKey[Unit]("check") := { TaskKey[Unit]("check") := {

2
sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt
View File

@ -1,3 +1,5 @@
import sbt.internal.librarymanagement.syntax._
externalIvySettings() externalIvySettings()
libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5" libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5"

5
sbt/src/sbt-test/dependency-management/ivy-settings-c/project/P.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
object B extends Build object B extends Build
@ -24,9 +25,9 @@ object B extends Build
lazy val baseSettings = Seq( lazy val baseSettings = Seq(
autoScalaLibrary := false, autoScalaLibrary := false,
ivyScala := None, ivyScala := None,
unmanagedJars in Compile <++= scalaInstance map (_.jars), unmanagedJars in Compile <++= scalaInstance map (_.allJars.toSeq),
publishArtifact in packageSrc := false, publishArtifact in packageSrc := false,
publishArtifact in packageDoc := false, publishArtifact in packageDoc := false,
publishMavenStyle := false publishMavenStyle := false
) )
} }

3
sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/project/P.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build object B extends Build
{ {
@ -13,6 +14,6 @@ object B extends Build
) )
lazy val baseSettings = Seq( lazy val baseSettings = Seq(
autoScalaLibrary := false, autoScalaLibrary := false,
unmanagedJars in Compile <++= scalaInstance map (_.jars) unmanagedJars in Compile <++= scalaInstance map (_.allJars.toSeq)
) )
} }

1
sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/project/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object Build extends Build object Build extends Build
{ {

5
sbt/src/sbt-test/dependency-management/java.net/build.sbt
View File

@ -1,5 +0,0 @@
ivyPaths <<= baseDirectory( dir => new IvyPaths(dir, Some(dir / "ivy-home")))
resolvers += JavaNet1Repository
libraryDependencies += "javax.ejb" % "ejb-api" % "3.0"

1
sbt/src/sbt-test/dependency-management/java.net/test
View File

@ -1 +0,0 @@
> update

1
sbt/src/sbt-test/dependency-management/make-pom-type/project/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object build extends Build { object build extends Build {
override def settings = super.settings ++ Seq( override def settings = super.settings ++ Seq(

3
sbt/src/sbt-test/dependency-management/make-pom/project/MakePomTest.scala
View File

@ -1,4 +1,5 @@
import sbt.{Node =>_,_} import sbt.{Node =>_,_}
import Import._
import Keys._ import Keys._
import scala.xml._ import scala.xml._
@ -73,4 +74,4 @@ object MakePomTest extends Build
if(base.endsWith("/")) base else (base + "/") if(base.endsWith("/")) base else (base + "/")
} }
def normalize(repo: MavenRepository): MavenRepository = new MavenRepository(repo.name, normalize(repo.root)) def normalize(repo: MavenRepository): MavenRepository = new MavenRepository(repo.name, normalize(repo.root))
} }

1
sbt/src/sbt-test/dependency-management/parent-publish/project/Parent.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
object ParentTest extends Build object ParentTest extends Build
{ {

3
sbt/src/sbt-test/dependency-management/pom-advanced/project/PomRepoTest.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
import complete.DefaultParsers._ import complete.DefaultParsers._
@ -34,4 +35,4 @@ object PomRepoTest extends Build
extracted.find { e => !expected.exists(_.accept(e.root)) } map { "Repository should not be exported: " + _ } orElse extracted.find { e => !expected.exists(_.accept(e.root)) } map { "Repository should not be exported: " + _ } orElse
(expected.find { e => !extracted.exists(r => e.accept(r.root)) } map { "Repository should be exported: " + _ } ) foreach error (expected.find { e => !extracted.exists(r => e.accept(r.root)) } map { "Repository should be exported: " + _ } ) foreach error
} }
} }

3
sbt/src/sbt-test/dependency-management/pom-classpaths/project/Build.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
import complete._ import complete._
import complete.DefaultParsers._ import complete.DefaultParsers._
@ -34,4 +35,4 @@ object MyBuild extends Build
() ()
} }
def seqStr(s: Seq[_]) = s.mkString("\n\t", "\n\t", "\n") def seqStr(s: Seq[_]) = s.mkString("\n\t", "\n\t", "\n")
} }

1
sbt/src/sbt-test/dependency-management/pom-packaging/project/PomTest.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object PomTest extends Build object PomTest extends Build
{ {

1
sbt/src/sbt-test/dependency-management/pom-scope/project/PomTest.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object PomTest extends Build object PomTest extends Build
{ {

2
sbt/src/sbt-test/dependency-management/provided-multi/changes/P.scala
View File

@ -1,5 +1,7 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object P extends Build object P extends Build
{ {
override def settings = super.settings ++ Seq( override def settings = super.settings ++ Seq(

3
sbt/src/sbt-test/dependency-management/provided/project/TestProject.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
import complete.DefaultParsers._ import complete.DefaultParsers._
@ -31,4 +32,4 @@ object TestProject extends Build
else else
servletAPI.foreach(s => sys.error(s + " incorrectly included in " + label + ".")) servletAPI.foreach(s => sys.error(s + " incorrectly included in " + label + "."))
} }
} }

1
sbt/src/sbt-test/dependency-management/publish-local/changes/RetrieveTest.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
object MultiPublishTest extends Build object MultiPublishTest extends Build

3
sbt/src/sbt-test/dependency-management/publish-local/project/MultiPublishTest.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
object MultiPublishTest extends Build object MultiPublishTest extends Build
@ -18,4 +19,4 @@ object MultiPublishTest extends Build
def interProject = def interProject =
projectDependencies <<= (publishMavenStyle, publishMavenStyle in sub, projectDependencies) map { (style, subStyle, pd) => if(style == subStyle) pd else Nil } projectDependencies <<= (publishMavenStyle, publishMavenStyle in sub, projectDependencies) map { (style, subStyle, pd) => if(style == subStyle) pd else Nil }
} }

2
sbt/src/sbt-test/dependency-management/scala-home/build.sbt
View File

@ -2,6 +2,6 @@ val makeHome = taskKey[Unit]("Populates the 'home/lib' directory with Scala jars
makeHome := { makeHome := {
val lib = baseDirectory.value / "home" / "lib" val lib = baseDirectory.value / "home" / "lib"
for(jar <- scalaInstance.value.jars) for(jar <- scalaInstance.value.allJars)
IO.copyFile(jar, lib / jar.getName) IO.copyFile(jar, lib / jar.getName)
} }

2
sbt/src/sbt-test/dependency-management/scala-home/changes/real-build.sbt
View File

@ -1,3 +1,5 @@
import sbt.internal.librarymanagement.syntax._
scalaHome := Some(baseDirectory.value / "home") scalaHome := Some(baseDirectory.value / "home")
val checkUpdate = taskKey[Unit]("Ensures that resolved Scala artifacts are replaced with ones from the configured Scala home directory") val checkUpdate = taskKey[Unit]("Ensures that resolved Scala artifacts are replaced with ones from the configured Scala home directory")

4
sbt/src/sbt-test/dependency-management/sources/project/Test.scala
View File

@ -1,5 +1,7 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
import sbt.internal.librarymanagement.syntax._
object Test extends Build object Test extends Build
{ {
@ -28,4 +30,4 @@ object Test extends Build
val srcs = getSources(report) val srcs = getSources(report)
if(srcs.nonEmpty) sys.error("Sources retrieved:\n\t" + srcs.mkString("\n\t")) else () if(srcs.nonEmpty) sys.error("Sources retrieved:\n\t" + srcs.mkString("\n\t")) else ()
} }
} }

3
sbt/src/sbt-test/dependency-management/url/project/TestProject.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
import classpath.ClasspathUtilities import classpath.ClasspathUtilities
@ -24,4 +25,4 @@ object TestProject extends Build
case _: ClassNotFoundException => sys.error("Dependency not downloaded.") case _: ClassNotFoundException => sys.error("Dependency not downloaded.")
} }
} }
} }

0
sbt/src/sbt-test/ivy-deps-management/update-classifiers-snapshot-srcs/test → sbt/src/sbt-test/ivy-deps-management/update-classifiers-snapshot-srcs/pending
View File

23
sbt/src/sbt-test/java/no-scala-tool/test
View File

@ -1,14 +1,17 @@
# test that a pure Java project can be compiled without a dependency on Scala library # test that a pure Java project can be compiled without a dependency on Scala library
> compile > compile
# It can use the Scala REPL for the version of Scala that sbt runs with
> console
# A different version of Scala needs to be resolved, but we don't have any resolvers configured ## Scala tools are resolved using ivy, so did we lose the ability to use the same Scala instance that sbt runs with?
> ++2.8.2 ##
-> console ## It can use the Scala REPL for the version of Scala that sbt runs with
#> console
# With an explicit scalaInstance, the Scala tools configuration won't be resolved ##
$ copy-file changes/explicitInstance.sbt explicitInstance.sbt ## A different version of Scala needs to be resolved, but we don't have any resolvers configured
> reload #> ++2.8.2
> console #-> console
##
## With an explicit scalaInstance, the Scala tools configuration won't be resolved
#$ copy-file changes/explicitInstance.sbt explicitInstance.sbt
#> reload
#> console

4
sbt/src/sbt-test/java/track-anonymous/build.sbt
View File

@ -1,5 +1,5 @@
{ {
import sbt.complete.DefaultParsers._ import complete.DefaultParsers._
val parser = token(Space ~> ( ("exists" ^^^ true) | ("absent" ^^^ false) ) ) val parser = token(Space ~> ( ("exists" ^^^ true) | ("absent" ^^^ false) ) )
InputKey[Unit]("check-output") := { InputKey[Unit]("check-output") := {
val shouldExist = parser.parsed val shouldExist = parser.parsed
@ -11,4 +11,4 @@
else else
() ()
} }
} }

0
sbt/src/sbt-test/project-load/sha-conflict/test → sbt/src/sbt-test/project-load/sha-conflict/pending
View File

2
sbt/src/sbt-test/project/auto-plugins/project/A.scala
View File

@ -44,4 +44,4 @@ object TopC extends AutoPlugin {
lazy val topLevelKeyTest = settingKey[String]("A top level setting declared in a plugin.") lazy val topLevelKeyTest = settingKey[String]("A top level setting declared in a plugin.")
} }
} }

1
sbt/src/sbt-test/project/auto-plugins/project/Q.scala
View File

@ -1,6 +1,7 @@
package sbttest // you need package http://stackoverflow.com/questions/9822008/ package sbttest // you need package http://stackoverflow.com/questions/9822008/
import sbt._ import sbt._
import Import._
import sbt.Keys.{name, resolvedScoped, organization } import sbt.Keys.{name, resolvedScoped, organization }
import java.util.concurrent.atomic.{AtomicInteger => AInt} import java.util.concurrent.atomic.{AtomicInteger => AInt}

1
sbt/src/sbt-test/project/auto-settings/project/P.scala
View File

@ -2,6 +2,7 @@
import Keys._ import Keys._
import AddSettings._ import AddSettings._
import Import._
object B extends Build object B extends Build
{ {

1
sbt/src/sbt-test/project/binary-plugin/changes/define/A.scala
View File

@ -2,6 +2,7 @@ package sbttest // you need package http://stackoverflow.com/questions/9822008/
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object C extends AutoPlugin { object C extends AutoPlugin {
object autoImport { object autoImport {

1
sbt/src/sbt-test/project/build-deps/project/B.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build object B extends Build
{ {

1
sbt/src/sbt-test/project/build-loaders/project/build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object EmptyLoaderBuild extends Build { object EmptyLoaderBuild extends Build {
override def buildLoaders = BuildLoader.transform(_.unit) :: Nil override def buildLoaders = BuildLoader.transform(_.unit) :: Nil

1
sbt/src/sbt-test/project/circular/project/P.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object Build extends Build { object Build extends Build {

1
sbt/src/sbt-test/project/console/project/Build.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
object B extends Build object B extends Build
{ {

0
sbt/src/sbt-test/project/continuations/test → sbt/src/sbt-test/project/continuations/pending
View File

1
sbt/src/sbt-test/project/delegate_config/project/Build.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import complete.DefaultParsers._ import complete.DefaultParsers._
import Keys._ import Keys._
import AddSettings._ import AddSettings._

1
sbt/src/sbt-test/project/delegates/project/Build.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import complete.DefaultParsers._ import complete.DefaultParsers._
import Keys._ import Keys._

1
sbt/src/sbt-test/project/external-conflict/changes/Build.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
object B extends Build object B extends Build

1
sbt/src/sbt-test/project/extra/project/B.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build object B extends Build
{ {

1
sbt/src/sbt-test/project/flatten/project/Flat.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import Keys._ import Keys._
import Configurations.{Compile, Test} import Configurations.{Compile, Test}

1
sbt/src/sbt-test/project/global-plugin/changes/Build.scala
View File

@ -1,4 +1,5 @@
import sbt._ import sbt._
import Import._
import sbt.Keys._ import sbt.Keys._
object MyBuild extends Build { object MyBuild extends Build {

1
sbt/src/sbt-test/project/isolated-build-definitions/generator/project/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build { object B extends Build {
lazy val project = Project(id = "project", lazy val project = Project(id = "project",

1
sbt/src/sbt-test/project/isolated-build-definitions/project/Build.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys._ import Keys._
import Import._
object B extends Build object B extends Build
{ {

1
sbt/src/sbt-test/project/multi/changes/Build1.scala
View File

@ -1,6 +1,7 @@
import sbt._ import sbt._
import Keys.name import Keys.name
import AddSettings._ import AddSettings._
import Import._
object TestBuild extends Build object TestBuild extends Build
{ {

1
sbt/src/sbt-test/project/multi/changes/Build2.scala
View File

@ -1,5 +1,6 @@
import sbt._ import sbt._
import Keys.name import Keys.name
import Import._
object TestBuild extends MakeBuild object TestBuild extends MakeBuild
{ {

Some files were not shown because too many files have changed in this diff Show More