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

Merge pull request #3322 from sbt/wip/integration 

Bump all modules to latest
This commit is contained in:
eugene yokota 2017-07-16 23:45:46 -04:00 committed by GitHub
parent 716d664d64 c9fae43595
commit e6a70f9864
69 changed files with 776 additions and 622 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
build.sbt
View File

@ -241,11 +241,11 @@ lazy val actionsProj = (project in file("main-actions"))
addSbtIO,
addSbtUtilLogging,
addSbtUtilRelation,
addSbtUtilTracking,
addSbtCompilerInterface,
addSbtCompilerClasspath,
addSbtCompilerApiInfo,
addSbtUtilTracking,
addSbtLm,
addSbtLmCore,
addSbtCompilerIvyIntegration,
addSbtZinc
)
@ -281,7 +281,7 @@ lazy val commandProj = (project in file("main-command"))
addSbtUtilLogging,
addSbtCompilerInterface,
addSbtCompilerClasspath,
addSbtLm
addSbtLmCore
)
// The core macro project defines the main logic of the DSL, abstracted
@ -329,7 +329,7 @@ lazy val mainSettingsProj = (project in file("main-settings"))
addSbtUtilRelation,
addSbtCompilerInterface,
addSbtCompilerClasspath,
addSbtLm
addSbtLmCore
)
// The main integration project for sbt. It brings all of the projects together, configures them, and provides for overriding conventions.
@ -347,10 +347,10 @@ lazy val mainProj = (project in file("main"))
.configure(
addSbtIO,
addSbtUtilLogging,
addSbtLmCore,
addSbtLmIvy,
addSbtCompilerInterface,
addSbtLm,
addSbtZincCompile
)
addSbtZincCompile)
// Strictly for bringing implicits and aliases from subsystems into the top-level sbt namespace through a single package object
// technically, we need a dependency on all of mainProj's dependencies, but we don't do that since this is strictly an integration project

3
main-actions/src/main/scala/sbt/Package.scala
View File

@ -120,7 +120,6 @@ object Package {
def sourcesDebugString(sources: Seq[(File, String)]): String =
"Input file mappings:\n\t" + (sources map { case (f, s) => s + "\n\t " + f } mkString ("\n\t"))
implicit def manifestEquiv: Equiv[Manifest] = defaultEquiv
implicit def manifestFormat: JsonFormat[Manifest] = projectFormat[Manifest, Array[Byte]](
m => {
val bos = new java.io.ByteArrayOutputStream()
@ -129,6 +128,4 @@ object Package {
},
bs => new Manifest(new java.io.ByteArrayInputStream(bs))
)
implicit def stringMapEquiv: Equiv[Map[File, String]] = defaultEquiv
}

4
main-actions/src/main/scala/sbt/RawCompileLike.scala
View File

@ -16,6 +16,7 @@ import sbt.util.CacheImplicits._
import sbt.util.Tracked.inputChanged
import sbt.util.{ CacheStoreFactory, FilesInfo, HashFileInfo, ModifiedFileInfo, PlainFileInfo }
import sbt.internal.util.HNil
import sbt.internal.util.HListFormats._
import sbt.util.FileInfo.{ exists, hash, lastModified }
import xsbti.compile.ClasspathOptions
@ -51,9 +52,6 @@ object RawCompileLike {
val inputs
: Inputs = hash(sources.toSet ++ optionFiles(options, fileInputOpts)) :+: lastModified(
classpath.toSet) :+: classpath :+: outputDirectory :+: options :+: maxErrors :+: HNil
implicit val stringEquiv: Equiv[String] = defaultEquiv
implicit val fileEquiv: Equiv[File] = defaultEquiv
implicit val intEquiv: Equiv[Int] = defaultEquiv
val cachedComp = inputChanged(cacheStoreFactory make "inputs") { (inChanged, in: Inputs) =>
inputChanged(cacheStoreFactory make "output") {
(outChanged, outputs: FilesInfo[PlainFileInfo]) =>

19
main-actions/src/test/scala/sbt/CacheIvyTest.scala
View File

@ -4,6 +4,7 @@ import org.scalacheck._
import org.scalacheck.Arbitrary._
import Prop._
import sbt.librarymanagement._
import sjsonnew.shaded.scalajson.ast.unsafe.JValue
class CacheIvyTest extends Properties("CacheIvy") {
import sbt.util.{ CacheStore, SingletonCache }
@ -12,8 +13,6 @@ class CacheIvyTest extends Properties("CacheIvy") {
import sjsonnew._
import sjsonnew.support.scalajson.unsafe.Converter
import scalajson.ast.unsafe.JValue
private class InMemoryStore(converter: SupportConverter[JValue]) extends CacheStore {
private var content: JValue = _
override def delete(): Unit = ()
@ -46,14 +45,20 @@ class CacheIvyTest extends Properties("CacheIvy") {
eq(out, m) :| s"Expected: ${str(m)}" :| s"Got: ${str(out)}"
}
implicit val arbExclusionRule: Arbitrary[ExclusionRule] = Arbitrary(
implicit val arbConfigRef: Arbitrary[ConfigRef] = Arbitrary(
for {
n <- Gen.alphaStr
} yield ConfigRef(n)
)
implicit val arbExclusionRule: Arbitrary[InclExclRule] = Arbitrary(
for {
o <- Gen.alphaStr
n <- Gen.alphaStr
a <- Gen.alphaStr
v <- arbCrossVersion.arbitrary
cs <- arbitrary[List[String]]
} yield ExclusionRule(o, n, a, cs.toVector, v)
cs <- arbitrary[List[ConfigRef]]
} yield InclExclRule(o, n, a, cs.toVector, v)
)
implicit val arbCrossVersion: Arbitrary[CrossVersion] = Arbitrary {
@ -78,8 +83,8 @@ class CacheIvyTest extends Properties("CacheIvy") {
isTransitive <- arbitrary[Boolean]
isForce <- arbitrary[Boolean]
explicitArtifacts <- Gen.listOf(arbitrary[Artifact])
exclusions <- Gen.listOf(arbitrary[ExclusionRule])
inclusions <- Gen.listOf(arbitrary[InclusionRule])
exclusions <- Gen.listOf(arbitrary[InclExclRule])
inclusions <- Gen.listOf(arbitrary[InclExclRule])
extraAttributes <- Gen.mapOf(arbitrary[(String, String)])
crossVersion <- arbitrary[CrossVersion]
} yield

4
main-command/src/main/scala/sbt/Highlight.scala
View File

@ -9,7 +9,7 @@ object Highlight {
def showMatches(pattern: Pattern)(line: String): Option[String] = {
val matcher = pattern.matcher(line)
if (ConsoleAppender.formatEnabled) {
if (ConsoleAppender.formatEnabledInEnv) {
// ANSI codes like \033[39m (normal text color) don't work on Windows
val highlighted = matcher.replaceAll(scala.Console.RED + "$0" + RESET)
if (highlighted == line) None else Some(highlighted)
@ -19,5 +19,5 @@ object Highlight {
None
}
def bold(s: String) =
if (ConsoleAppender.formatEnabled) BOLD + s.replace(RESET, RESET + BOLD) + RESET else s
if (ConsoleAppender.formatEnabledInEnv) BOLD + s.replace(RESET, RESET + BOLD) + RESET else s
}

8
main-settings/src/main/scala/sbt/Append.scala
View File

@ -56,6 +56,14 @@ object Append {
})
def appendValue(a: List[T], b: V): List[T] = a :+ (b: T)
}
implicit def appendVectorImplicit[T, V](implicit ev: V => T): Sequence[Vector[T], Seq[V], V] =
new Sequence[Vector[T], Seq[V], V] {
def appendValues(a: Vector[T], b: Seq[V]): Vector[T] =
a ++ (b map { x =>
(x: T)
})
def appendValue(a: Vector[T], b: V): Vector[T] = a :+ (b: T)
}
implicit def appendString: Value[String, String] = new Value[String, String] {
def appendValue(a: String, b: String) = a + b
}

2
main-settings/src/main/scala/sbt/Def.scala
View File

@ -68,7 +68,7 @@ object Def extends Init[Scope] with TaskMacroExtra {
Scope.displayMasked(scoped.scope, scoped.key.label, mask)
def withColor(s: String, color: Option[String]): String = {
val useColor = ConsoleAppender.formatEnabled
val useColor = ConsoleAppender.formatEnabledInEnv
color match {
case Some(c) if useColor => c + s + scala.Console.RESET
case _ => s

8
main-settings/src/main/scala/sbt/std/TaskLinterDSL.scala
View File

@ -145,10 +145,10 @@ object OnlyTaskDynLinterDSL extends BaseTaskLinterDSL {
}
object TaskLinterDSLFeedback {
private final val startBold = if (ConsoleAppender.formatEnabled) AnsiColor.BOLD else ""
private final val startRed = if (ConsoleAppender.formatEnabled) AnsiColor.RED else ""
private final val startGreen = if (ConsoleAppender.formatEnabled) AnsiColor.GREEN else ""
private final val reset = if (ConsoleAppender.formatEnabled) AnsiColor.RESET else ""
private final val startBold = if (ConsoleAppender.formatEnabledInEnv) AnsiColor.BOLD else ""
private final val startRed = if (ConsoleAppender.formatEnabledInEnv) AnsiColor.RED else ""
private final val startGreen = if (ConsoleAppender.formatEnabledInEnv) AnsiColor.GREEN else ""
private final val reset = if (ConsoleAppender.formatEnabledInEnv) AnsiColor.RESET else ""
private final val ProblemHeader = s"${startRed}Problem${reset}"
private final val SolutionHeader = s"${startGreen}Solution${reset}"

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

@ -48,8 +48,7 @@ import sbt.io.{
PathFinder,
SimpleFileFilter,
DirectoryFilter,
Hash,
WatchService
Hash
}, Path._
import sbt.librarymanagement.Artifact.{ DocClassifier, SourceClassifier }
import sbt.librarymanagement.Configurations.{
@ -62,9 +61,10 @@ import sbt.librarymanagement.Configurations.{
Test
}
import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion }
import sbt.librarymanagement.{ `package` => _, _ }
import sbt.librarymanagement._
import sbt.librarymanagement.ivy._
import sbt.librarymanagement.syntax._
import sbt.util.InterfaceUtil.f1
import sbt.util.InterfaceUtil.{ toJavaFunction => f1 }
import sbt.util._
import sbt.util.CacheImplicits._
import scala.concurrent.duration.FiniteDuration
@ -72,9 +72,10 @@ import scala.util.control.NonFatal
import scala.xml.NodeSeq
import Scope.{ fillTaskAxis, GlobalScope, ThisScope }
import sjsonnew.{ IsoLList, JsonFormat, LList, LNil }, LList.:*:
import sjsonnew.shaded.scalajson.ast.unsafe.JValue
import std.TaskExtra._
import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint }
import xsbti.compile.IncToolOptionsUtil
import xsbti.compile.{ IncToolOptionsUtil, AnalysisContents, IncOptions }
import xsbti.CrossValue
// incremental compiler
@ -101,7 +102,7 @@ import sbt.internal.inc.{
Analysis,
FileValueCache,
Locate,
LoggerReporter,
ManagedLoggedReporter,
MixedAnalyzingCompiler,
ScalaInstance
}
@ -376,8 +377,8 @@ object Defaults extends BuildCommon {
def compileBase = inTask(console)(compilersSetting :: Nil) ++ compileBaseGlobal ++ Seq(
incOptions := incOptions.value
.withClassfileManagerType(
Option(new TransactionalManagerType(crossTarget.value / "classes.bak",
sbt.util.Logger.Null): ClassFileManagerType).toOptional
Option(TransactionalManagerType
.of(crossTarget.value / "classes.bak", sbt.util.Logger.Null): ClassFileManagerType).toOptional
),
scalaInstance := scalaInstanceTask.value,
crossVersion := (if (crossPaths.value) CrossVersion.binary else Disabled()),
@ -413,7 +414,7 @@ object Defaults extends BuildCommon {
// must be a val: duplication detected by object identity
private[this] lazy val compileBaseGlobal: Seq[Setting[_]] = globalDefaults(
Seq(
incOptions := IncOptionsUtil.defaultIncOptions,
incOptions := IncOptions.of(),
classpathOptions :== ClasspathOptionsUtil.boot,
classpathOptions in console :== ClasspathOptionsUtil.repl,
compileOrder :== CompileOrder.Mixed,
@ -470,7 +471,7 @@ object Defaults extends BuildCommon {
globalLock = launcher.globalLock,
componentProvider = app.provider.components,
secondaryCacheDir = Option(zincDir),
ivyConfiguration = bootIvyConfiguration.value,
dependencyResolution = dependencyResolution.value,
compilerBridgeSource = scalaCompilerBridgeSource.value,
scalaJarsTarget = zincDir,
log = streams.value.log
@ -492,8 +493,11 @@ object Defaults extends BuildCommon {
}
}
def defaultCompileSettings: Seq[Setting[_]] =
globalDefaults(enableBinaryCompileAnalysis := true)
lazy val configTasks: Seq[Setting[_]] = docTaskSettings(doc) ++ inTask(compile)(
compileInputsSettings) ++ configGlobal ++ compileAnalysisSettings ++ Seq(
compileInputsSettings) ++ configGlobal ++ defaultCompileSettings ++ compileAnalysisSettings ++ Seq(
compile := compileTask.value,
manipulateBytecode := compileIncremental.value,
compileIncremental := (compileIncrementalTask tag (Tags.Compile, Tags.CPU)).value,
@ -622,7 +626,7 @@ object Defaults extends BuildCommon {
}
def scalaInstanceFromUpdate: Initialize[Task[ScalaInstance]] = Def.task {
val toolReport = update.value.configuration(Configurations.ScalaTool.name) getOrElse
val toolReport = update.value.configuration(Configurations.ScalaTool) getOrElse
sys.error(noToolConfiguration(managedScalaInstance.value))
def files(id: String) =
for {
@ -1062,12 +1066,13 @@ object Defaults extends BuildCommon {
case c => Some(c.name)
}
val combined = cPart.toList ++ classifier.toList
if (combined.isEmpty) a.withClassifier(None).withConfigurations(cOpt.toVector)
val configurations = cOpt.map(c => ConfigRef(c.name)).toVector
if (combined.isEmpty) a.withClassifier(None).withConfigurations(configurations)
else {
val classifierString = combined mkString "-"
a.withClassifier(Some(classifierString))
.withType(Artifact.classifierType(classifierString))
.withConfigurations(cOpt.toVector)
.withConfigurations(configurations)
}
}
@ -1253,7 +1258,7 @@ object Defaults extends BuildCommon {
}
}
}
def psTask: Initialize[Task[Vector[JobHandle]]] =
def psTask: Initialize[Task[Seq[JobHandle]]] =
Def.task {
val xs = bgList.value
val s = streams.value
@ -1369,11 +1374,14 @@ object Defaults extends BuildCommon {
def compileTask: Initialize[Task[CompileAnalysis]] = Def.task {
val setup: Setup = compileIncSetup.value
val useBinary: Boolean = enableBinaryCompileAnalysis.value
// TODO - expose bytecode manipulation phase.
val analysisResult: CompileResult = manipulateBytecode.value
if (analysisResult.hasModified) {
val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile)
store.set(analysisResult.analysis, analysisResult.setup)
val store =
MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile, !useBinary)
val contents = AnalysisContents.create(analysisResult.analysis(), analysisResult.setup())
store.set(contents)
}
analysisResult.analysis
}
@ -1410,7 +1418,7 @@ object Defaults extends BuildCommon {
override def definesClass(classpathEntry: File): DefinesClass =
cachedPerEntryDefinesClassLookup(classpathEntry)
}
new Setup(
Setup.of(
lookup,
(skip in compile).value,
// TODO - this is kind of a bad way to grab the cache directory for streams...
@ -1425,7 +1433,7 @@ object Defaults extends BuildCommon {
}
def compileInputsSettings: Seq[Setting[_]] = {
Seq(
compileOptions := new CompileOptions(
compileOptions := CompileOptions.of(
(classDirectory.value +: data(dependencyClasspath.value)).toArray,
sources.value.toArray,
classDirectory.value,
@ -1435,10 +1443,14 @@ object Defaults extends BuildCommon {
f1(foldMappers(sourcePositionMappers.value)),
compileOrder.value
),
compilerReporter := new LoggerReporter(maxErrors.value,
streams.value.log,
foldMappers(sourcePositionMappers.value)),
compileInputs := new Inputs(
compilerReporter := {
new ManagedLoggedReporter(
maxErrors.value,
streams.value.log,
foldMappers(sourcePositionMappers.value)
)
},
compileInputs := Inputs.of(
compilers.value,
compileOptions.value,
compileIncSetup.value,
@ -1460,11 +1472,14 @@ object Defaults extends BuildCommon {
def compileAnalysisSettings: Seq[Setting[_]] = Seq(
previousCompile := {
val setup = compileIncSetup.value
val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile)
store.get() match {
case Some((an, setup)) =>
new PreviousResult(Option(an).toOptional, Option(setup).toOptional)
case None => new PreviousResult(jnone[CompileAnalysis], jnone[MiniSetup])
val useBinary: Boolean = enableBinaryCompileAnalysis.value
val store = MixedAnalyzingCompiler.staticCachedStore(setup.cacheFile, !useBinary)
store.get().toOption match {
case Some(contents) =>
val analysis = Option(contents.getAnalysis).toOptional
val setup = Option(contents.getMiniSetup).toOptional
PreviousResult.of(analysis, setup)
case None => PreviousResult.of(jnone[CompileAnalysis], jnone[MiniSetup])
}
}
)
@ -1477,10 +1492,8 @@ object Defaults extends BuildCommon {
val problems =
analysis.infos.allInfos.values.flatMap(i =>
i.getReportedProblems ++ i.getUnreportedProblems)
val reporter = new LoggerReporter(max, streams.value.log, foldMappers(spms))
problems foreach { p =>
reporter.display(p)
}
val reporter = new ManagedLoggedReporter(max, streams.value.log, foldMappers(spms))
problems.foreach(p => reporter.log(p))
}
def sbtPluginExtra(m: ModuleID, sbtV: String, scalaV: String): ModuleID =
@ -1656,7 +1669,9 @@ object Classpaths {
def notFound =
sys.error(
"Configuration to use for managed classpath must be explicitly defined when default configurations are not present.")
search find { defined contains _.name } getOrElse notFound
search find { c =>
defined contains ConfigRef(c.name)
} getOrElse notFound
}
def packaged(pkgTasks: Seq[TaskKey[File]]): Initialize[Task[Map[Artifact, File]]] =
@ -1692,12 +1707,14 @@ object Classpaths {
packagedArtifacts :== Map.empty,
crossTarget := target.value,
makePom := {
val config = makePomConfiguration.value;
IvyActions.makePom(ivyModule.value, config, streams.value.log); config.file
val config = makePomConfiguration.value
val publisher = Keys.publisher.value
publisher.makePomFile(ivyModule.value, config, streams.value.log)
config.file.get
},
packagedArtifact in makePom := ((artifact in makePom).value -> makePom.value),
deliver := deliverTask(deliverConfiguration).value,
deliverLocal := deliverTask(deliverLocalConfiguration).value,
deliver := deliverTask(publishConfiguration).value,
deliverLocal := deliverTask(publishLocalConfiguration).value,
publish := publishTask(publishConfiguration, deliver).value,
publishLocal := publishTask(publishLocalConfiguration, deliverLocal).value,
publishM2 := publishTask(publishM2Configuration, deliverLocal).value
@ -1715,7 +1732,7 @@ object Classpaths {
scmInfo :== None,
offline :== false,
defaultConfiguration :== Some(Configurations.Compile),
dependencyOverrides :== Set.empty,
dependencyOverrides :== Vector.empty,
libraryDependencies :== Nil,
excludeDependencies :== Nil,
ivyLoggingLevel :== {
@ -1728,12 +1745,12 @@ object Classpaths {
ivyValidate :== false,
moduleConfigurations :== Nil,
publishTo :== None,
resolvers :== Nil,
resolvers :== Vector.empty,
useJCenter :== false,
retrievePattern :== Resolver.defaultRetrievePattern,
transitiveClassifiers :== Seq(SourceClassifier, DocClassifier),
sourceArtifactTypes :== Artifact.DefaultSourceTypes,
docArtifactTypes :== Artifact.DefaultDocTypes,
sourceArtifactTypes :== Artifact.DefaultSourceTypes.toVector,
docArtifactTypes :== Artifact.DefaultDocTypes.toVector,
sbtDependency := {
val app = appConfiguration.value
val id = app.provider.id
@ -1777,13 +1794,13 @@ object Classpaths {
useJCenter.value) match {
case (Some(delegated), Seq(), _, _) => delegated
case (_, rs, Some(ars), uj) => ars ++ rs
case (_, rs, _, uj) => Resolver.withDefaultResolvers(rs, uj, mavenCentral = true)
case (_, rs, _, uj) => Resolver.combineDefaultResolvers(rs.toVector, uj, mavenCentral = true)
}),
appResolvers := {
val ac = appConfiguration.value
val uj = useJCenter.value
appRepositories(ac) map { ars =>
val useMavenCentral = ars contains DefaultMavenRepository
val useMavenCentral = ars contains Resolver.DefaultMavenRepository
Resolver.reorganizeAppResolvers(ars, uj, useMavenCentral)
}
},
@ -1806,7 +1823,7 @@ object Classpaths {
val st = state.value
BuildPaths.getDependencyDirectory(st, BuildPaths.getGlobalBase(st))
},
otherResolvers := Resolver.publishMavenLocal :: publishTo.value.toList,
otherResolvers := Resolver.publishMavenLocal +: publishTo.value.toVector,
projectResolver := projectResolverTask.value,
projectDependencies := projectDependenciesTask.value,
// TODO - Is this the appropriate split? Ivy defines this simply as
@ -1815,10 +1832,10 @@ object Classpaths {
allDependencies := {
projectDependencies.value ++ libraryDependencies.value
},
ivyScala := (ivyScala or (
scalaModuleInfo := (scalaModuleInfo or (
Def.setting {
Option(
IvyScala(
ScalaModuleInfo(
(scalaVersion in update).value,
(scalaBinaryVersion in update).value,
Vector.empty,
@ -1837,26 +1854,26 @@ object Classpaths {
projectDescriptors := depMap.value,
updateConfiguration := {
// Tell the UpdateConfiguration which artifact types are special (for sources and javadocs)
val specialArtifactTypes = sourceArtifactTypes.value union docArtifactTypes.value
val specialArtifactTypes = sourceArtifactTypes.value.toSet union docArtifactTypes.value.toSet
// By default, to retrieve all types *but* these (it's assumed that everything else is binary/resource)
UpdateConfiguration(
retrieve = retrieveConfiguration.value,
missingOk = false,
logging = ivyLoggingLevel.value,
artifactFilter = ArtifactTypeFilter.forbid(specialArtifactTypes),
offline = offline.value,
frozen = false
)
UpdateConfiguration()
.withRetrieveManaged(retrieveConfiguration.value)
.withLogging(ivyLoggingLevel.value)
.withArtifactFilter(ArtifactTypeFilter.forbid(specialArtifactTypes))
.withOffline(offline.value)
},
retrieveConfiguration := {
if (retrieveManaged.value)
Some(
RetrieveConfiguration(managedDirectory.value,
retrievePattern.value,
retrieveManagedSync.value,
configurationsToRetrieve.value))
RetrieveConfiguration()
.withRetrieveDirectory(managedDirectory.value)
.withOutputPattern(retrievePattern.value)
.withSync(retrieveManagedSync.value)
.withConfigurationsToRetrieve(configurationsToRetrieve.value map { _.toVector }))
else None
},
dependencyResolution := IvyDependencyResolution(ivyConfiguration.value),
publisher := IvyPublisher(ivyConfiguration.value),
ivyConfiguration := mkIvyConfiguration.value,
ivyConfigurations := {
val confs = thisProject.value.configurations
@ -1870,43 +1887,44 @@ object Classpaths {
else Nil
},
moduleSettings := moduleSettings0.value,
makePomConfiguration := new MakePomConfiguration(artifactPath in makePom value,
projectInfo.value,
None,
pomExtra.value,
pomPostProcess.value,
pomIncludeRepository.value,
pomAllRepositories.value),
deliverLocalConfiguration := deliverConfig(crossTarget.value,
status =
if (isSnapshot.value) "integration"
else "release",
logging = ivyLoggingLevel.value),
deliverConfiguration := deliverLocalConfiguration.value,
makePomConfiguration := MakePomConfiguration()
.withFile((artifactPath in makePom).value)
.withModuleInfo(projectInfo.value)
.withExtra(pomExtra.value)
.withProcess(pomPostProcess.value)
.withFilterRepositories(pomIncludeRepository.value)
.withAllRepositories(pomAllRepositories.value),
publishConfiguration := {
// TODO(jvican): I think this is a bug.
val delivered = deliver.value
publishConfig(
packagedArtifacts.in(publish).value,
if (publishMavenStyle.value) None else Some(delivered),
resolverName = getPublishTo(publishTo.value).name,
checksums = checksums.in(publish).value,
logging = ivyLoggingLevel.value,
overwrite = isSnapshot.value
publishMavenStyle.value,
deliverPattern(crossTarget.value),
if (isSnapshot.value) "integration" else "release",
ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
packagedArtifacts.in(publish).value.toVector,
checksums.in(publish).value.toVector,
getPublishTo(publishTo.value).name,
ivyLoggingLevel.value,
isSnapshot.value
)
},
publishLocalConfiguration := publishConfig(
packagedArtifacts.in(publishLocal).value,
Some(deliverLocal.value),
checksums.in(publishLocal).value,
false, //publishMavenStyle.value,
deliverPattern(crossTarget.value),
if (isSnapshot.value) "integration" else "release",
ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
packagedArtifacts.in(publishLocal).value.toVector,
checksums.in(publishLocal).value.toVector,
logging = ivyLoggingLevel.value,
overwrite = isSnapshot.value
),
publishM2Configuration := publishConfig(
packagedArtifacts.in(publishM2).value,
None,
true,
deliverPattern(crossTarget.value),
if (isSnapshot.value) "integration" else "release",
ivyConfigurations.value.map(c => ConfigRef(c.name)).toVector,
packagedArtifacts.in(publishM2).value.toVector,
checksums = checksums.in(publishM2).value.toVector,
resolverName = Resolver.publishMavenLocal.name,
checksums = checksums.in(publishM2).value,
logging = ivyLoggingLevel.value,
overwrite = isSnapshot.value
),
@ -1944,14 +1962,18 @@ object Classpaths {
implicit val key = (m: ModuleID) => (m.organization, m.name, m.revision)
val projectDeps = projectDependencies.value.iterator.map(key).toSet
val externalModules = update.value.allModules.filterNot(m => projectDeps contains key(m))
GetClassifiersModule(projectID.value,
externalModules,
ivyConfigurations.in(updateClassifiers).value.toVector,
transitiveClassifiers.in(updateClassifiers).value.toVector)
GetClassifiersModule(
projectID.value,
None,
externalModules,
ivyConfigurations.in(updateClassifiers).value.toVector,
transitiveClassifiers.in(updateClassifiers).value.toVector
)
},
updateClassifiers := (Def.task {
val s = streams.value
val is = ivySbt.value
val lm = new DependencyResolution(new IvyDependencyResolution(is))
val mod = (classifiersModule in updateClassifiers).value
val c = updateConfiguration.value
val app = appConfiguration.value
@ -1959,24 +1981,24 @@ object Classpaths {
val docTypes = docArtifactTypes.value
val out = is.withIvy(s.log)(_.getSettings.getDefaultIvyUserDir)
val uwConfig = (unresolvedWarningConfiguration in update).value
val depDir = dependencyCacheDirectory.value
val ivy = ivyScala.value
val st = state.value
val scalaModule = scalaModuleInfo.value
withExcludes(out, mod.classifiers, lock(app)) { excludes =>
IvyActions.updateClassifiers(
is,
GetClassifiersConfiguration(mod,
excludes,
c.withArtifactFilter(c.artifactFilter.invert),
ivy,
srcTypes,
docTypes),
lm.updateClassifiers(
GetClassifiersConfiguration(
mod,
excludes.toVector,
c.withArtifactFilter(c.artifactFilter.map(af => af.withInverted(!af.inverted))),
// scalaModule,
srcTypes.toVector,
docTypes.toVector
),
uwConfig,
LogicalClock(st.hashCode),
Some(depDir),
Vector.empty,
s.log
)
) match {
case Left(_) => ???
case Right(ur) => ur
}
}
} tag (Tags.Update, Tags.Network)).value
)
@ -1999,7 +2021,7 @@ object Classpaths {
else base
val sbtOrg = scalaOrganization.value
val version = scalaVersion.value
if (scalaHome.value.isDefined || ivyScala.value.isEmpty || !managedScalaInstance.value)
if (scalaHome.value.isDefined || scalaModuleInfo.value.isEmpty || !managedScalaInstance.value)
pluginAdjust
else {
val isDotty = ScalaInstance.isDotty(version)
@ -2039,19 +2061,16 @@ object Classpaths {
new IvySbt(ivyConfiguration.value)
}
def moduleSettings0: Initialize[Task[ModuleSettings]] = Def.task {
InlineConfiguration(
ivyValidate.value,
ivyScala.value,
projectID.value,
projectInfo.value,
allDependencies.value.toVector,
dependencyOverrides.value,
excludeDependencies.value.toVector,
ivyXML.value,
ivyConfigurations.value.toVector,
defaultConfiguration.value,
conflictManager.value
)
ModuleDescriptorConfiguration(projectID.value, projectInfo.value)
.withValidate(ivyValidate.value)
.withScalaModuleInfo(scalaModuleInfo.value)
.withDependencies(allDependencies.value.toVector)
.withOverrides(dependencyOverrides.value.toVector)
.withExcludes(excludeDependencies.value.toVector)
.withIvyXML(ivyXML.value)
.withConfigurations(ivyConfigurations.value.toVector)
.withDefaultConfiguration(defaultConfiguration.value)
.withConflictManager(conflictManager.value)
}
private[this] def sbtClassifiersGlobalDefaults =
@ -2072,7 +2091,7 @@ object Classpaths {
.resolvers
explicit orElse bootRepositories(appConfiguration.value) getOrElse externalResolvers.value
},
ivyConfiguration := new InlineIvyConfiguration(
ivyConfiguration := InlineIvyConfiguration(
paths = ivyPaths.value,
resolvers = externalResolvers.value.toVector,
otherResolvers = Vector.empty,
@ -2090,16 +2109,18 @@ object Classpaths {
// to fix https://github.com/sbt/sbt/issues/2686
scalaVersion := appConfiguration.value.provider.scalaProvider.version,
scalaBinaryVersion := binaryScalaVersion(scalaVersion.value),
ivyScala := {
scalaModuleInfo := {
Some(
IvyScala(scalaVersion.value,
scalaBinaryVersion.value,
Vector(),
checkExplicit = false,
filterImplicit = false,
overrideScalaVersion = true).withScalaOrganization(scalaOrganization.value))
ScalaModuleInfo(
scalaVersion.value,
scalaBinaryVersion.value,
Vector(),
checkExplicit = false,
filterImplicit = false,
overrideScalaVersion = true).withScalaOrganization(scalaOrganization.value))
},
updateSbtClassifiers in TaskGlobal := (Def.task {
val lm = dependencyResolution.value
val s = streams.value
val is = ivySbt.value
val mod = classifiersModule.value
@ -2111,24 +2132,26 @@ object Classpaths {
val out = is.withIvy(log)(_.getSettings.getDefaultIvyUserDir)
val uwConfig = (unresolvedWarningConfiguration in update).value
val depDir = dependencyCacheDirectory.value
val ivy = ivyScala.value
val ivy = scalaModuleInfo.value
val st = state.value
withExcludes(out, mod.classifiers, lock(app)) { excludes =>
val noExplicitCheck = ivy.map(_.withCheckExplicit(false))
IvyActions.transitiveScratch(
is,
"sbt",
GetClassifiersConfiguration(mod,
excludes,
c.withArtifactFilter(c.artifactFilter.invert),
noExplicitCheck,
srcTypes,
docTypes),
uwConfig,
LogicalClock(st.hashCode),
Some(depDir),
log
)
withExcludes(out, mod.classifiers, lock(app)) {
excludes =>
// val noExplicitCheck = ivy.map(_.withCheckExplicit(false))
LibraryManagement.transitiveScratch(
lm,
"sbt",
GetClassifiersConfiguration(mod,
excludes.toVector,
c.withArtifactFilter(c.artifactFilter.map(af =>
af.withInverted(!af.inverted))),
srcTypes.toVector,
docTypes.toVector),
uwConfig,
log
) match {
case Left(uw) => ???
case Right(ur) => ur
}
}
} tag (Tags.Update, Tags.Network)).value
)) ++ Seq(bootIvyConfiguration := (ivyConfiguration in updateSbtClassifiers).value)
@ -2140,12 +2163,17 @@ object Classpaths {
val pluginClasspath = loadedBuild.value.units(ref.build).unit.plugins.fullClasspath.toVector
val pluginJars = pluginClasspath.filter(_.data.isFile) // exclude directories: an approximation to whether they've been published
val pluginIDs: Vector[ModuleID] = pluginJars.flatMap(_ get moduleID.key)
GetClassifiersModule(projectID.value,
sbtDependency.value +: pluginIDs,
Vector(Configurations.Default),
classifiers.toVector)
GetClassifiersModule(
projectID.value,
// TODO: Should it be sbt's scalaModuleInfo?
scalaModuleInfo.value,
sbtDependency.value +: pluginIDs,
// sbt is now on Maven Central, so this has changed from sbt 0.13.
Vector(Configurations.Default) ++ Configurations.default,
classifiers.toVector
)
}
def deliverTask(config: TaskKey[DeliverConfiguration]): Initialize[Task[File]] =
def deliverTask(config: TaskKey[PublishConfiguration]): Initialize[Task[File]] =
Def.task {
val _ = update.value
IvyActions.deliver(ivyModule.value, config.value, streams.value.log)
@ -2167,10 +2195,10 @@ object Classpaths {
}
def withExcludes(out: File, classifiers: Seq[String], lock: xsbti.GlobalLock)(
f: Map[ModuleID, Set[String]] => UpdateReport): UpdateReport = {
f: Map[ModuleID, Vector[ConfigRef]] => UpdateReport): UpdateReport = {
import sbt.librarymanagement.LibraryManagementCodec._
import sbt.util.FileBasedStore
implicit val isoString: sjsonnew.IsoString[scalajson.ast.unsafe.JValue] =
implicit val isoString: sjsonnew.IsoString[JValue] =
sjsonnew.IsoString.iso(
sjsonnew.support.scalajson.unsafe.CompactPrinter.apply,
sjsonnew.support.scalajson.unsafe.Parser.parseUnsafe
@ -2184,11 +2212,17 @@ object Classpaths {
def call = {
implicit val midJsonKeyFmt: sjsonnew.JsonKeyFormat[ModuleID] = moduleIdJsonKeyFormat
val excludes =
store.read[Map[ModuleID, Set[String]]](default = Map.empty[ModuleID, Set[String]])
store
.read[Map[ModuleID, Vector[ConfigRef]]](
default = Map.empty[ModuleID, Vector[ConfigRef]])
val report = f(excludes)
val allExcludes = excludes ++ IvyActions.extractExcludes(report)
val allExcludes: Map[ModuleID, Vector[ConfigRef]] = excludes ++ IvyActions
.extractExcludes(report)
.mapValues(cs => cs.map(c => ConfigRef(c)).toVector)
store.write(allExcludes)
IvyActions.addExcluded(report, classifiers.toVector, allExcludes)
IvyActions.addExcluded(report,
classifiers.toVector,
allExcludes.mapValues(_.map(_.name).toSet))
}
}
)
@ -2249,11 +2283,14 @@ object Classpaths {
import UpdateLogging.{ Full, DownloadOnly, Default }
val conf = updateConfiguration.value
val maybeUpdateLevel = (logLevel in update).?.value
maybeUpdateLevel.orElse(state0.get(logLevel.key)) match {
val conf1 = maybeUpdateLevel.orElse(state0.get(logLevel.key)) match {
case Some(Level.Debug) if conf.logging == Default => conf.withLogging(logging = Full)
case Some(_) if conf.logging == Default => conf.withLogging(logging = DownloadOnly)
case _ => conf
}
// logical clock is folded into UpdateConfiguration
conf1.withLogicalClock(LogicalClock(state0.hashCode))
}
val evictionOptions = Def.taskDyn {
@ -2272,7 +2309,6 @@ object Classpaths {
force = shouldForce,
depsUpdated = transitiveUpdate.value.exists(!_.stats.cached),
uwConfig = (unresolvedWarningConfiguration in update).value,
logicalClock = LogicalClock(state0.hashCode),
depDir = Some(dependencyCacheDirectory.value),
ewo = evictionOptions,
mavenStyle = publishMavenStyle.value,
@ -2362,25 +2398,24 @@ object Classpaths {
def getPublishTo(repo: Option[Resolver]): Resolver =
repo getOrElse sys.error("Repository for publishing is not specified.")
def deliverConfig(outputDirectory: File,
status: String = "release",
logging: UpdateLogging = UpdateLogging.DownloadOnly) =
new DeliverConfiguration(deliverPattern(outputDirectory), status, None, logging)
def publishConfig(
artifacts: Map[Artifact, File],
ivyFile: Option[File],
checksums: Seq[String],
resolverName: String = "local",
logging: UpdateLogging = UpdateLogging.DownloadOnly,
overwrite: Boolean = false
) =
new PublishConfiguration(ivyFile,
resolverName,
artifacts,
checksums.toVector,
logging,
overwrite)
def publishConfig(publishMavenStyle: Boolean,
deliverIvyPattern: String,
status: String,
configurations: Vector[ConfigRef],
artifacts: Vector[(Artifact, File)],
checksums: Vector[String],
resolverName: String = "local",
logging: UpdateLogging = UpdateLogging.DownloadOnly,
overwrite: Boolean = false) =
PublishConfiguration(publishMavenStyle,
deliverIvyPattern,
status,
configurations,
resolverName,
artifacts,
checksums,
logging,
overwrite)
def deliverPattern(outputPath: File): String =
(outputPath / "[artifact]-[revision](-[classifier]).[ext]").absolutePath
@ -2415,7 +2450,8 @@ object Classpaths {
def projectResolverTask: Initialize[Task[Resolver]] =
projectDescriptors map { m =>
new RawRepository(new ProjectResolver(ProjectResolver.InterProject, m))
val resolver = new ProjectResolver(ProjectResolver.InterProject, m)
new RawRepository(resolver, resolver.getName)
}
def analyzed[T](data: T, analysis: CompileAnalysis) =
@ -2544,19 +2580,16 @@ object Classpaths {
val (rs, other) = (fullResolvers.value.toVector, otherResolvers.value.toVector)
val s = streams.value
warnResolversConflict(rs ++: other, s.log)
new InlineIvyConfiguration(
paths = ivyPaths.value,
resolvers = rs,
otherResolvers = other,
moduleConfigurations = moduleConfigurations.value.toVector,
// offline.value,
lock = Option(lock(appConfiguration.value)),
checksums = (checksums in update).value.toVector,
managedChecksums = false,
resolutionCacheDir = Some(crossTarget.value / "resolution-cache"),
updateOptions = updateOptions.value,
log = s.log
)
InlineIvyConfiguration()
.withPaths(ivyPaths.value)
.withResolvers(rs)
.withOtherResolvers(other)
.withModuleConfigurations(moduleConfigurations.value.toVector)
.withLock(lock(appConfiguration.value))
.withChecksums((checksums in update).value.toVector)
.withResolutionCacheDir(crossTarget.value / "resolution-cache")
.withUpdateOptions(updateOptions.value)
.withLog(s.log)
}
import java.util.LinkedHashSet
@ -2570,12 +2603,12 @@ object Classpaths {
val applicableConfigs = allConfigs(c)
for (ac <- applicableConfigs) // add all configurations in this project
visited add (p -> ac.name)
val masterConfs = names(getConfigurations(projectRef, data))
val masterConfs = names(getConfigurations(projectRef, data).toVector)
for (ResolvedClasspathDependency(dep, confMapping) <- deps.classpath(p)) {
val configurations = getConfigurations(dep, data)
val mapping =
mapped(confMapping, masterConfs, names(configurations), "compile", "*->compile")
mapped(confMapping, masterConfs, names(configurations.toVector), "compile", "*->compile")
// map master configuration 'c' and all extended configurations to the appropriate dependency configuration
for (ac <- applicableConfigs; depConfName <- mapping(ac.name)) {
for (depConf <- confOpt(configurations, depConfName))
@ -2813,8 +2846,8 @@ object Classpaths {
case _: NoSuchMethodError => None
}
def bootChecksums(app: xsbti.AppConfiguration): Seq[String] =
try { app.provider.scalaProvider.launcher.checksums.toSeq } catch {
def bootChecksums(app: xsbti.AppConfiguration): Vector[String] =
try { app.provider.scalaProvider.launcher.checksums.toVector } catch {
case _: NoSuchMethodError => IvySbt.DefaultChecksums
}
@ -2823,13 +2856,13 @@ object Classpaths {
catch { case _: NoSuchMethodError => false }
/** Loads the `appRepositories` configured for this launcher, if supported. */
def appRepositories(app: xsbti.AppConfiguration): Option[Seq[Resolver]] =
try { Some(app.provider.scalaProvider.launcher.appRepositories.toSeq map bootRepository) } catch {
def appRepositories(app: xsbti.AppConfiguration): Option[Vector[Resolver]] =
try { Some(app.provider.scalaProvider.launcher.appRepositories.toVector map bootRepository) } catch {
case _: NoSuchMethodError => None
}
def bootRepositories(app: xsbti.AppConfiguration): Option[Seq[Resolver]] =
try { Some(app.provider.scalaProvider.launcher.ivyRepositories.toSeq map bootRepository) } catch {
def bootRepositories(app: xsbti.AppConfiguration): Option[Vector[Resolver]] =
try { Some(app.provider.scalaProvider.launcher.ivyRepositories.toVector map bootRepository) } catch {
case _: NoSuchMethodError => None
}
@ -2863,7 +2896,7 @@ object Classpaths {
p.id match {
case Predefined.Local => Resolver.defaultLocal
case Predefined.MavenLocal => Resolver.mavenLocal
case Predefined.MavenCentral => DefaultMavenRepository
case Predefined.MavenCentral => Resolver.DefaultMavenRepository
case Predefined.ScalaToolsReleases => Resolver.ScalaToolsReleases
case Predefined.ScalaToolsSnapshots => Resolver.ScalaToolsSnapshots
case Predefined.SonatypeOSSReleases => Resolver.sonatypeRepo("releases")
@ -2987,7 +3020,13 @@ trait BuildExtra extends BuildCommon with DefExtra {
otherTask map {
case (base, app, pr, uo, s) =>
val extraResolvers = if (addMultiResolver) Vector(pr) else Vector.empty
ExternalIvyConfiguration(Option(lock(app)), base, s.log, uo, u, extraResolvers)
ExternalIvyConfiguration()
.withLock(lock(app))
.withBaseDirectory(base)
.withLog(s.log)
.withUpdateOptions(uo)
.withUri(u)
.withExtraResolvers(extraResolvers)
}
}).value
}
@ -2996,18 +3035,19 @@ trait BuildExtra extends BuildCommon with DefExtra {
baseDirectory.value / name
}
def externalIvyFile(
file: Initialize[File] = inBase("ivy.xml"),
iScala: Initialize[Option[IvyScala]] = ivyScala): Setting[Task[ModuleSettings]] =
def externalIvyFile(file: Initialize[File] = inBase("ivy.xml"),
iScala: Initialize[Option[ScalaModuleInfo]] = scalaModuleInfo)
: Setting[Task[ModuleSettings]] =
moduleSettings := IvyFileConfiguration(ivyValidate.value,
iScala.value,
file.value,
managedScalaInstance.value)
def externalPom(file: Initialize[File] = inBase("pom.xml"),
iScala: Initialize[Option[IvyScala]] = ivyScala): Setting[Task[ModuleSettings]] =
iScala: Initialize[Option[ScalaModuleInfo]] = scalaModuleInfo)
: Setting[Task[ModuleSettings]] =
moduleSettings := PomConfiguration(ivyValidate.value,
ivyScala.value,
scalaModuleInfo.value,
file.value,
managedScalaInstance.value)

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

@ -140,7 +140,7 @@ object EvaluateTaskConfig {
final case class PluginData(
dependencyClasspath: Seq[Attributed[File]],
definitionClasspath: Seq[Attributed[File]],
resolvers: Option[Seq[Resolver]],
resolvers: Option[Vector[Resolver]],
report: Option[UpdateReport],
scalacOptions: Seq[String]
) {

53
main/src/main/scala/sbt/Keys.scala
View File

@ -42,44 +42,41 @@ import sbt.internal.util.{ AttributeKey, SourcePosition }
import sbt.librarymanagement.Configurations.CompilerPlugin
import sbt.librarymanagement.LibraryManagementCodec._
import sbt.librarymanagement.ivy.{ Credentials, UpdateOptions }
import sbt.librarymanagement.{
Artifact,
ConfigRef,
Configuration,
ConflictManager,
ConflictWarning,
Credentials,
CrossVersion,
Developer,
DependencyResolution,
EvictionWarning,
EvictionWarningOptions,
IvyScala,
GetClassifiersModule,
MakePomConfiguration,
MavenRepository,
ModuleConfiguration,
ModuleID,
ModuleInfo,
ModuleSettings,
PublishConfiguration,
Publisher,
Resolver,
RetrieveConfiguration,
ScalaModuleInfo,
ScalaVersion,
ScmInfo,
TrackLevel,
UnresolvedWarningConfiguration,
UpdateConfiguration,
UpdateOptions,
UpdateLogging,
UpdateReport
}
import sbt.librarymanagement.ExclusionRule
import sbt.internal.librarymanagement.{
CompatibilityWarningOptions,
DeliverConfiguration,
GetClassifiersModule,
IvyConfiguration,
IvyPaths,
IvySbt,
MakePomConfiguration,
PublishConfiguration,
RetrieveConfiguration,
UnresolvedWarningConfiguration
}
import sbt.librarymanagement.InclExclRule
import sbt.internal.librarymanagement.{ CompatibilityWarningOptions, IvySbt }
import sbt.librarymanagement.ivy.{ IvyConfiguration, IvyPaths }
import sbt.util.{ Level, Logger }
import org.apache.logging.log4j.core.Appender
import sbt.BuildSyntax._
@ -87,6 +84,9 @@ import sbt.BuildSyntax._
// format: off
object Keys {
// Normally we prefer concrete datatype like Vector, but due to ++= implicits and for backward compatibility,
// for keys we should stick to using Seq.
val TraceValues = "-1 to disable, 0 for up to the first sbt frame, or a positive number to set the maximum number of frames shown."
// logging
@ -208,6 +208,7 @@ object Keys {
val fileInputOptions = SettingKey[Seq[String]]("file-input-options", "Options that take file input, which may invalidate the cache.", CSetting)
val scalaCompilerBridgeSource = SettingKey[ModuleID]("scala-compiler-bridge-source", "Configures the module ID of the sources of the compiler bridge.", CSetting)
val scalaArtifacts = SettingKey[Seq[String]]("scala-artifacts", "Configures the list of artifacts which should match the Scala binary version", CSetting)
val enableBinaryCompileAnalysis = SettingKey[Boolean]("binary-analysis", "Writes the analysis file in binary format")
val clean = TaskKey[Unit]("clean", "Deletes files produced by the build, such as generated sources, compiled classes, and task caches.", APlusTask)
val console = TaskKey[Unit]("console", "Starts the Scala interpreter with the project classes on the classpath.", APlusTask)
@ -261,8 +262,8 @@ object Keys {
val envVars = TaskKey[Map[String, String]]("envVars", "Environment variables used when forking a new JVM", BTask)
val bgJobService = settingKey[BackgroundJobService]("Job manager used to run background jobs.")
val bgList = taskKey[Vector[JobHandle]]("List running background jobs.")
val ps = taskKey[Vector[JobHandle]]("bgList variant that displays on the log.")
val bgList = taskKey[Seq[JobHandle]]("List running background jobs.")
val ps = taskKey[Seq[JobHandle]]("bgList variant that displays on the log.")
val bgStop = inputKey[Unit]("Stop a background job by providing its ID.")
val bgWaitFor = inputKey[Unit]("Wait for a background job to finish by providing its ID.")
val bgRun = inputKey[JobHandle]("Start an application's default main class as a background job")
@ -343,6 +344,8 @@ object Keys {
val updateOptions = SettingKey[UpdateOptions]("update-options", "Options for resolving managed dependencies.", DSetting)
val unresolvedWarningConfiguration = TaskKey[UnresolvedWarningConfiguration]("unresolved-warning-configuration", "Configuration for unresolved dependency warning.", DTask)
val dependencyPositions = TaskKey[Map[ModuleID, SourcePosition]]("dependency-positions", "Source positions where the dependencies are defined.", DTask)
val dependencyResolution = TaskKey[DependencyResolution]("dependency-resolution", "Provides the sbt interface to dependency resolution.", CTask)
val publisher = TaskKey[Publisher]("publisher", "Provides the sbt interface to publisher")
val ivySbt = TaskKey[IvySbt]("ivy-sbt", "Provides the sbt interface to Ivy.", CTask)
val ivyModule = TaskKey[IvySbt#Module]("ivy-module", "Provides the sbt interface to a configured Ivy module.", CTask)
val updateCacheName = TaskKey[String]("updateCacheName", "Defines the directory name used to store the update cache files (inside the streams cacheDirectory).", DTask)
@ -353,14 +356,12 @@ object Keys {
val updateClassifiers = TaskKey[UpdateReport]("update-classifiers", "Resolves and optionally retrieves classified artifacts, such as javadocs and sources, for dependency definitions, transitively.", BPlusTask, update)
val transitiveClassifiers = SettingKey[Seq[String]]("transitive-classifiers", "List of classifiers used for transitively obtaining extra artifacts for sbt or declared dependencies.", BSetting)
val updateSbtClassifiers = TaskKey[UpdateReport]("update-sbt-classifiers", "Resolves and optionally retrieves classifiers, such as javadocs and sources, for sbt, transitively.", BPlusTask, updateClassifiers)
val sourceArtifactTypes = SettingKey[Set[String]]("source-artifact-types", "Ivy artifact types that correspond to source artifacts. Used by IDEs to resolve these resources.", BSetting)
val docArtifactTypes = SettingKey[Set[String]]("doc-artifact-types", "Ivy artifact types that correspond to javadoc artifacts. Used by IDEs to resolve these resources.", BSetting)
val sourceArtifactTypes = settingKey[Seq[String]]("Ivy artifact types that correspond to source artifacts. Used by IDEs to resolve these resources.") // BSetting
val docArtifactTypes = settingKey[Seq[String]]("Ivy artifact types that correspond to javadoc artifacts. Used by IDEs to resolve these resources.") // BSetting
val publishConfiguration = TaskKey[PublishConfiguration]("publish-configuration", "Configuration for publishing to a repository.", DTask)
val publishLocalConfiguration = TaskKey[PublishConfiguration]("publish-local-configuration", "Configuration for publishing to the local Ivy repository.", DTask)
val publishM2Configuration = TaskKey[PublishConfiguration]("publish-m2-configuration", "Configuration for publishing to the local Maven repository.", DTask)
val deliverConfiguration = TaskKey[DeliverConfiguration]("deliver-configuration", "Configuration for generating the finished Ivy file for publishing.", DTask)
val deliverLocalConfiguration = TaskKey[DeliverConfiguration]("deliver-local-configuration", "Configuration for generating the finished Ivy file for local publishing.", DTask)
val makePomConfiguration = SettingKey[MakePomConfiguration]("make-pom-configuration", "Configuration for generating a pom.", DSetting)
val packagedArtifacts = TaskKey[Map[Artifact, File]]("packaged-artifacts", "Packages all artifacts for publishing and maps the Artifact definition to the generated file.", CTask)
val publishMavenStyle = SettingKey[Boolean]("publish-maven-style", "Configures whether to generate and publish a pom (true) or Ivy file (false).", BSetting)
@ -399,12 +400,12 @@ object Keys {
val ivyPaths = SettingKey[IvyPaths]("ivy-paths", "Configures paths used by Ivy for dependency management.", DSetting)
val dependencyCacheDirectory = TaskKey[File]("dependency-cache-directory", "The base directory for cached dependencies.", DTask)
val libraryDependencies = SettingKey[Seq[ModuleID]]("library-dependencies", "Declares managed dependencies.", APlusSetting)
val dependencyOverrides = SettingKey[Set[ModuleID]]("dependency-overrides", "Declares managed dependency overrides.", BSetting)
val excludeDependencies = SettingKey[Seq[ExclusionRule]]("exclude-dependencies", "Declares managed dependency exclusions.", BSetting)
val dependencyOverrides = SettingKey[Seq[ModuleID]]("dependency-overrides", "Declares managed dependency overrides.", BSetting)
val excludeDependencies = SettingKey[Seq[InclExclRule]]("exclude-dependencies", "Declares managed dependency exclusions.", BSetting)
val allDependencies = TaskKey[Seq[ModuleID]]("all-dependencies", "Inter-project and library dependencies.", CTask)
val projectDependencies = TaskKey[Seq[ModuleID]]("project-dependencies", "Inter-project dependencies.", DTask)
val ivyXML = SettingKey[NodeSeq]("ivy-xml", "Defines inline Ivy XML for configuring dependency management.", BSetting)
val ivyScala = SettingKey[Option[IvyScala]]("ivy-scala", "Configures how Scala dependencies are checked, filtered, and injected.", CSetting)
val scalaModuleInfo = SettingKey[Option[ScalaModuleInfo]]("scala-module-info", "Configures how Scala dependencies are checked, filtered, and injected.", CSetting)
val ivyValidate = SettingKey[Boolean]("ivy-validate", "Enables/disables Ivy validation of module metadata.", BSetting)
val ivyLoggingLevel = SettingKey[UpdateLogging]("ivy-logging-level", "The logging level for updating.", BSetting)
val publishTo = TaskKey[Option[Resolver]]("publish-to", "The resolver to publish to.", ASetting)
@ -413,7 +414,7 @@ object Keys {
val autoUpdate = SettingKey[Boolean]("auto-update", "<unimplemented>", Invisible)
val retrieveManaged = SettingKey[Boolean]("retrieve-managed", "If true, enables retrieving dependencies to the current build. Otherwise, dependencies are used directly from the cache.", BSetting)
val retrieveManagedSync = SettingKey[Boolean]("retrieve-managed-sync", "If true, enables synchronizing the dependencies retrieved to the current build by removed unneeded files.", BSetting)
val configurationsToRetrieve = SettingKey[Option[Set[Configuration]]]("configurations-to-retrieve", "An optional set of configurations from which to retrieve dependencies if retrieveManaged is set to true", BSetting)
val configurationsToRetrieve = SettingKey[Option[Seq[ConfigRef]]]("configurations-to-retrieve", "An optional set of configurations from which to retrieve dependencies if retrieveManaged is set to true", BSetting)
val managedDirectory = SettingKey[File]("managed-directory", "Directory to which managed dependencies are retrieved.", BSetting)
val classpathTypes = SettingKey[Set[String]]("classpath-types", "Artifact types that are included on the classpath.", BSetting)
val publishArtifact = SettingKey[Boolean]("publish-artifact", "Enables (true) or disables (false) publishing an artifact.", AMinusSetting)

12
main/src/main/scala/sbt/Opts.scala
View File

@ -3,7 +3,8 @@
*/
package sbt
import sbt.librarymanagement.{ Credentials, MavenRepository, Resolver }
import sbt.librarymanagement.{ MavenRepository, Resolver }
import sbt.librarymanagement.ivy.Credentials
import java.io.File
import java.net.URL
@ -62,11 +63,12 @@ object DefaultOptions {
def scaladoc(name: String, version: String): Seq[String] =
doc.title(name) ++ doc.version(version)
def resolvers(snapshot: Boolean): Seq[Resolver] = {
if (snapshot) Seq(resolver.sbtSnapshots) else Nil
def resolvers(snapshot: Boolean): Vector[Resolver] = {
if (snapshot) Vector(resolver.sbtSnapshots) else Vector.empty
}
def pluginResolvers(plugin: Boolean, snapshot: Boolean): Seq[Resolver] = {
if (plugin && snapshot) Seq(resolver.sbtSnapshots, resolver.sbtIvySnapshots) else Nil
def pluginResolvers(plugin: Boolean, snapshot: Boolean): Vector[Resolver] = {
if (plugin && snapshot) Vector(resolver.sbtSnapshots, resolver.sbtIvySnapshots)
else Vector.empty
}
def addResolvers: Setting[_] = Keys.resolvers ++= { resolvers(Keys.isSnapshot.value) }
def addPluginResolvers: Setting[_] =

27
main/src/main/scala/sbt/TemplateCommand.scala
View File

@ -8,7 +8,7 @@ import sbt.util._
import sbt.internal.util.complete.{ DefaultParsers, Parser }, DefaultParsers._
import xsbti.AppConfiguration
import sbt.librarymanagement._
import sbt.internal.librarymanagement.IvyConfiguration
import sbt.librarymanagement.ivy.{ IvyConfiguration, IvyDependencyResolution }
import sbt.internal.inc.classpath.ClasspathUtilities
import BasicCommandStrings._, BasicKeys._
@ -25,13 +25,13 @@ private[sbt] object TemplateCommandUtil {
val extracted = (Project extract state)
val (s2, ivyConf) = extracted.runTask(Keys.ivyConfiguration, state)
val globalBase = BuildPaths.getGlobalBase(state)
val ivyScala = extracted.get(Keys.ivyScala in Keys.updateSbtClassifiers)
val scalaModuleInfo = extracted.get(Keys.scalaModuleInfo in Keys.updateSbtClassifiers)
val arguments = inputArg.toList ++
(state.remainingCommands match {
case exec :: Nil if exec.commandLine == "shell" => Nil
case xs => xs map (_.commandLine)
})
run(infos, arguments, state.configuration, ivyConf, globalBase, ivyScala, log)
run(infos, arguments, state.configuration, ivyConf, globalBase, scalaModuleInfo, log)
"exit" :: s2.copy(remainingCommands = Nil)
}
@ -41,11 +41,11 @@ private[sbt] object TemplateCommandUtil {
config: AppConfiguration,
ivyConf: IvyConfiguration,
globalBase: File,
ivyScala: Option[IvyScala],
scalaModuleInfo: Option[ScalaModuleInfo],
log: Logger
): Unit =
infos find { info =>
val loader = infoLoader(info, config, ivyConf, globalBase, ivyScala, log)
val loader = infoLoader(info, config, ivyConf, globalBase, scalaModuleInfo, log)
val hit = tryTemplate(info, arguments, loader)
if (hit) {
runTemplate(info, arguments, loader)
@ -75,10 +75,10 @@ private[sbt] object TemplateCommandUtil {
config: AppConfiguration,
ivyConf: IvyConfiguration,
globalBase: File,
ivyScala: Option[IvyScala],
scalaModuleInfo: Option[ScalaModuleInfo],
log: Logger
): ClassLoader = {
val cp = classpathForInfo(info, ivyConf, globalBase, ivyScala, log)
val cp = classpathForInfo(info, ivyConf, globalBase, scalaModuleInfo, log)
ClasspathUtilities.toLoader(cp, config.provider.loader)
}
@ -103,10 +103,10 @@ private[sbt] object TemplateCommandUtil {
info: TemplateResolverInfo,
ivyConf: IvyConfiguration,
globalBase: File,
ivyScala: Option[IvyScala],
scalaModuleInfo: Option[ScalaModuleInfo],
log: Logger
): List[File] = {
val lm = new DefaultLibraryManagement(ivyConf, log)
val lm = IvyDependencyResolution(ivyConf)
val templatesBaseDirectory = new File(globalBase, "templates")
val templateId = s"${info.module.organization}_${info.module.name}_${info.module.revision}"
val templateDirectory = new File(templatesBaseDirectory, templateId)
@ -114,8 +114,13 @@ private[sbt] object TemplateCommandUtil {
if (!(info.module.revision endsWith "-SNAPSHOT") && jars.nonEmpty) jars.toList
else {
IO.createDirectory(templateDirectory)
val m = lm.getModule(info.module.withConfigurations(Some("component")), ivyScala)
val xs = lm.update(m, templateDirectory)(_ => true).toList.flatten
val m = lm.moduleDescriptor(info.module.withConfigurations(Some("component")),
Vector.empty,
scalaModuleInfo)
val xs = lm.retrieve(m, templateDirectory, log) match {
case Left(_) => ??? // FIXME
case Right(files) => files.toList
}
xs
}
}

47
main/src/main/scala/sbt/internal/AltLibraryManagementCodec.scala
View File

@ -3,14 +3,14 @@ package sbt.internal
import sbt.internal.librarymanagement._
import sbt.internal.util.Types._
import sbt.internal.util.{ HList, HNil }
import sbt.internal.util.HListFormats._
import sbt.io.{ Hash, IO }
import sbt.io.Hash
import sbt.librarymanagement._
import sbt.util.CacheImplicits._
import sbt.librarymanagement.ivy._
import sbt.util._
import sbt.internal.util.HListFormats._
import sjsonnew.JsonFormat
object AltLibraryManagementCodec extends LibraryManagementCodec {
object AltLibraryManagementCodec extends IvyLibraryManagementCodec {
type In0 = ModuleSettings :+: UpdateConfiguration :+: HNil
type In = IvyConfiguration :+: In0
@ -37,33 +37,31 @@ object AltLibraryManagementCodec extends LibraryManagementCodec {
SftpRepository,
RawRepository]
type InlineIvyHL = (IvyPaths :+: Vector[Resolver] :+: Vector[Resolver] :+: Vector[
type InlineIvyHL = (Option[IvyPaths] :+: Vector[Resolver] :+: Vector[Resolver] :+: Vector[
ModuleConfiguration] :+: Vector[String] :+: Boolean :+: HNil)
def inlineIvyToHL(i: InlineIvyConfiguration): InlineIvyHL = (
i.paths :+: i.resolvers :+: i.otherResolvers :+: i.moduleConfigurations :+:
i.checksums :+: i.managedChecksums :+: HNil
)
type ExternalIvyHL = PlainFileInfo :+: Array[Byte] :+: HNil
type ExternalIvyHL = Option[PlainFileInfo] :+: Array[Byte] :+: HNil
def externalIvyToHL(e: ExternalIvyConfiguration): ExternalIvyHL =
FileInfo.exists(e.baseDirectory) :+: Hash.contentsIfLocal(e.uri) :+: HNil
e.baseDirectory.map(FileInfo.exists.apply) :+: e.uri
.map(Hash.contentsIfLocal)
.getOrElse(Array.empty) :+: HNil
// Redefine to use a subset of properties, that are serialisable
override lazy implicit val InlineIvyConfigurationFormat: JsonFormat[InlineIvyConfiguration] = {
def hlToInlineIvy(i: InlineIvyHL): InlineIvyConfiguration = {
val (paths :+: resolvers :+: otherResolvers :+: moduleConfigurations :+: localOnly
:+: checksums :+: HNil) = i
InlineIvyConfiguration(None,
IO.createTemporaryDirectory,
NullLogger,
UpdateOptions(),
paths,
resolvers,
otherResolvers,
moduleConfigurations,
localOnly,
checksums,
None)
val (paths :+: resolvers :+: otherResolvers :+: moduleConfigurations :+: checksums
:+: managedChecksums :+: HNil) = i
InlineIvyConfiguration()
.withPaths(paths)
.withResolvers(resolvers)
.withOtherResolvers(otherResolvers)
.withModuleConfigurations(moduleConfigurations)
.withManagedChecksums(managedChecksums)
.withChecksums(checksums)
}
projectFormat[InlineIvyConfiguration, InlineIvyHL](inlineIvyToHL, hlToInlineIvy)
@ -76,11 +74,12 @@ object AltLibraryManagementCodec extends LibraryManagementCodec {
val baseDirectory :+: _ /* uri */ :+: HNil = e
ExternalIvyConfiguration(
None,
baseDirectory.file,
NullLogger,
Some(NullLogger),
UpdateOptions(),
IO.createTemporaryDirectory.toURI /* the original uri is destroyed.. */,
Vector.empty)
baseDirectory.map(_.file),
None /* the original uri is destroyed.. */,
Vector.empty
)
}
projectFormat[ExternalIvyConfiguration, ExternalIvyHL](externalIvyToHL, hlToExternalIvy)

3
main/src/main/scala/sbt/internal/BuildStructure.scala
View File

@ -14,6 +14,7 @@ import sbt.io.syntax._
import sbt.internal.util.{ Attributed, AttributeEntry, AttributeKey, AttributeMap, Settings }
import sbt.internal.util.Attributed.data
import sbt.util.Logger
import sjsonnew.shaded.scalajson.ast.unsafe.JValue
final class BuildStructure(val units: Map[URI, LoadedBuildUnit],
val root: URI,
@ -250,7 +251,7 @@ object BuildStreams {
def mkStreams(units: Map[URI, LoadedBuildUnit],
root: URI,
data: Settings[Scope]): State => Streams = s => {
implicit val isoString: sjsonnew.IsoString[scalajson.ast.unsafe.JValue] =
implicit val isoString: sjsonnew.IsoString[JValue] =
sjsonnew.IsoString.iso(sjsonnew.support.scalajson.unsafe.CompactPrinter.apply,
sjsonnew.support.scalajson.unsafe.Parser.parseUnsafe)
(s get Keys.stateStreams) getOrElse {

4
main/src/main/scala/sbt/internal/ConsoleProject.scala
View File

@ -15,7 +15,7 @@ object ConsoleProject {
val cpImports = new Imports(extracted, state)
val bindings = ("currentState" -> state) :: ("extracted" -> extracted) :: ("cpHelpers" -> cpImports) :: Nil
val unit = extracted.currentUnit
val (_, ivyConf) = extracted.runTask(Keys.ivyConfiguration, state)
val (_, dependencyResolution) = extracted.runTask(Keys.dependencyResolution, state)
val scalaInstance = {
val scalaProvider = state.configuration.provider.scalaProvider
ScalaInstance(scalaProvider.version, scalaProvider.launcher)
@ -30,7 +30,7 @@ object ConsoleProject {
globalLock = launcher.globalLock,
componentProvider = app.provider.components,
secondaryCacheDir = Option(zincDir),
ivyConfiguration = ivyConf,
dependencyResolution = dependencyResolution,
compilerBridgeSource = extracted.get(Keys.scalaCompilerBridgeSource),
scalaJarsTarget = zincDir,
log = log

4
main/src/main/scala/sbt/internal/GlobalPlugin.scala
View File

@ -69,7 +69,7 @@ object GlobalPlugin {
GlobalPluginData(projectID.value,
projectDependencies.value,
depMap,
resolvers.value,
resolvers.value.toVector,
(fullClasspath in Runtime).value,
(prods ++ intcp).distinct)(updateReport)
}
@ -102,7 +102,7 @@ object GlobalPlugin {
final case class GlobalPluginData(projectID: ModuleID,
dependencies: Seq[ModuleID],
descriptors: Map[ModuleRevisionId, ModuleDescriptor],
resolvers: Seq[Resolver],
resolvers: Vector[Resolver],
fullClasspath: Classpath,
internalClasspath: Classpath)(val updateReport: UpdateReport)
final case class GlobalPlugin(data: GlobalPluginData,

2
main/src/main/scala/sbt/internal/IvyConsole.scala
View File

@ -41,7 +41,7 @@ object IvyConsole {
val depSettings: Seq[Setting[_]] = Seq(
libraryDependencies ++= managed.reverse,
resolvers ++= repos.reverse,
resolvers ++= repos.reverse.toVector,
unmanagedJars in Compile ++= Attributed blankSeq unmanaged.reverse,
logLevel in Global := Level.Warn,
showSuccess in Global := false

40
main/src/main/scala/sbt/internal/LibraryManagement.scala
View File

@ -7,15 +7,15 @@ import sbt.internal.util.HNil
import sbt.internal.util.Types._
import sbt.internal.util.HListFormats._
import sbt.librarymanagement._
import sbt.librarymanagement.ivy._
import sbt.librarymanagement.syntax._
import sbt.util.CacheImplicits._
import sbt.util.{ CacheStore, CacheStoreFactory, Logger, Tracked }
object LibraryManagement {
private[sbt] object LibraryManagement {
private type UpdateInputs = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil
private[sbt] def cachedUpdate(
def cachedUpdate(
cacheStoreFactory: CacheStoreFactory,
label: String,
module: IvySbt#Module,
@ -25,7 +25,6 @@ object LibraryManagement {
force: Boolean,
depsUpdated: Boolean,
uwConfig: UnresolvedWarningConfiguration,
logicalClock: LogicalClock,
depDir: Option[File],
ewo: EvictionWarningOptions,
mavenStyle: Boolean,
@ -40,7 +39,7 @@ object LibraryManagement {
log.info(s"Updating $label...")
val reportOrUnresolved: Either[UnresolvedWarning, UpdateReport] =
//try {
IvyActions.updateEither(module, updateConfig, uwConfig, logicalClock, depDir, log)
IvyActions.updateEither(module, updateConfig, uwConfig, /*logicalClock, depDir,*/ log)
// } catch {
// case e: Throwable =>
// e.printStackTrace
@ -117,10 +116,39 @@ object LibraryManagement {
val settings = module.moduleSettings
val outStore = cacheStoreFactory.make("output")
val handler = if (skip && !force) skipResolve(outStore) else doResolve(outStore)
handler(ivyConfig :+: settings :+: updateConfig :+: HNil)
// Remove clock for caching purpose
val withoutClock = updateConfig.withLogicalClock(LogicalClock.unknown)
handler(ivyConfig :+: settings :+: withoutClock :+: HNil)
}
private[this] def fileUptodate(file: File, stamps: Map[File, Long]): Boolean =
stamps.get(file).forall(_ == file.lastModified)
private[sbt] def transitiveScratch(
lm: DependencyResolution,
label: String,
config: GetClassifiersConfiguration,
uwconfig: UnresolvedWarningConfiguration,
log: Logger
): Either[UnresolvedWarning, UpdateReport] = {
import config.{ updateConfiguration => c, module => mod }
import mod.{ id, dependencies => deps, scalaModuleInfo }
val base = restrictedCopy(id, true).withName(id.name + "$" + label)
val module = lm.moduleDescriptor(base, deps, scalaModuleInfo)
val report = lm.update(module, c, uwconfig, log) match {
case Right(r) => r
case Left(w) =>
throw w.resolveException
}
val newConfig = config
.withModule(mod.withDependencies(report.allModules))
lm.updateClassifiers(newConfig, uwconfig, Vector(), log)
}
private[sbt] def restrictedCopy(m: ModuleID, confs: Boolean) =
ModuleID(m.organization, m.name, m.revision)
.withCrossVersion(m.crossVersion)
.withExtraAttributes(m.extraAttributes)
.withConfigurations(if (confs) m.configurations else None)
.branch(m.branchName)
}

26
main/src/main/scala/sbt/internal/Load.scala
View File

@ -31,13 +31,13 @@ import Keys.{
}
import Project.inScope
import sbt.internal.inc.classpath.ClasspathUtilities
import sbt.internal.librarymanagement.{ InlineIvyConfiguration, IvyPaths }
import sbt.librarymanagement.ivy.{ InlineIvyConfiguration, IvyDependencyResolution, IvyPaths }
import sbt.internal.inc.{ ZincUtil, ScalaInstance }
import sbt.internal.util.Attributed.data
import sbt.internal.util.Types.const
import sbt.internal.util.{ Attributed, Settings, ~> }
import sbt.io.{ GlobFilter, IO, Path }
import sbt.librarymanagement.{ Configuration, Configurations, Resolver, UpdateOptions }
import sbt.librarymanagement.{ Configuration, Configurations, Resolver }
import sbt.util.{ Show, Logger }
import scala.annotation.tailrec
import scala.tools.nsc.reporters.ConsoleReporter
@ -79,18 +79,12 @@ private[sbt] object Load {
val stagingDirectory = getStagingDirectory(state, globalBase).getCanonicalFile
val loader = getClass.getClassLoader
val classpath = Attributed.blankSeq(provider.mainClasspath ++ scalaProvider.jars)
val ivyConfiguration = new InlineIvyConfiguration(
paths = IvyPaths(baseDirectory, bootIvyHome(state.configuration)),
resolvers = Resolver.withDefaultResolvers(Nil).toVector,
otherResolvers = Vector.empty,
moduleConfigurations = Vector.empty,
lock = None,
checksums = Vector.empty,
managedChecksums = false,
resolutionCacheDir = None,
updateOptions = UpdateOptions(),
log = log
)
val ivyConfiguration =
InlineIvyConfiguration()
.withPaths(IvyPaths(baseDirectory, bootIvyHome(state.configuration)))
.withResolvers(Resolver.combineDefaultResolvers(Vector.empty))
.withLog(log)
val dependencyResolution = IvyDependencyResolution(ivyConfiguration)
val si = ScalaInstance(scalaProvider.version, scalaProvider.launcher)
val zincDir = BuildPaths.getZincDirectory(state, globalBase)
val classpathOptions = ClasspathOptionsUtil.boot
@ -100,7 +94,7 @@ private[sbt] object Load {
globalLock = launcher.globalLock,
componentProvider = app.provider.components,
secondaryCacheDir = Option(zincDir),
ivyConfiguration = ivyConfiguration,
dependencyResolution = dependencyResolution,
compilerBridgeSource = ZincUtil.getDefaultBridgeModule(scalaProvider.version),
scalaJarsTarget = zincDir,
log = log
@ -1136,7 +1130,7 @@ private[sbt] object Load {
PluginData(
removeEntries(cp, prod),
prod,
Some(fullResolvers.value),
Some(fullResolvers.value.toVector),
Some(update.value),
opts
)

7
main/src/main/scala/sbt/internal/LogManager.scala
View File

@ -164,10 +164,11 @@ object LogManager {
): SuppressedTraceContext => Option[String] = {
lazy val display = Project.showContextKey(state)
def commandBase = "last " + display.show(unwrapStreamsKey(key))
def command(useColor: Boolean) =
if (useColor) BLUE + commandBase + RESET else s"'$commandBase'"
def command(useFormat: Boolean) =
if (useFormat) BLUE + commandBase + RESET else s"'$commandBase'"
context =>
Some("Stack trace suppressed: run %s for the full output.".format(command(context.useColor)))
Some(
"Stack trace suppressed: run %s for the full output.".format(command(context.useFormat)))
}
def unwrapStreamsKey(key: ScopedKey[_]): ScopedKey[_] = key.scope.task match {

2
main/src/main/scala/sbt/internal/PluginManagement.scala
View File

@ -27,7 +27,7 @@ final case class PluginManagement(overrides: Set[ModuleID],
addOverrides(extractOverrides(cp))
def inject: Seq[Setting[_]] = Seq(
Keys.dependencyOverrides ++= overrides
Keys.dependencyOverrides ++= overrides.toVector
)
def resetDepth: PluginManagement =

2
main/src/main/scala/sbt/internal/RelayAppender.scala
View File

@ -10,7 +10,7 @@ import sbt.util.Level
import sbt.internal.util._
import sbt.protocol.LogEvent
import sbt.internal.util.codec._
import scalajson.ast.unsafe._
import sjsonnew.shaded.scalajson.ast.unsafe._
class RelayAppender(name: String)
extends AbstractAppender(name, null, PatternLayout.createDefaultLayout(), true) {

2
main/src/main/scala/sbt/internal/librarymanagement/FakeRawRepository.scala
View File

@ -7,5 +7,5 @@ import sbt.librarymanagement.RawRepository
object FakeRawRepository {
def create(name: String): RawRepository =
new RawRepository(new FakeResolver(name, IO.createTemporaryDirectory, Map.empty))
new RawRepository(new FakeResolver(name, IO.createTemporaryDirectory, Map.empty), name)
}

2
main/src/main/scala/sbt/internal/server/SettingQuery.scala
View File

@ -6,7 +6,7 @@ package internal
package server
import java.net.URI
import scalajson.ast.unsafe.JValue
import sjsonnew.shaded.scalajson.ast.unsafe.JValue
import scala.util.{ Left, Right }
import sbt.util.{ SomeJsonWriter, NoJsonWriter }
import sbt.librarymanagement.LibraryManagementCodec._

182
notes/1.0.0.markdown
View File

@ -1,16 +1,56 @@
See [sbt 1.0 roadmap and beta-1][sbt-1-0-roadmap] for scheduled timeline.
### sbt 1.0.0-M6
### sbt 1.0.0-RC1
This is the beta-2 release of sbt 1.0.
### Changes since sbt 1.0.0-M5
This is the RC-1 release of sbt 1.0.
#### Features, fixes, changes with compatibility implications
- Many of the case classes are replaced with pseudo case classes generated using Contraband. Migrate `.copy(foo = xxx)` to `withFoo(xxx)`.
- sbt 1.0 uses Scala 2.12 for build definitions and plugins. This also requires JDK 8.
- Non-auto `sbt.Plugin` trait is dropped. Please migrate to AutoPlugin. Auto plugins are easier to configure, and work better with each other.
- sbt 0.12 style `Build` trait that was deprecated in sbt 0.13.12, is removed. Please [migrate to build.sbt](http://www.scala-sbt.org/0.13/docs/Migrating-from-sbt-012x.html#Migrating+from+the+Build+trait). Auto plugins and `Build` trait do not work well together, and its feature is now largely subsumed by multi-project build.sbt.
- sbt 0.12 style `Project(...)` constructor is restricted down to two parameters. This is because `settings` parameter does not work well with Auto Plugins. Use `project` instead.
- sbt 0.12 style key dependency operators `<<=`, `<+=`, `<++=` are removed. Please [migrate to :=, +=, and ++=](http://www.scala-sbt.org/0.13/docs/Migrating-from-sbt-012x.html#Migrating+simple+expressions). These operators have been sources of confusion for many users, and have long been removed from 0.13 docs, and have been formally deprecated since sbt 0.13.13.
- Zinc 1 drops support for Scala 2.9 and earlier. Scala 2.10 must use 2.10.2 and above. Scala 2.11 must use 2.11.2 and above. (latest patch releases are recommended)
- `config("tooling")` must be directly assigned to a *capitalized* `val`, like `val Tooling = config("tooling")`. This captures the lhs identifier into the configuration so we can use it from the shell later.
- Changes `publishTo` and `otherResolvers` from SettingKeys to TaskKeys. [#2059][2059]/[#2662][2662] by [@dwijnand][@dwijnand]
- `PathFinder`'s `.***` method is renamed to `.allPaths` method.
- Drops sbt 0.12 style hyphen-separated key names (use `publishLocal` instead of `publish-local`).
- Renames early command feature from `--<command>` to `early(<command>)`.
- Log options `-error`, `-warn`, `-info`, `-debug` are added as shorthand for `"early(error)"` etc.
- `sbt.Process` and `sbt.ProcessExtra` are dropped. Use `scala.sys.process` instead.
- `incOptions.value.withNameHashing(...)` option is removed because name hashing is always on.
- `TestResult.Value` is now called `TestResult`.
- The scripted plugin is cross-versioned now, so you must use `%%` when depending on it
- Removes the `settingsSets` method from `Project` (along with `add/setSbtFiles`).
- Drops deprecated `InputTask` `apply` method and `inputTask` DSL method. Use `Def.inputTask` and `Def.spaceDelimited().parsed`.
- Drops deprecated `ProjectReference` implicit lifts. Use `RootProject(<uri>)`, `RootProject(<file>)` or `LocalProject(<string>)`.
- Drops deprecated `seq(..)` DSL method. Use `Seq` or pass in the settings without wrapping.
- Drops deprecated `File`/`Seq[File]` setting enrichments. Use `.value` and `Def.setting`.
- Drops deprecated `SubProcess` `apply` overload. Use `SubProcess(ForkOptions(runJVMOptions = ..))`.
- Drops `toError(opt: Option[String]): Unit` (equivalent to `opt foreach sys.error`); if used to wrap
`ScalaRun#run` then the replacement is `scalaRun.run(...).failed foreach (sys error _.getMessage)`
- A number of the methods on `sbt.Path` (such as `relativeTo` and `rebase` and `flat`) are now no longer in the
default namespace by virtue of being mixed into the sbt package object. Use `sbt.io.Path` to access them
again.
- sbt 1.0 renames `Global` as scope component to `Zero` to disambiguate from `GlobalScope`. [@eed3si9n][@eed3si9n]
- sbt 1.0 uses `ConfigRef` in places where `String` was used to reference configuration, such as `update.value.configuration(...)`. Pass in `Configuration`, which implicitly converts to `ConfigRef`.
- Changes `sourceArtifactTypes` and `docArtifactTypes` from `Set[String]` to `Seq[String]` settings.
The Scala Center is working with Lightbend to provide [an automatic migration tool][sbt-migration-rewrites].
- sbt 1.0 renames `Global` as scope component to `Zero` to disambiguate from `GlobalScope`. [@eed3si9n][@eed3si9n]
#### Zinc API changes
- Java classes under the `xsbti.compile` package such as `IncOptions` hides the constructor. Use the factory method `xsbti.compile.Foo.of(...)`.
- Renames `ivyScala: IvyScala` key to `scalaModuleInfo: ScalaModuleInfo`.
- `xsbti.Reporter#log(...)` takes `xsbti.Problem` as the parameter. Call `log(problem.position, problem.message, problem.severity)` to delegate to the older `log(...)`.
- `xsbi.Maybe`, `xsbti.F0`, and `sxbti.F1` are changed to corresponding Java 8 classes `java.util.Optional`, `java.util.Supplier` and `java.util.Function`.
#### Features
- New incremental compiler called Zinc 1. Details below.
- The interactive shell is adds network API. Details below.
#### Fixes
@ -26,6 +66,12 @@ The Scala Center is working with Lightbend to provide [an automatic migration to
- Scala Center contributed a Java-friendly Zinc API. This was a overhaul of the Zinc internal API for a good Scala integration with other build tools. [zinc#304][zinc304] by [@jvican][@jvican]
- Ivy engine with parallel artifact download. See below.
- Scala Center contributed static validation of `build.sbt`. See below
- The startup log level is dropped to `-error` in script mode using `scalas`. [#840][840] by [@eed3si9n][@eed3si9n]
- Replace cross building support with sbt-doge. This allows builds with projects that have multiple different combinations of cross scala versions to be cross built correctly. The behaviour of ++ is changed so that it only updates the Scala version of projects that support that Scala version, but the Scala version can be post fixed with ! to force it to change for all projects. A -v argument has been added that prints verbose information about which projects are having their settings changed along with their cross scala versions. [#2613][2613] by [@jroper][@jroper]
- `ivyLoggingLevel` is dropped to `UpdateLogging.Quiet` when CI environment is detected. [@eed3si9n][@eed3si9n]
- Add logging of the name of the different `build.sbt` (matching `*.sbt`) files used. [#1911][1911] by [@valydia][@valydia]
- Add the ability to call `aggregate` for the current project inside a build sbt file. By [@xuwei-k][@xuwei-k]
- Add new global setting `asciiGraphWidth` that controls the maximum width of the ASCII graphs printed by commands like `inspect tree`. Default value corresponds to the previously hardcoded value of 40 characters. By [@RomanIakovlev][@RomanIakovlev].
- Revamped documentation for [Scopes](www.scala-sbt.org/0.13/docs/Scopes.html), and added [Scope Delegation](www.scala-sbt.org/0.13/docs/Scope-Delegation.html). [@eed3si9n][@eed3si9n]
- Ports sbt-cross-building's `^` and `^^` commands for plugin cross building. See below.
- Adds support for cross-versioned exclusions. [#1518][1518]/[lm#88][lm88] by [@jvican][@jvican]
@ -37,6 +83,41 @@ The Scala Center is working with Lightbend to provide [an automatic migration to
- For faster startup, reuse the same global instance for parsing. [#3115][3115] by [@jvican][@jvican]
- Adds `InteractionService` from sbt-core-next to keep compatibility with sbt 0.13. [#3182][3182] by [@eed3si9n][@eed3si9n]
#### Internals
- Adopted Scalafmt for formatting the source code using neo-scalafmt.
- Scala Center contributed a redesign of the scripted test framework that has batch mode execution. Scripted now reuses the same sbt instance to run sbt tests, which reduces the CI build times by 50% [#3151][3151] by [@jvican][@jvican]
- sbt 1.0.0-M6 is built using sbt 1.0.0-M5. [#3184][3184] by [@dwijnand][@dwijnand]
### Details of major changes
### Zinc 1: Class-based name hashing
A major improvement brought into Zinc 1.0 by Grzegorz Kossakowski (commissioned by Lightbend) is class-based name hashing, which will speed up the incremental compilation of Scala in large projects.
Zinc 1.0's name hashing tracks your code dependendencies at the class level, instead of at the source file level. The GitHub issue [sbt/sbt#1104](https://github.com/sbt/sbt/issues/1104) lists some comparisons of adding a method to an existing class in some projects:
```
ScalaTest AndHaveWord class: Before 49s, After 4s (12x)
Specs2 OptionResultMatcher class: Before 48s, After 1s (48x)
scala/scala Platform class: Before 59s, After 15s (3.9x)
scala/scala MatchCodeGen class: Before 48s, After 17s (2.8x)
```
This depends on some factors such as how your classes are organized, but you can see 3x ~ 40x improvements. The reason for the speedup is because it compiles fewer source files than before by untangling the classes from source files. In the example adding a method to scala/scala's Platform class, sbt 0.13's name hashing used to compile 72 sources, but the new Zinc compiles 6 sources.
### sbt server: JSON API for tooling integration
sbt 1.0 includes server feature, which allows IDEs and other tools to query the build for settings, and invoke commands via a JSON API. Similar to the way that the interactive shell in sbt 0.13 is implemented with `shell` command, "server" is also just `shell` command that listens to both human input and network input. As a user, there should be minimal impact because of the server.
In March 2016, we [rebooted](http://eed3si9n.com/sbt-server-reboot) the "server" feature to make it as small as possible. We worked in collaboration with JetBrains' @jastice who works on IntelliJ's sbt interface to narrow down the feature list. sbt 1.0 will not have all the things we originally wanted, but in the long term, we hope to see better integration between IDE and sbt ecosystem using this system. For example, IDEs will be able to issue the compile task and retrieve compiler warning as JSON events:
```
{"type":"xsbti.Problem","message":{"category":"","severity":"Warn","message":"a pure expression does nothing in statement position; you may be omitting necessary parentheses","position":{"line":2,"lineContent":" 1","offset":29,"pointer":2,"pointerSpace":" ","sourcePath":"/tmp/hello/Hello.scala","sourceFile":"file:/tmp/hello/Hello.scala"}},"level":"warn"}
```
Another related feature that was added is the `bgRun` task which, for example, enables a server process to be run in the background while you run tests against it.
#### Static validation of build.sbt
sbt 1.0 prohibits `.value` calls inside the bodies of if expressions and anonymous functions in a task, `@sbtUnchecked` annotation can be used to override the check.
@ -45,12 +126,6 @@ The static validation also catches if you forget to call `.value` in a body of a
[#3216][3216] and [#3225][3225] by [@jvican][@jvican]
#### Internals
- Adopted Scalafmt for formatting the source code using neo-scalafmt.
- Scala Center contributed a redesign of the scripted test framework that has batch mode execution. Scripted now reuses the same sbt instance to run sbt tests, which reduces the CI build times by 50% [#3151][3151] by [@jvican][@jvican]
- sbt 1.0.0-M6 is built using sbt 1.0.0-M5. [#3184][3184] by [@dwijnand][@dwijnand]
#### Ivy engine with parallel artifact download
sbt 1.0 adds parallel artifact download while still using Ivy for resolution, contributed by Scala Center.
@ -124,7 +199,6 @@ Then, run:
[#3133][3133] by [@eed3si9n][@eed3si9n] (forward ported from 0.13.16-M1)
#### notes
- https://github.com/sbt/sbt/compare/v1.0.0-M5...v1.0.0-M6
@ -132,90 +206,6 @@ Then, run:
- https://github.com/sbt/librarymanagement/compare/v1.0.0-X10...v1.0.0-X15
- https://github.com/sbt/util/compare/v1.0.0-M23...v1.0.0-M24
### sbt 1.0.0-M5
This is the beta-1 release of sbt 1.0.
There's no binary compatibility with sbt 0.13 or other future 1.0.0-Mx versions.
#### Features, fixes, changes with compatibility implications
We are working with Scala Center to provide [an automatic migration tool][sbt-migration-rewrites].
- sbt 1.0 uses Scala 2.12 for build definitions and plugins. This also requires JDK 8.
- Non-auto `sbt.Plugin` trait is dropped. Please migrate to AutoPlugin. Auto plugins are easier to configure, and work better with each other.
- sbt 0.12 style `Build` trait that was deprecated in sbt 0.13.12, is removed. Please [migrate to build.sbt](http://www.scala-sbt.org/0.13/docs/Migrating-from-sbt-012x.html#Migrating+from+the+Build+trait). Auto plugins and `Build` trait do not work well together, and its feature is now largely subsumed by multi-project build.sbt.
- sbt 0.12 style `Project(...)` constructor is restricted down to two parameters. This is because `settings` parameter does not work well with Auto Plugins. Use `project` instead.
- sbt 0.12 style key dependency operators `<<=`, `<+=`, `<++=` are removed. Please [migrate to :=, +=, and ++=](http://www.scala-sbt.org/0.13/docs/Migrating-from-sbt-012x.html#Migrating+simple+expressions). These operators have been sources of confusion for many users, and have long been removed from 0.13 docs, and have been formally deprecated since sbt 0.13.13.
- Zinc 1 drops support for Scala 2.9 and earlier. Scala 2.10 must use 2.10.2 and above. Scala 2.11 must use 2.11.2 and above. (latest patch releases are recommended)
- Many of the case classes are replaced with pseudo case classes generated using Contraband. Migrate `.copy(foo = xxx)` to `withFoo(xxx)`.
- Changes `publishTo` and `otherResolvers` from SettingKeys to TaskKeys. [#2059][2059]/[#2662][2662] by [@dwijnand][@dwijnand]
- `PathFinder`'s `.***` method is renamed to `.allPaths` method.
- Drops sbt 0.12 style hyphen-separated key names (use `publishLocal` instead of `publish-local`).
- Renames early command feature from `--<command>` to `early(<command>)`.
- Log options `-error`, `-warn`, `-info`, `-debug` are added as shorthand for `"early(error)"` etc.
- `sbt.Process` and `sbt.ProcessExtra` are dropped. Use `scala.sys.process` instead.
- `incOptions.value.withNameHashing(...)` option is removed because name hashing is always on.
- `TestResult.Value` is now called `TestResult`.
- The scripted plugin is cross-versioned now, so you must use `%%` when depending on it
- Removes the `settingsSets` method from `Project` (along with `add/setSbtFiles`).
- Drops deprecated `InputTask` `apply` method and `inputTask` DSL method. Use `Def.inputTask` and `Def.spaceDelimited().parsed`.
- Drops deprecated `ProjectReference` implicit lifts. Use `RootProject(<uri>)`, `RootProject(<file>)` or `LocalProject(<string>)`.
- Drops deprecated `seq(..)` DSL method. Use `Seq` or pass in the settings without wrapping.
- Drops deprecated `File`/`Seq[File]` setting enrichments. Use `.value` and `Def.setting`.
- Drops deprecated `SubProcess` `apply` overload. Use `SubProcess(ForkOptions(runJVMOptions = ..))`.
- Drops `toError(opt: Option[String]): Unit` (equivalent to `opt foreach sys.error`); if used to wrap
`ScalaRun#run` then the replacement is `scalaRun.run(...).failed foreach (sys error _.getMessage)`
- A number of the methods on `sbt.Path` (such as `relativeTo` and `rebase` and `flat`) are now no longer in the
default namespace by virtue of being mixed into the sbt package object. Use `sbt.io.Path` to access them
again.
#### Features
- New incremental compiler called Zinc 1. Details below.
- The interactive shell is adds network API. Details below.
#### Fixes
#### Improvements
- The startup log level is dropped to `-error` in script mode using `scalas`. [#840][840] by [@eed3si9n][@eed3si9n]
- Replace cross building support with sbt-doge. This allows builds with projects that have multiple different combinations of cross scala versions to be cross built correctly. The behaviour of ++ is changed so that it only updates the Scala version of projects that support that Scala version, but the Scala version can be post fixed with ! to force it to change for all projects. A -v argument has been added that prints verbose information about which projects are having their settings changed along with their cross scala versions. [#2613][2613] by [@jroper][@jroper]
- `ivyLoggingLevel` is dropped to `UpdateLogging.Quiet` when CI environment is detected. [@eed3si9n][@eed3si9n]
- Add logging of the name of the different `build.sbt` (matching `*.sbt`) files used. [#1911][1911] by [@valydia][@valydia]
- Add the ability to call `aggregate` for the current project inside a build sbt file. By [@xuwei-k][@xuwei-k]
- Add new global setting `asciiGraphWidth` that controls the maximum width of the ASCII graphs printed by commands like `inspect tree`. Default value corresponds to the previously hardcoded value of 40 characters. By [@RomanIakovlev][@RomanIakovlev].
### Details of major changes
### Zinc 1: Class-based name hashing
A major improvement brought into Zinc 1.0 by Grzegorz Kossakowski (commissioned by Lightbend) is class-based name hashing, which will speed up the incremental compilation of Scala in large projects.
Zinc 1.0's name hashing tracks your code dependendencies at the class level, instead of at the source file level. The GitHub issue [sbt/sbt#1104](https://github.com/sbt/sbt/issues/1104) lists some comparisons of adding a method to an existing class in some projects:
```
ScalaTest AndHaveWord class: Before 49s, After 4s (12x)
Specs2 OptionResultMatcher class: Before 48s, After 1s (48x)
scala/scala Platform class: Before 59s, After 15s (3.9x)
scala/scala MatchCodeGen class: Before 48s, After 17s (2.8x)
```
This depends on some factors such as how your classes are organized, but you can see 3x ~ 40x improvements. The reason for the speedup is because it compiles fewer source files than before by untangling the classes from source files. In the example adding a method to scala/scala's Platform class, sbt 0.13's name hashing used to compile 72 sources, but the new Zinc compiles 6 sources.
### sbt server: JSON API for tooling integration
sbt 1.0 includes server feature, which allows IDEs and other tools to query the build for settings, and invoke commands via a JSON API. Similar to the way that the interactive shell in sbt 0.13 is implemented with `shell` command, "server" is also just `shell` command that listens to both human input and network input. As a user, there should be minimal impact because of the server.
In March 2016, we [rebooted](http://eed3si9n.com/sbt-server-reboot) the "server" feature to make it as small as possible. We worked in collaboration with JetBrains' @jastice who works on IntelliJ's sbt interface to narrow down the feature list. sbt 1.0 will not have all the things we originally wanted, but in the long term, we hope to see better integration between IDE and sbt ecosystem using this system. For example, IDEs will be able to issue the compile task and retrieve compiler warning as JSON events:
```
{"type":"xsbti.Problem","message":{"category":"","severity":"Warn","message":"a pure expression does nothing in statement position; you may be omitting necessary parentheses","position":{"line":2,"lineContent":" 1","offset":29,"pointer":2,"pointerSpace":" ","sourcePath":"/tmp/hello/Hello.scala","sourceFile":"file:/tmp/hello/Hello.scala"}},"level":"warn"}
```
Another related feature that was added is the `bgRun` task which, for example, enables a server process to be run in the background while you run tests against it.
[@eed3si9n]: https://github.com/eed3si9n
[@dwijnand]: http://github.com/dwijnand
[@jvican]: https://github.com/jvican

2
project/ContrabandConfig.scala
View File

@ -32,7 +32,7 @@ object ContrabandConfig {
case "sbt.testing.Status" => { _ =>
"sbt.internal.testing.StatusFormats" :: Nil
}
case "scalajson.ast.unsafe.JValue" => { _ =>
case "scalajson.ast.unsafe.JValue" | "sjsonnew.shaded.scalajson.ast.unsafe.JValue" => { _ =>
"sbt.internal.util.codec.JValueFormats" :: Nil
}
}

12
project/Dependencies.scala
View File

@ -13,9 +13,9 @@ object Dependencies {
// sbt modules
private val ioVersion = "1.0.0-M12"
private val utilVersion = "1.0.0-M26"
private val lmVersion = "1.0.0-X17"
private val zincVersion = "1.0.0-X18"
private val utilVersion = "1.0.0-M28"
private val lmVersion = "1.0.0-X18"
private val zincVersion = "1.0.0-X20"
private val sbtIO = "org.scala-sbt" %% "io" % ioVersion
@ -27,7 +27,8 @@ object Dependencies {
private val utilTracking = "org.scala-sbt" %% "util-tracking" % utilVersion
private val utilScripted = "org.scala-sbt" %% "util-scripted" % utilVersion
private val libraryManagement = "org.scala-sbt" %% "librarymanagement" % lmVersion
private val libraryManagementCore = "org.scala-sbt" %% "librarymanagement-core" % lmVersion
private val libraryManagementIvy = "org.scala-sbt" %% "librarymanagement-ivy" % lmVersion
val launcherInterface = "org.scala-sbt" % "launcher-interface" % "1.0.0"
val rawLauncher = "org.scala-sbt" % "launcher" % "1.0.0"
@ -77,7 +78,8 @@ object Dependencies {
def addSbtUtilScripted(p: Project): Project =
addSbtModule(p, sbtUtilPath, "utilScripted", utilScripted)
def addSbtLm(p: Project): Project = addSbtModule(p, sbtLmPath, "lm", libraryManagement)
def addSbtLmCore(p: Project): Project = addSbtModule(p, sbtLmPath, "lmCore", libraryManagementCore)
def addSbtLmIvy(p: Project): Project = addSbtModule(p, sbtLmPath, "lmIvy", libraryManagementIvy)
def addSbtCompilerInterface(p: Project): Project =
addSbtModule(p, sbtZincPath, "compilerInterface", compilerInterface)

8
protocol/src/main/contraband-scala/sbt/protocol/SettingQuerySuccess.scala
View File

@ -5,7 +5,7 @@
// DO NOT EDIT MANUALLY
package sbt.protocol
final class SettingQuerySuccess private (
val value: scalajson.ast.unsafe.JValue,
val value: sjsonnew.shaded.scalajson.ast.unsafe.JValue,
val contentType: String) extends sbt.protocol.SettingQueryResponse() with Serializable {
@ -20,10 +20,10 @@ final class SettingQuerySuccess private (
override def toString: String = {
"SettingQuerySuccess(" + value + ", " + contentType + ")"
}
protected[this] def copy(value: scalajson.ast.unsafe.JValue = value, contentType: String = contentType): SettingQuerySuccess = {
protected[this] def copy(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue = value, contentType: String = contentType): SettingQuerySuccess = {
new SettingQuerySuccess(value, contentType)
}
def withValue(value: scalajson.ast.unsafe.JValue): SettingQuerySuccess = {
def withValue(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue): SettingQuerySuccess = {
copy(value = value)
}
def withContentType(contentType: String): SettingQuerySuccess = {
@ -32,5 +32,5 @@ final class SettingQuerySuccess private (
}
object SettingQuerySuccess {
def apply(value: scalajson.ast.unsafe.JValue, contentType: String): SettingQuerySuccess = new SettingQuerySuccess(value, contentType)
def apply(value: sjsonnew.shaded.scalajson.ast.unsafe.JValue, contentType: String): SettingQuerySuccess = new SettingQuerySuccess(value, contentType)
}

2
protocol/src/main/contraband-scala/sbt/protocol/codec/SettingQuerySuccessFormats.scala
View File

@ -11,7 +11,7 @@ implicit lazy val SettingQuerySuccessFormat: JsonFormat[sbt.protocol.SettingQuer
jsOpt match {
case Some(js) =>
unbuilder.beginObject(js)
val value = unbuilder.readField[scalajson.ast.unsafe.JValue]("value")
val value = unbuilder.readField[sjsonnew.shaded.scalajson.ast.unsafe.JValue]("value")
val contentType = unbuilder.readField[String]("contentType")
unbuilder.endObject()
sbt.protocol.SettingQuerySuccess(value, contentType)

2
protocol/src/main/contraband/server.contra
View File

@ -43,7 +43,7 @@ type ExecStatusEvent implements EventMessage {
interface SettingQueryResponse implements EventMessage {}
type SettingQuerySuccess implements SettingQueryResponse {
value: scalajson.ast.unsafe.JValue!
value: sjsonnew.shaded.scalajson.ast.unsafe.JValue!
contentType: String!
}

2
protocol/src/main/scala/sbt/protocol/Serialization.scala
View File

@ -6,7 +6,7 @@ package protocol
import sjsonnew.JsonFormat
import sjsonnew.support.scalajson.unsafe.{ Parser, Converter, CompactPrinter }
import scalajson.ast.unsafe.{ JValue, JObject, JString }
import sjsonnew.shaded.scalajson.ast.unsafe.{ JValue, JObject, JString }
import java.nio.ByteBuffer
import scala.util.{ Success, Failure }
import sbt.internal.util.StringEvent

14
run/src/main/scala/sbt/TrapExit.scala
View File

@ -9,15 +9,15 @@ package sbt
import scala.reflect.Manifest
import scala.collection.concurrent.TrieMap
import java.lang.ref.WeakReference
import Thread.currentThread
import java.security.Permission
import java.util.concurrent.{ ConcurrentHashMap => CMap }
import java.lang.Integer.{ toHexString => hex }
import java.util.function.Supplier
import sbt.util.Logger
import sbt.util.InterfaceUtil
import TrapExit._
/**
@ -39,7 +39,7 @@ object TrapExit {
*/
def apply(execute: => Unit, log: Logger): Int =
System.getSecurityManager match {
case m: TrapExit => m.runManaged(Logger.f0(execute), log)
case m: TrapExit => m.runManaged(InterfaceUtil.toSupplier(execute), log)
case _ => runUnmanaged(execute, log)
}
@ -149,12 +149,12 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
private[this] val threadToApp = new CMap[ThreadID, App]
/** Executes `f` in a managed context. */
def runManaged(f: xsbti.F0[Unit], xlog: xsbti.Logger): Int = {
def runManaged(f: Supplier[Unit], xlog: xsbti.Logger): Int = {
val _ = running.incrementAndGet()
try runManaged0(f, xlog)
finally running.decrementAndGet()
}
private[this] def runManaged0(f: xsbti.F0[Unit], xlog: xsbti.Logger): Int = {
private[this] def runManaged0(f: Supplier[Unit], xlog: xsbti.Logger): Int = {
val log: Logger = xlog
val app = new App(f, log)
val executionThread = app.mainThread
@ -214,7 +214,7 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
* `execute` is the application code to evaluate.
* `log` is used for debug logging.
*/
private final class App(val execute: xsbti.F0[Unit], val log: Logger) extends Runnable {
private final class App(val execute: Supplier[Unit], val log: Logger) extends Runnable {
/**
* Tracks threads and groups created by this application.
@ -249,7 +249,7 @@ private final class TrapExit(delegateManager: SecurityManager) extends SecurityM
val exitCode = new ExitCode
def run(): Unit = {
try execute()
try execute.get()
catch {
case x: Throwable =>
exitCode.set(1) //exceptions in the main thread cause the exit code to be 1

50
sbt/src/main/scala/Import.scala
View File

@ -8,6 +8,8 @@ trait Import {
type URI = java.net.URI
type URL = java.net.URL
implicit def Seq2Vector[T](s: Seq[T]): Vector[T] = s.toVector
// sbt
val StdoutOutput = sbt.OutputStrategy.StdoutOutput
type BufferedOutput = sbt.OutputStrategy.BufferedOutput
@ -225,8 +227,8 @@ trait Import {
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 CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
type CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
val Configuration = sbt.librarymanagement.Configuration
type Configuration = sbt.librarymanagement.Configuration
val ConfigurationReport = sbt.librarymanagement.ConfigurationReport
@ -236,33 +238,39 @@ trait Import {
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 Credentials = sbt.librarymanagement.ivy.Credentials
type Credentials = sbt.librarymanagement.ivy.Credentials
val CrossVersion = sbt.librarymanagement.CrossVersion
type CrossVersion = sbt.librarymanagement.CrossVersion
val DefaultMavenRepository = sbt.librarymanagement.DefaultMavenRepository
val DefaultMavenRepository = sbt.librarymanagement.Resolver.DefaultMavenRepository
val Developer = sbt.librarymanagement.Developer
type Developer = sbt.librarymanagement.Developer
val Disabled = sbt.librarymanagement.Disabled
type Disabled = sbt.librarymanagement.Disabled
type DirectCredentials = sbt.librarymanagement.DirectCredentials
type DirectCredentials = sbt.librarymanagement.ivy.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 ExclusionRule = sbt.librarymanagement.InclExclRule
// type ExclusionRule = sbt.librarymanagement.InclExclRule
type FileCredentials = sbt.librarymanagement.ivy.FileCredentials
val FileRepository = sbt.librarymanagement.FileRepository
type FileRepository = sbt.librarymanagement.FileRepository
val Full = sbt.librarymanagement.Full
type Full = sbt.librarymanagement.Full
val IvyScala = sbt.librarymanagement.IvyScala
type IvyScala = sbt.librarymanagement.IvyScala
val JCenterRepository = sbt.librarymanagement.JCenterRepository
val JavaNet2Repository = sbt.librarymanagement.JavaNet2Repository
val InlineConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
type InlineConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
val IvyScala = sbt.librarymanagement.ScalaModuleInfo
type IvyScala = sbt.librarymanagement.ScalaModuleInfo
val JCenterRepository = sbt.librarymanagement.Resolver.JCenterRepository
val JavaNet2Repository = sbt.librarymanagement.Resolver.JavaNet2Repository
type LogicalClock = sbt.librarymanagement.LogicalClock
val LogicalClock = sbt.librarymanagement.LogicalClock
type MakePomConfiguration = sbt.librarymanagement.MakePomConfiguration
val MakePomConfiguration = sbt.librarymanagement.MakePomConfiguration
val MavenCache = sbt.librarymanagement.MavenCache
type MavenCache = sbt.librarymanagement.MavenCache
val MavenRepo = sbt.librarymanagement.MavenRepo
@ -271,12 +279,16 @@ trait Import {
type MavenRepository = sbt.librarymanagement.MavenRepository
val ModuleConfiguration = sbt.librarymanagement.ModuleConfiguration
type ModuleConfiguration = sbt.librarymanagement.ModuleConfiguration
val ModuleDescriptorConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
type ModuleDescriptorConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
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 ModuleSettings = sbt.librarymanagement.ModuleSettings
type ModuleSettings = sbt.librarymanagement.ModuleSettings
val OrganizationArtifactReport = sbt.librarymanagement.OrganizationArtifactReport
type OrganizationArtifactReport = sbt.librarymanagement.OrganizationArtifactReport
val Patterns = sbt.librarymanagement.Patterns
@ -301,8 +313,8 @@ trait Import {
val URLRepository = sbt.librarymanagement.URLRepository
type URLRepository = sbt.librarymanagement.URLRepository
val UpdateLogging = sbt.librarymanagement.UpdateLogging
val UpdateOptions = sbt.librarymanagement.UpdateOptions
type UpdateOptions = sbt.librarymanagement.UpdateOptions
val UpdateOptions = sbt.librarymanagement.ivy.UpdateOptions
type UpdateOptions = sbt.librarymanagement.ivy.UpdateOptions
val UpdateReport = sbt.librarymanagement.UpdateReport
type UpdateReport = sbt.librarymanagement.UpdateReport
val UpdateStats = sbt.librarymanagement.UpdateStats
@ -311,9 +323,11 @@ trait Import {
type VersionNumber = sbt.librarymanagement.VersionNumber
type VersionNumberCompatibility = sbt.librarymanagement.VersionNumberCompatibility
// sbt.internal.librarymanagement
type IvyPaths = sbt.internal.librarymanagement.IvyPaths
val IvyPaths = sbt.internal.librarymanagement.IvyPaths
// sbt.librarymanagement.ivy
val InlineIvyConfiguration = sbt.librarymanagement.ivy.InlineIvyConfiguration
type InlineIvyConfiguration = sbt.librarymanagement.ivy.InlineIvyConfiguration
type IvyPaths = sbt.librarymanagement.ivy.IvyPaths
val IvyPaths = sbt.librarymanagement.ivy.IvyPaths
type IncOptions = xsbti.compile.IncOptions
}

23
sbt/src/main/scala/package.scala
View File

@ -1,3 +1,5 @@
import scala.language.experimental.macros
/* sbt -- Simple Build Tool
* Copyright 2010, 2011 Mark Harrah
*/
@ -5,8 +7,8 @@ package object sbt
extends sbt.IOSyntax0
with sbt.std.TaskExtra
with sbt.internal.util.Types
with sbt.internal.librarymanagement.impl.DependencyBuilders
with sbt.ProjectExtra
with sbt.librarymanagement.DependencyBuilders
with sbt.librarymanagement.DependencyFilterExtra
with sbt.librarymanagement.LibraryManagementSyntax
with sbt.BuildExtra
@ -36,15 +38,16 @@ package object sbt
final val Global = Scope.Global
final val GlobalScope = Scope.GlobalScope
import sbt.{ Configurations => C }
final val Compile = C.Compile
final val Test = C.Test
final val Runtime = C.Runtime
final val IntegrationTest = C.IntegrationTest
final val Default = C.Default
final val Provided = C.Provided
// import sbt.{ Configurations => C }
// final val Compile = C.Compile
// final val Test = C.Test
// final val Runtime = C.Runtime
// final val IntegrationTest = C.IntegrationTest
// final val Default = C.Default
// final val Provided = C.Provided
// java.lang.System is more important, so don't alias this one
// final val System = C.System
final val Optional = C.Optional
def config(s: String): Configuration = C.config(s)
// final val Optional = C.Optional
def config(name: String): Configuration =
macro sbt.librarymanagement.ConfigurationMacro.configMacroImpl
}

2
sbt/src/sbt-test/actions/external-doc/build.sbt
View File

@ -31,7 +31,7 @@ val checkApiMappings = taskKey[Unit]("Verifies that the API mappings are collect
def expectedMappings = Def.task {
val version = scalaVersion.value
val binVersion = scalaBinaryVersion.value
val ms = update.value.configuration(Compile.name).get.modules.flatMap { mod =>
val ms = update.value.configuration(Compile).get.modules.flatMap { mod =>
mod.artifacts.flatMap { case (a,f) =>
val n = a.name.stripSuffix("_" + binVersion)
n match {

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

@ -1,5 +1,5 @@
lazy val root = (project in file(".")).
settings(
incOptions := xsbti.compile.IncOptionsUtil.defaultIncOptions,
incOptions := xsbti.compile.IncOptions.of(),
scalaVersion := "2.11.7"
)

43
sbt/src/sbt-test/compiler-project/macro-config/build.sbt
View File

@ -1,24 +1,33 @@
// Adds a "macro" configuration for macro dependencies.
// Defines "macro" configuration.
// By default, this includes the dependencies of the normal sources.
// Drop the `extend(Compile)` to include no dependencies (not even scala-library) by default.
ivyConfigurations += config("macro").hide.extend(Compile)
val Macro = config("macro").hide.extend(Compile)
// add the compiler as a dependency for src/macro/
libraryDependencies +=
scalaVersion("org.scala-lang" % "scala-compiler" % _ % "macro").value
lazy val root = (project in file("."))
.settings(
scalaVersion := "2.12.2",
// adds standard compile, console, package tasks for src/macro/
inConfig(config("macro"))(Defaults.configSettings)
// Adds a "macro" configuration for macro dependencies.
ivyConfigurations.value += Macro,
// puts the compiled macro on the classpath for the main sources
unmanagedClasspath in Compile ++=
(fullClasspath in config("macro")).value
// add the compiler as a dependency for src/macro/
libraryDependencies += {
"org.scala-lang" % "scala-compiler" % scalaVersion.value % Macro
},
// includes sources in src/macro/ in the main source package
mappings in (Compile, packageSrc) ++=
(mappings in (config("macro"), packageSrc)).value
// adds standard compile, console, package tasks for src/macro/
inConfig(Macro)(Defaults.configSettings),
// Includes classes compiled from src/macro/ in the main binary
// This can be omitted if the classes in src/macro/ aren't used at runtime
mappings in (Compile, packageBin) ++=
(mappings in (config("macro"), packageBin)).value
// puts the compiled macro on the classpath for the main sources
unmanagedClasspath in Compile ++=
(fullClasspath in Macro).value,
// includes sources in src/macro/ in the main source package
mappings in (Compile, packageSrc) ++=
(mappings in (Macro, packageSrc)).value,
// Includes classes compiled from src/macro/ in the main binary
// This can be omitted if the classes in src/macro/ aren't used at runtime
mappings in (Compile, packageBin) ++=
(mappings in (Macro, packageBin)).value
)

0
sbt/src/sbt-test/compiler-project/macro-config/test → sbt/src/sbt-test/compiler-project/macro-config/disabled
View File

3
sbt/src/sbt-test/compiler-project/semantic-errors/project/src/main/scala/sbt/TestPlugin.scala
View File

@ -31,6 +31,9 @@ class CollectingReporter extends xsbti.Reporter {
def printSummary(): Unit = ()
def problems: Array[xsbti.Problem] = buffer.toArray
def log(problem: xsbti.Problem): Unit =
log(problem.position, problem.message, problem.severity)
/** Logs a message. */
def log(pos: xsbti.Position, msg: String, sev: xsbti.Severity): Unit = {
object MyProblem extends xsbti.Problem {

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

@ -5,7 +5,7 @@ scalaVersion := "2.10.6"
crossScalaVersions := List("2.10.6", "2.11.8")
incOptions := incOptions.value.withClassfileManagerType(
Option(new xsbti.compile.TransactionalManagerType(
Option(xsbti.compile.TransactionalManagerType.of(
crossTarget.value / "classes.bak",
(streams in (Compile, compile)).value.log
): xsbti.compile.ClassFileManagerType).asJava

2
sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt
View File

@ -6,7 +6,7 @@ val b = project
localCache,
scalaVersion := "2.11.8",
libraryDependencies += "org.example" %% "artifacta" % "1.0.0-SNAPSHOT" withSources() classifier("tests"),
externalResolvers := Seq(
externalResolvers := Vector(
MavenCache("demo", ((baseDirectory in ThisBuild).value / "demo-repo")),
DefaultMavenRepository
)

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

@ -4,6 +4,23 @@ dependencyOverrides in ThisBuild += "com.github.nscala-time" %% "nscala-time" %
lazy val root = (project in file("."))
.dependsOn(p1 % Compile)
.settings(
inThisBuild(List(
organizationName := "eed3si9n",
organizationHomepage := Some(url("http://example.com/")),
homepage := Some(url("https://github.com/example/example")),
scmInfo := Some(ScmInfo(url("https://github.com/example/example"), "git@github.com:example/example.git")),
developers := List(
Developer("harrah", "Mark Harrah", "@harrah", url("https://github.com/harrah")),
Developer("eed3si9n", "Eugene Yokota", "@eed3si9n", url("https://github.com/eed3si9n")),
Developer("jsuereth", "Josh Suereth", "@jsuereth", url("https://github.com/jsuereth")),
Developer("dwijnand", "Dale Wijnand", "@dwijnand", url("https://github.com/dwijnand")),
Developer("gkossakowski", "Grzegorz Kossakowski", "@gkossakowski", url("https://github.com/gkossakowski")),
Developer("Duhemm", "Martin Duhem", "@Duhemm", url("https://github.com/Duhemm"))
),
version := "0.3.1-SNAPSHOT",
description := "An HTTP client for Scala with Async Http Client underneath.",
licenses := Seq("Apache 2" -> new URL("http://www.apache.org/licenses/LICENSE-2.0.txt")),
)),
ivyPaths := IvyPaths(
(baseDirectory in ThisBuild).value,
Some((baseDirectory in LocalRootProject).value / "ivy-cache")
@ -16,10 +33,16 @@ lazy val root = (project in file("."))
val s = (streams in update).value
val cacheStoreFactory = s.cacheStoreFactory sub updateCacheName.value
val module = ivyModule.value
val config = updateConfiguration.value
val updateConfig = updateConfiguration.value
val ivyConfiguration0 = module.owner.configuration
val moduleSettings0 = module.moduleSettings
val inline0 = moduleSettings0 match { case x: InlineConfiguration => x }
// Remove clock for caching purpose
val updateConfig0 = updateConfig.withLogicalClock(LogicalClock.unknown)
import sbt.internal.librarymanagement.IvyConfiguration
import sbt.librarymanagement.ivy.IvyConfiguration
import sbt.librarymanagement.{ ModuleSettings, UpdateConfiguration }
import sbt.internal.util.HListFormats._
type In = IvyConfiguration :+: ModuleSettings :+: UpdateConfiguration :+: HNil
@ -29,10 +52,41 @@ lazy val root = (project in file("."))
val f: In => Unit =
Tracked.inputChanged(cacheStoreFactory make "inputs") { (inChanged: Boolean, in: In) =>
if (inChanged)
sys.error(s"Update cache is invalidated: ${module.owner.configuration}, ${module.moduleSettings}, $config")
val ivyConfiguration1 = in.head
val moduleSettings1 = in.tail.head
val inline1 = moduleSettings1 match { case x: InlineConfiguration => x }
val updateConfig1 = in.tail.tail.head
if (inChanged) {
sys.error(s"""
ivyConfiguration1 == ivyConfiguration0: ${ivyConfiguration1 == ivyConfiguration0}
ivyConfiguration1:
$ivyConfiguration1
ivyConfiguration0
$ivyConfiguration0
-----
inline1 == inline0: ${inline1 == inline0}
inline1:
$inline1
inline0
$inline0
-----
updateConfig1 == updateConfig0: ${updateConfig1 == updateConfig0}
updateConfig1:
$updateConfig1
updateConfig0
$updateConfig0
""")
}
}
f(module.owner.configuration :+: module.moduleSettings :+: config :+: HNil)
f(ivyConfiguration0 :+: (inline0: ModuleSettings) :+: updateConfig0 :+: HNil)
},
// https://github.com/sbt/sbt/issues/3226

3
sbt/src/sbt-test/dependency-management/cache-update/test
View File

@ -1,3 +1,6 @@
> compile
$ sleep 2000
> check
$ sleep 2000
> check
> check2

6
sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt
View File

@ -69,9 +69,9 @@ lazy val root = (project in file(".")).
if (!(acp contains "commons-io-1.4-sources.jar")) {
sys.error("commons-io-1.4-sources not found when it should be included: " + acp.toString)
}
if (!(acp contains "commons-io-1.4.jar")) {
sys.error("commons-io-1.4 not found when it should be included: " + acp.toString)
}
// if (!(acp contains "commons-io-1.4.jar")) {
// sys.error("commons-io-1.4 not found when it should be included: " + acp.toString)
// }
// stock Ivy implementation doesn't contain regular (non-source) jar, which probably is a bug
val acpWithoutSource = acp filterNot { _ == "commons-io-1.4.jar"}

10
sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/pending
View File

@ -1,10 +0,0 @@
# Quoting @eed3si9n in https://github.com/dwijnand/sbt-lm/pull/1 :
# > After several experiments, I'm actually convinced that force() is unrelated to the scripted scenario,
# > and it's # currently passing by virtue of the questionable caching behavior:
# > https://github.com/sbt/sbt/blob/c223dccb542beaf763a3a2909cda74bdad39beca/ivy/src/main/scala/sbt/ivyint/CachedResolutionResolveEngine.scala#L715
# > I think we can mark the failing test as pending for now.
> y1/publishLocal
> y2/publishLocal
> debug
> check

4
sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/test Normal file
View File

@ -0,0 +1,4 @@
> y1/publishLocal
> y2/publishLocal
> debug
> check

4
sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt
View File

@ -1,4 +1,4 @@
configurationsToRetrieve := Some(Set(Compile))
configurationsToRetrieve := Some(Vector(Compile))
retrieveManaged := true
@ -8,4 +8,4 @@ autoScalaLibrary := false
managedDirectory := file("dependencies")
retrievePattern := "[conf]/[artifact]-[revision](-[classifier]).[ext]"
retrievePattern := "[conf]/[artifact]-[revision](-[classifier]).[ext]"

4
sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt
View File

@ -1,6 +1,6 @@
import scala.xml.{ Node, _ }
import scala.xml.Utility.trim
import sbt.internal.librarymanagement.{ IvySbt, MakePomConfiguration, MakePom }
import sbt.internal.librarymanagement.{ IvySbt, MakePom }
lazy val check = taskKey[Unit]("check")
@ -59,6 +59,6 @@ def makePomXml(log: Logger, makePomConfig: MakePomConfiguration, ivyModule: IvyS
ivyModule.withModule[Node](log) { (ivy, md, default) =>
import makePomConfig._
new MakePom(log).toPom(
ivy, md, moduleInfo, configurations, includeTypes, extra, filterRepositories, allRepositories)
ivy, md, moduleInfo.get, configurations, includeTypes, extra.get, filterRepositories, allRepositories)
}
}

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

@ -6,7 +6,7 @@ lazy val root = (project in file(".")).
settings(
libraryDependencies ++= baseDirectory(dependencies).value,
scalaVersion := "2.9.2",
ivyScala := ivyScala.value map (_.withOverrideScalaVersion(sbtPlugin.value)),
scalaModuleInfo := scalaModuleInfo.value map (_.withOverrideScalaVersion(sbtPlugin.value)),
autoScalaLibrary := baseDirectory(base => !(base / "noscala").exists ).value,
scalaOverride := check("scala.App").value
)

31
sbt/src/sbt-test/dependency-management/extra/DefineColor.sbt
View File

@ -1,15 +1,16 @@
ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
publishMavenStyle := false
publishTo := (baseDirectory { base =>
Some(Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns))
}).value
projectID := (projectID { _.extra("e:color" -> "red") }).value
organization := "org.scala-sbt"
version := "1.0"
name := "define-color"
lazy val root = (project in file("."))
.settings(
organization := "com.example",
version := "1.0",
name := "define-color",
projectID := {
val old = projectID.value
old.extra("e:color" -> "red")
},
ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
publishMavenStyle := false,
publishTo := {
val base = baseDirectory.value
Some(Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns))
}
)

33
sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt
View File

@ -1,17 +1,16 @@
ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
publishMavenStyle := false
resolvers := baseDirectory( base =>
Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns) :: Nil
).value
libraryDependencies := (baseDirectory { base =>
val color = IO.read(base / "color")
val dep = "org.scala-sbt" %% "define-color" % "1.0" extra("e:color" -> color)
dep :: Nil
}).value
organization := "org.example"
name := "use-color"
lazy val root = (project in file("."))
.settings(
organization := "org.example",
name := "use-color",
ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")),
publishMavenStyle := false,
resolvers := baseDirectory( base =>
Resolver.file("test-repo", base / "repo" / "test")(Resolver.defaultIvyPatterns) :: Nil
).value,
libraryDependencies := {
val base = baseDirectory.value
val color = IO.read(base / "color")
val dep = "com.example" %% "define-color" % "1.0" extra("e:color" -> color)
dep :: Nil
}
)

2
sbt/src/sbt-test/dependency-management/gh-1484-npe/build.sbt
View File

@ -1,7 +1,7 @@
lazy val check = taskKey[Unit]("tests update")
def commonSettings: Seq[Def.Setting[_]] = Seq(
resolvers ++= Resolver.typesafeIvyRepo("releases") :: Resolver.typesafeRepo("releases") :: Resolver.sbtPluginRepo("releases") :: Nil,
resolvers ++= Vector(Resolver.typesafeIvyRepo("releases"), Resolver.typesafeRepo("releases"), Resolver.sbtPluginRepo("releases")),
check := {
val ur = update.value
import sbinary._, Operations._, DefaultProtocol._

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

@ -1,6 +1,6 @@
lazy val commonSettings = Seq(
autoScalaLibrary := false,
ivyScala := None,
scalaModuleInfo := None,
unmanagedJars in Compile ++= (scalaInstance map (_.allJars.toSeq)).value,
publishArtifact in packageSrc := false,
publishArtifact in packageDoc := false,

5
sbt/src/sbt-test/dependency-management/make-pom/build.sbt
View File

@ -6,7 +6,10 @@ lazy val root = (project in file(".")) settings (
TaskKey[Unit]("checkExtra") := checkExtra.value,
TaskKey[Unit]("checkVersionPlusMapping") := checkVersionPlusMapping.value,
resolvers += Resolver.sonatypeRepo("snapshots"),
makePomConfiguration ~= { _.copy(extra = <extra-tag/>) },
makePomConfiguration := {
val p = makePomConfiguration.value
p.withExtra(<extra-tag/>)
},
libraryDependencies += "com.google.code.findbugs" % "jsr305" % "1.3.+"
)

4
sbt/src/sbt-test/dependency-management/override/build.sbt
View File

@ -2,12 +2,12 @@ autoScalaLibrary := false
ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache"))
ivyScala := Some(IvyScala(
scalaModuleInfo := Some(sbt.librarymanagement.ScalaModuleInfo(
(scalaVersion in update).value,
(scalaBinaryVersion in update).value,
Vector.empty,
filterImplicit = false,
checkExplicit = false,
filterImplicit = false,
overrideScalaVersion = false
))

8
sbt/src/sbt-test/dependency-management/override/test
View File

@ -1,19 +1,19 @@
> 'set libraryDependencies := Seq("junit" % "junit" % "3.8.1" % "test")'
> check 3.8.1
> 'set dependencyOverrides := Set("junit" % "junit" % "4.5")'
> 'set dependencyOverrides := Vector("junit" % "junit" % "4.5")'
> check 4.5
> 'set libraryDependencies := Seq("junit" % "junit" % "4.5" % "test")'
> check 4.5
> 'set dependencyOverrides := Set("junit" % "junit" % "3.8.1")'
> 'set dependencyOverrides := Vector("junit" % "junit" % "3.8.1")'
> check 3.8.1
> 'set libraryDependencies := Seq("net.databinder" %% "dispatch-http" % "0.8.7")'
> check 0.8.7
> 'set dependencyOverrides := Set("net.databinder" %% "dispatch-http" % "0.8.6")'
> 'set dependencyOverrides := Vector("net.databinder" %% "dispatch-http" % "0.8.6")'
> check 0.8.6
> 'set libraryDependencies := Seq("net.databinder" %% "dispatch-http" % "0.8.6")'
> check 0.8.6
> 'set dependencyOverrides := Set("net.databinder" %% "dispatch-http" % "0.8.7")'
> 'set dependencyOverrides := Vector("net.databinder" %% "dispatch-http" % "0.8.7")'
> check 0.8.7

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

@ -6,6 +6,6 @@ scalaBinaryVersion := "2.9.1"
resolvers += Classpaths.typesafeReleases
dependencyOverrides := Set("com.typesafe.sbtscalariform" % "sbtscalariform" % "0.3.1")
dependencyOverrides := Vector("com.typesafe.sbtscalariform" % "sbtscalariform" % "0.3.1")
autoScalaLibrary := false

3
sbt/src/sbt-test/dependency-management/pom-advanced/build.sbt
View File

@ -9,7 +9,8 @@ lazy val root = (project in file(".")).
},
makePomConfiguration := {
val conf = makePomConfiguration.value
conf.copy(filterRepositories = pomIncludeRepository(baseDirectory.value, conf.filterRepositories))
conf
.withFilterRepositories(pomIncludeRepository(baseDirectory.value, conf.filterRepositories))
},
ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy-home"))).value
)

6
sbt/src/sbt-test/dependency-management/pom-scope/build.sbt
View File

@ -1,7 +1,7 @@
lazy val custom = config("custom")
lazy val Custom = config("custom")
lazy val root = (project in file(".")).
configs(custom).
configs(Custom).
settings(
TaskKey[Unit]("checkPom") := checkPom.value,
libraryDependencies ++= Seq(
@ -9,7 +9,7 @@ lazy val root = (project in file(".")).
"b" % "b" % "1.0" % "runtime,optional",
"c" % "c" % "1.0" % "optional",
"d" % "d" % "1.0" % "test",
"e" % "e" % "1.0" % "custom",
"e" % "e" % "1.0" % Custom,
"f" % "f" % "1.0" % "custom,optional,runtime",
"g" % "g" % "1.0" % "custom,runtime" classifier "foo",
"h" % "h" % "1.0" % "custom,optional,runtime" classifier "foo"

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

@ -1,5 +1,5 @@
def configIvyScala =
ivyScala ~= (_ map (_ withCheckExplicit false))
scalaModuleInfo ~= (_ map (_ withCheckExplicit false))
val declared = SettingKey[Boolean]("declared")
lazy val a = project.

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

@ -1 +1 @@
scalaVersion := "2.9.2"
scalaVersion := "2.11.11"

12
sbt/src/sbt-test/project/auto-plugins/build.sbt
View File

@ -41,8 +41,8 @@ check := {
val rversion = projectID.?.value // Should be None
same(rversion, None, "projectID")
// Ensure with multiple .sbt files that disabling/enabling works across them
val fDel = (del in q in projF).?.value
same(fDel, Some(" Q"), "del in q in projF")
val fDel = (del in Quux in projF).?.value
same(fDel, Some(" Q"), "del in Quux in projF")
//
val adel = (del in projA).?.value // should be None
same(adel, None, "del in projA")
@ -57,10 +57,10 @@ check := {
same(globalValue, "global 1", "demo in Global") // this is temporary, should be 0 until # is fixed
val projValue = (demo in projC).?.value
same(projValue, Some("project projC Q R"), "demo in projC")
val qValue = (del in projC in q).?.value
same(qValue, Some(" Q R"), "del in projC in q")
val optInValue = (del in projE in q).value
same(optInValue, " Q S R", "del in projE in q")
val qValue = (del in projC in Quux).?.value
same(qValue, Some(" Q R"), "del in projC in Quux")
val optInValue = (del in projE in Quux).value
same(optInValue, " Q S R", "del in projE in Quux")
val overrideOrgValue = (organization in projE).value
same(overrideOrgValue, "S", "organization in projE")
// tests for top level plugins

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

@ -9,8 +9,8 @@ package sbttest // you need package http://stackoverflow.com/questions/9822008/
object Imports
{
lazy val q = config("q")
lazy val p = config("p").extend(q)
lazy val Quux = config("q")
lazy val Pippy = config("p").extend(Quux)
lazy val demo = settingKey[String]("A demo setting.")
lazy val del = settingKey[String]("Another demo setting.")
@ -47,13 +47,13 @@ object Q extends AutoPlugin
override def trigger = allRequirements
override def projectConfigurations: Seq[Configuration] =
p ::
q ::
Pippy ::
Quux ::
Nil
override def projectSettings: Seq[Setting[_]] =
(demo := s"project ${name.value}") ::
(del in q := " Q") ::
(del in Quux := " Q") ::
Nil
override def buildSettings: Seq[Setting[_]] =
@ -77,9 +77,9 @@ object R extends AutoPlugin
override def projectSettings = Seq(
// tests proper ordering: R requires Q, so Q settings should come first
del in q += " R",
del in Quux += " R",
// tests that configurations are properly registered, enabling delegation from p to q
demo += (del in p).value
demo += (del in Pippy).value
)
}
@ -91,7 +91,7 @@ object S extends AutoPlugin
override def trigger = noTrigger
override def projectSettings = Seq(
del in q += " S",
del in Quux += " S",
organization := "S"
)
}

3
sbt/src/sbt-test/source-dependencies/trait-member-modified/build.sbt
View File

@ -1,11 +1,10 @@
import sbt.internal.inc.Analysis
import xsbti.Maybe
import xsbti.compile.{PreviousResult, CompileAnalysis, MiniSetup}
previousCompile in Compile := {
val previous = (previousCompile in Compile).value
if (!CompileState.isNew) {
val res = new PreviousResult(none[CompileAnalysis].asJava, none[MiniSetup].asJava)
val res = PreviousResult.of(none[CompileAnalysis].asJava, none[MiniSetup].asJava)
CompileState.isNew = true
res
} else previous

3
sbt/src/sbt-test/source-dependencies/transitive-memberRef/build.sbt
View File

@ -1,5 +1,4 @@
import sbt.internal.inc.Analysis
import xsbti.Maybe
import xsbti.compile.{PreviousResult, CompileAnalysis, MiniSetup}
logLevel := Level.Debug
@ -8,7 +7,7 @@ logLevel := Level.Debug
previousCompile in Compile := {
val previous = (previousCompile in Compile).value
if (!CompileState.isNew) {
val res = new PreviousResult(none[CompileAnalysis].asJava, none[MiniSetup].asJava)
val res = PreviousResult.of(none[CompileAnalysis].asJava, none[MiniSetup].asJava)
CompileState.isNew = true
res
} else previous

51
sbt/src/sbt-test/tests/scala-instance-classloader/build.sbt
View File

@ -2,31 +2,32 @@ import sbt.internal.inc.ScalaInstance
lazy val OtherScala = config("other-scala").hide
configs(OtherScala)
lazy val root = (project in file("."))
.configs(OtherScala)
.settings(
scalaVersion := "2.11.11",
libraryDependencies += "org.scala-lang" % "scala-compiler" % "2.11.11" % OtherScala.name,
managedClasspath in OtherScala := Classpaths.managedJars(OtherScala, classpathTypes.value, update.value),
libraryDependencies += "org.scala-lang" % "scala-compiler" % "2.11.8" % OtherScala.name
// Hack in the scala instance
scalaInstance := {
val rawJars = (managedClasspath in OtherScala).value.map(_.data)
val scalaHome = (target.value / "scala-home")
def removeVersion(name: String): String =
name.replaceAll("\\-2.11.11", "")
for(jar <- rawJars) {
val tjar = scalaHome / s"lib/${removeVersion(jar.getName)}"
IO.copyFile(jar, tjar)
}
IO.listFiles(scalaHome).foreach(f => System.err.println(s" * $f}"))
ScalaInstance(scalaHome, appConfiguration.value.provider.scalaProvider.launcher)
},
managedClasspath in OtherScala := Classpaths.managedJars(OtherScala, classpathTypes.value, update.value)
libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % Test,
libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.3.3" % Test,
// Hack in the scala instance
scalaInstance := {
val rawJars = (managedClasspath in OtherScala).value.map(_.data)
val scalaHome = (target.value / "scala-home")
def removeVersion(name: String): String =
name.replaceAll("\\-2.11.8", "")
for(jar <- rawJars) {
val tjar = scalaHome / s"lib/${removeVersion(jar.getName)}"
IO.copyFile(jar, tjar)
}
IO.listFiles(scalaHome).foreach(f => System.err.println(s" * $f}"))
ScalaInstance(scalaHome, appConfiguration.value.provider.scalaProvider.launcher)
}
libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % "test"
libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.3.3" % "test"
scalaVersion := "2.11.8"
ivyScala := ivyScala.value map (_.withOverrideScalaVersion(sbtPlugin.value))
scalaModuleInfo := {
val old = scalaModuleInfo.value
old map { _.withOverrideScalaVersion(sbtPlugin.value) }
}
)

4
sbt/src/sbt-test/tests/serial/build.sbt
View File

@ -1,11 +1,11 @@
val commonSettings = Seq(
libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1" % "test"
libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1" % Test
)
lazy val root = (project in file(".")).
aggregate(sub1, sub2).
settings(inThisBuild(List(
organization := "com.softwaremill",
organization := "com.example",
version := "0.0.1-SNAPSHOT",
scalaVersion := "2.10.6"
)),

18
scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala
View File

@ -15,8 +15,8 @@ object ScriptedPlugin extends AutoPlugin {
override def requires = plugins.JvmPlugin
override def trigger = allRequirements
object autoImport {
def scriptedConf = config("scripted-sbt") hide
def scriptedLaunchConf = config("scripted-sbt-launch") hide
val ScriptedConf = Configurations.config("scripted-sbt") hide
val ScriptedLaunchConf = Configurations.config("scripted-sbt-launch") hide
val scriptedSbt = SettingKey[String]("scripted-sbt")
val sbtLauncher = TaskKey[File]("sbt-launcher")
val sbtTestDirectory = SettingKey[File]("sbt-test-directory")
@ -32,26 +32,26 @@ object ScriptedPlugin extends AutoPlugin {
}
import autoImport._
override lazy val projectSettings = Seq(
ivyConfigurations ++= Seq(scriptedConf, scriptedLaunchConf),
ivyConfigurations ++= Seq(ScriptedConf, ScriptedLaunchConf),
scriptedSbt := (sbtVersion in pluginCrossBuild).value,
sbtLauncher := getJars(scriptedLaunchConf).map(_.get.head).value,
sbtLauncher := getJars(ScriptedLaunchConf).map(_.get.head).value,
sbtTestDirectory := sourceDirectory.value / "sbt-test",
libraryDependencies ++= {
binarySbtVersion(scriptedSbt.value) match {
case "0.13" =>
Seq(
"org.scala-sbt" % "scripted-sbt" % scriptedSbt.value % scriptedConf.toString,
"org.scala-sbt" % "sbt-launch" % scriptedSbt.value % scriptedLaunchConf.toString
"org.scala-sbt" % "scripted-sbt" % scriptedSbt.value % ScriptedConf.toString,
"org.scala-sbt" % "sbt-launch" % scriptedSbt.value % ScriptedLaunchConf.toString
)
case sv if sv startsWith "1.0." =>
Seq(
"org.scala-sbt" %% "scripted-sbt" % scriptedSbt.value % scriptedConf.toString,
"org.scala-sbt" % "sbt-launch" % scriptedSbt.value % scriptedLaunchConf.toString
"org.scala-sbt" %% "scripted-sbt" % scriptedSbt.value % ScriptedConf.toString,
"org.scala-sbt" % "sbt-launch" % scriptedSbt.value % ScriptedLaunchConf.toString
)
}
},
scriptedBufferLog := true,
scriptedClasspath := getJars(scriptedConf).value,
scriptedClasspath := getJars(ScriptedConf).value,
scriptedTests := scriptedTestsTask.value,
scriptedRun := scriptedRunTask.value,
scriptedDependencies := {