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

Merge pull request #4106 from dwijnand/overload-varargs-sorta 

Switch inThisBuild (+friends) to use varargs SettingsDefinition
This commit is contained in:
Dale Wijnand 2018-04-20 16:11:29 +01:00 committed by GitHub
parent 54a6262f7f ccf938c786
commit 187c50c78d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 210 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -134,9 +134,8 @@ object Defaults extends BuildCommon {
def buildCore: Seq[Setting[_]] = thisBuildCore ++ globalCore
def thisBuildCore: Seq[Setting[_]] =
inScope(GlobalScope.copy(project = Select(ThisBuild)))(
Seq(
managedDirectory := baseDirectory.value / "lib_managed"
))
managedDirectory := baseDirectory.value / "lib_managed"
)
private[sbt] lazy val globalCore: Seq[Setting[_]] = globalDefaults(
defaultTestTasks(test) ++ defaultTestTasks(testOnly) ++ defaultTestTasks(testQuick) ++ Seq(
excludeFilter :== HiddenFileFilter
@ -294,10 +293,9 @@ object Defaults extends BuildCommon {
def defaultTestTasks(key: Scoped): Seq[Setting[_]] =
inTask(key)(
Seq(
tags := Seq(Tags.Test -> 1),
logBuffered := true
))
tags := Seq(Tags.Test -> 1),
logBuffered := true
)
// TODO: This should be on the new default settings for a project.
def projectCore: Seq[Setting[_]] = Seq(
@ -715,21 +713,19 @@ object Defaults extends BuildCommon {
lazy val ConfigGlobal: Scope = ConfigZero
def testTaskOptions(key: Scoped): Seq[Setting[_]] =
inTask(key)(
Seq(
testListeners := {
TestLogger.make(streams.value.log,
closeableTestLogger(streamsManager.value,
test in resolvedScoped.value.scope,
logBuffered.value)) +:
new TestStatusReporter(succeededFile(streams.in(test).value.cacheDirectory)) +:
testListeners.in(TaskZero).value
},
testOptions := Tests.Listeners(testListeners.value) +: (testOptions in TaskZero).value,
testExecution := testExecutionTask(key).value
)) ++ inScope(GlobalScope)(
Seq(
derive(testGrouping := singleTestGroupDefault.value)
))
testListeners := {
TestLogger.make(streams.value.log,
closeableTestLogger(streamsManager.value,
test in resolvedScoped.value.scope,
logBuffered.value)) +:
new TestStatusReporter(succeededFile(streams.in(test).value.cacheDirectory)) +:
testListeners.in(TaskZero).value
},
testOptions := Tests.Listeners(testListeners.value) +: (testOptions in TaskZero).value,
testExecution := testExecutionTask(key).value
) ++ inScope(GlobalScope)(
derive(testGrouping := singleTestGroupDefault.value)
)
private[this] def closeableTestLogger(manager: Streams, baseKey: Scoped, buffered: Boolean)(
tdef: TestDefinition): TestLogger.PerTest = {
@ -985,7 +981,7 @@ object Defaults extends BuildCommon {
))
lazy val packageConfig: Seq[Setting[_]] =
inTask(packageBin)(Seq(
inTask(packageBin)(
packageOptions := {
val n = name.value
val ver = version.value
@ -997,14 +993,13 @@ object Defaults extends BuildCommon {
Package.addImplManifestAttributes(n, ver, homepage.value, org, orgName) +:
main.map(Package.MainClass.apply) ++: old
}
)) ++
) ++
inTask(packageSrc)(
Seq(
packageOptions := Package.addSpecManifestAttributes(
name.value,
version.value,
organizationName.value) +: packageOptions.value
)) ++
packageOptions := Package.addSpecManifestAttributes(
name.value,
version.value,
organizationName.value) +: packageOptions.value
) ++
packageTaskSettings(packageBin, packageBinMappings) ++
packageTaskSettings(packageSrc, packageSrcMappings) ++
packageTaskSettings(packageDoc, packageDocMappings) ++
@ -1081,14 +1076,13 @@ object Defaults extends BuildCommon {
def packageTaskSettings(key: TaskKey[File], mappingsTask: Initialize[Task[Seq[(File, String)]]]) =
inTask(key)(
Seq(
key in TaskZero := packageTask.value,
packageConfiguration := packageConfigurationTask.value,
mappings := mappingsTask.value,
packagedArtifact := (artifact.value -> key.value),
artifact := artifactSetting.value,
artifactPath := artifactPathSetting(artifact).value
))
key in TaskZero := packageTask.value,
packageConfiguration := packageConfigurationTask.value,
mappings := mappingsTask.value,
packagedArtifact := (artifact.value -> key.value),
artifact := artifactSetting.value,
artifactPath := artifactPathSetting(artifact).value
)
def packageTask: Initialize[Task[File]] =
Def.task {
@ -1288,49 +1282,48 @@ object Defaults extends BuildCommon {
def docTaskSettings(key: TaskKey[File] = doc): Seq[Setting[_]] =
inTask(key)(
Seq(
apiMappings ++= {
val dependencyCp = dependencyClasspath.value
val log = streams.value.log
if (autoAPIMappings.value) APIMappings.extract(dependencyCp, log).toMap
else Map.empty[File, URL]
},
fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"),
key in TaskZero := {
val s = streams.value
val cs: Compilers = compilers.value
val srcs = sources.value
val out = target.value
val sOpts = scalacOptions.value
val xapis = apiMappings.value
val hasScala = srcs.exists(_.name.endsWith(".scala"))
val hasJava = srcs.exists(_.name.endsWith(".java"))
val cp = data(dependencyClasspath.value).toList
val label = nameForSrc(configuration.value.name)
val fiOpts = fileInputOptions.value
val reporter = (compilerReporter in compile).value
(hasScala, hasJava) match {
case (true, _) =>
val options = sOpts ++ Opts.doc.externalAPI(xapis)
val runDoc = Doc.scaladoc(label, s.cacheStoreFactory sub "scala", cs.scalac match {
case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scaladoc"))
}, fiOpts)
runDoc(srcs, cp, out, options, maxErrors.value, s.log)
case (_, true) =>
val javadoc =
sbt.inc.Doc.cachedJavadoc(label, s.cacheStoreFactory sub "java", cs.javaTools)
javadoc.run(srcs.toList,
cp,
out,
javacOptions.value.toList,
IncToolOptionsUtil.defaultIncToolOptions(),
s.log,
reporter)
case _ => () // do nothing
}
out
apiMappings ++= {
val dependencyCp = dependencyClasspath.value
val log = streams.value.log
if (autoAPIMappings.value) APIMappings.extract(dependencyCp, log).toMap
else Map.empty[File, URL]
},
fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"),
key in TaskZero := {
val s = streams.value
val cs: Compilers = compilers.value
val srcs = sources.value
val out = target.value
val sOpts = scalacOptions.value
val xapis = apiMappings.value
val hasScala = srcs.exists(_.name.endsWith(".scala"))
val hasJava = srcs.exists(_.name.endsWith(".java"))
val cp = data(dependencyClasspath.value).toList
val label = nameForSrc(configuration.value.name)
val fiOpts = fileInputOptions.value
val reporter = (compilerReporter in compile).value
(hasScala, hasJava) match {
case (true, _) =>
val options = sOpts ++ Opts.doc.externalAPI(xapis)
val runDoc = Doc.scaladoc(label, s.cacheStoreFactory sub "scala", cs.scalac match {
case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scaladoc"))
}, fiOpts)
runDoc(srcs, cp, out, options, maxErrors.value, s.log)
case (_, true) =>
val javadoc =
sbt.inc.Doc.cachedJavadoc(label, s.cacheStoreFactory sub "java", cs.javaTools)
javadoc.run(srcs.toList,
cp,
out,
javacOptions.value.toList,
IncToolOptionsUtil.defaultIncToolOptions(),
s.log,
reporter)
case _ => () // do nothing
}
))
out
}
)
def mainBgRunTask = mainBgRunTaskForConfig(Select(Runtime))
def mainBgRunMainTask = mainBgRunMainTaskForConfig(Select(Runtime))
@ -1630,15 +1623,14 @@ object Defaults extends BuildCommon {
// build.sbt is treated a Scala source of metabuild, so to enable deprecation flag on build.sbt we set the option here.
lazy val deprecationSettings: Seq[Setting[_]] =
inConfig(Compile)(
Seq(
scalacOptions := {
val old = scalacOptions.value
val existing = old.toSet
val d = "-deprecation"
if (sbtPlugin.value && !existing(d)) d :: old.toList
else old
}
))
scalacOptions := {
val old = scalacOptions.value
val existing = old.toSet
val d = "-deprecation"
if (sbtPlugin.value && !existing(d)) d :: old.toList
else old
}
)
}
object Classpaths {
import Keys._
@ -2146,78 +2138,77 @@ object Classpaths {
def sbtClassifiersTasks =
sbtClassifiersGlobalDefaults ++
inTask(updateSbtClassifiers)(
Seq(
externalResolvers := {
val explicit = buildStructure.value
.units(thisProjectRef.value.build)
.unit
.plugins
.pluginData
.resolvers
explicit orElse bootRepositories(appConfiguration.value) getOrElse externalResolvers.value
},
ivyConfiguration := InlineIvyConfiguration(
paths = ivyPaths.value,
resolvers = externalResolvers.value.toVector,
otherResolvers = Vector.empty,
moduleConfigurations = Vector.empty,
lock = Option(lock(appConfiguration.value)),
checksums = checksums.value.toVector,
managedChecksums = false,
resolutionCacheDir = Some(crossTarget.value / "resolution-cache"),
updateOptions = UpdateOptions(),
log = streams.value.log
),
ivySbt := ivySbt0.value,
classifiersModule := classifiersModuleTask.value,
// Redefine scalaVersion and scalaBinaryVersion specifically for the dependency graph used for updateSbtClassifiers task.
// to fix https://github.com/sbt/sbt/issues/2686
scalaVersion := appConfiguration.value.provider.scalaProvider.version,
scalaBinaryVersion := binaryScalaVersion(scalaVersion.value),
scalaModuleInfo := {
Some(
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
val c = updateConfiguration.value
val app = appConfiguration.value
val srcTypes = sourceArtifactTypes.value
val docTypes = docArtifactTypes.value
val log = s.log
val out = is.withIvy(log)(_.getSettings.getDefaultIvyUserDir)
val uwConfig = (unresolvedWarningConfiguration in update).value
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(_) => ???
case Right(ur) => ur
}
}
} tag (Tags.Update, Tags.Network)).value
)) ++ Seq(bootIvyConfiguration := (ivyConfiguration in updateSbtClassifiers).value)
externalResolvers := {
val explicit = buildStructure.value
.units(thisProjectRef.value.build)
.unit
.plugins
.pluginData
.resolvers
explicit orElse bootRepositories(appConfiguration.value) getOrElse externalResolvers.value
},
ivyConfiguration := InlineIvyConfiguration(
paths = ivyPaths.value,
resolvers = externalResolvers.value.toVector,
otherResolvers = Vector.empty,
moduleConfigurations = Vector.empty,
lock = Option(lock(appConfiguration.value)),
checksums = checksums.value.toVector,
managedChecksums = false,
resolutionCacheDir = Some(crossTarget.value / "resolution-cache"),
updateOptions = UpdateOptions(),
log = streams.value.log
),
ivySbt := ivySbt0.value,
classifiersModule := classifiersModuleTask.value,
// Redefine scalaVersion and scalaBinaryVersion specifically for the dependency graph used for updateSbtClassifiers task.
// to fix https://github.com/sbt/sbt/issues/2686
scalaVersion := appConfiguration.value.provider.scalaProvider.version,
scalaBinaryVersion := binaryScalaVersion(scalaVersion.value),
scalaModuleInfo := {
Some(
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
val c = updateConfiguration.value
val app = appConfiguration.value
val srcTypes = sourceArtifactTypes.value
val docTypes = docArtifactTypes.value
val log = s.log
val out = is.withIvy(log)(_.getSettings.getDefaultIvyUserDir)
val uwConfig = (unresolvedWarningConfiguration in update).value
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(_) => ???
case Right(ur) => ur
}
}
} tag (Tags.Update, Tags.Network)).value
) ++ Seq(bootIvyConfiguration := (ivyConfiguration in updateSbtClassifiers).value)
def classifiersModuleTask: Initialize[Task[GetClassifiersModule]] =
Def.task {
@ -3245,7 +3236,7 @@ trait BuildExtra extends BuildCommon with DefExtra {
* This is useful for reducing test:compile time when not running test.
*/
def noTestCompletion(config: Configuration = Test): Setting[_] =
inConfig(config)(Seq(definedTests := detectTests.value)).head
inConfig(config)(definedTests := detectTests.value).head
def filterKeys(ss: Seq[Setting[_]], transitive: Boolean = false)(
f: ScopedKey[_] => Boolean): Seq[Setting[_]] =

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

@ -46,7 +46,7 @@ private[sbt] object PluginCross {
val add = List(sbtVersion in GlobalScope in pluginCrossBuild :== version) ++
List(scalaVersion := scalaVersionSetting.value) ++
inScope(GlobalScope.copy(project = Select(currentRef)))(
Seq(scalaVersion := scalaVersionSetting.value)
scalaVersion := scalaVersionSetting.value
)
val cleared = session.mergeSettings.filterNot(crossExclude)
val newStructure = Load.reapply(cleared ++ add, structure)

20
main/src/main/scala/sbt/Project.scala
View File

@ -32,7 +32,7 @@ import Keys.{
watch
}
import Scope.{ Global, ThisScope }
import Def.{ Flattened, Initialize, ScopedKey, Setting }
import Def.{ Flattened, Initialize, ScopedKey, Setting, SettingsDefinition }
import sbt.internal.{
Load,
BuildStructure,
@ -863,17 +863,19 @@ trait ProjectExtra {
implicit def richTaskSessionVar[T](init: Initialize[Task[T]]): Project.RichTaskSessionVar[T] =
new Project.RichTaskSessionVar(init)
def inThisBuild(ss: Seq[Setting[_]]): Seq[Setting[_]] =
inScope(ThisScope.copy(project = Select(ThisBuild)))(ss)
def inThisBuild(ss: SettingsDefinition*): Seq[Setting[_]] =
inScope(ThisScope.copy(project = Select(ThisBuild)))(ss flatMap (_.settings))
def inConfig(conf: Configuration)(ss: Seq[Setting[_]]): Seq[Setting[_]] =
inScope(ThisScope.copy(config = Select(conf)))((configuration :== conf) +: ss)
def inConfig(conf: Configuration)(ss: SettingsDefinition*): Seq[Setting[_]] =
inScope(ThisScope.copy(config = Select(conf)))(
(configuration :== conf) +: (ss flatMap (_.settings))
)
def inTask(t: Scoped)(ss: Seq[Setting[_]]): Seq[Setting[_]] =
inScope(ThisScope.copy(task = Select(t.key)))(ss)
def inTask(t: Scoped)(ss: SettingsDefinition*): Seq[Setting[_]] =
inScope(ThisScope.copy(task = Select(t.key)))(ss flatMap (_.settings))
def inScope(scope: Scope)(ss: Seq[Setting[_]]): Seq[Setting[_]] =
Project.transform(Scope.replaceThis(scope), ss)
def inScope(scope: Scope)(ss: SettingsDefinition*): Seq[Setting[_]] =
Project.transform(Scope.replaceThis(scope), ss flatMap (_.settings))
private[sbt] def inThisBuild[T](i: Initialize[T]): Initialize[T] =
inScope(ThisScope.copy(project = Select(ThisBuild)), i)

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

@ -98,13 +98,12 @@ object GlobalPlugin {
}
}
val globalPluginSettings = Project.inScope(Scope.GlobalScope in LocalRootProject)(
Seq(
organization := SbtArtifacts.Organization,
onLoadMessage := Keys.baseDirectory("Loading global plugins from " + _).value,
name := "global-plugin",
sbtPlugin := true,
version := "0.0"
))
organization := SbtArtifacts.Organization,
onLoadMessage := Keys.baseDirectory("Loading global plugins from " + _).value,
name := "global-plugin",
sbtPlugin := true,
version := "0.0"
)
}
final case class GlobalPluginData(projectID: ModuleID,
dependencies: Seq[ModuleID],

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

@ -1126,22 +1126,21 @@ private[sbt] object Load {
/** These are the settings defined when loading a project "meta" build. */
val autoPluginSettings: Seq[Setting[_]] = inScope(GlobalScope in LocalRootProject)(
Seq(
sbtPlugin :== true,
pluginData := {
val prod = (exportedProducts in Configurations.Runtime).value
val cp = (fullClasspath in Configurations.Runtime).value
val opts = (scalacOptions in Configurations.Compile).value
PluginData(
removeEntries(cp, prod),
prod,
Some(fullResolvers.value.toVector),
Some(update.value),
opts
)
},
onLoadMessage := ("Loading project definition from " + baseDirectory.value)
))
sbtPlugin :== true,
pluginData := {
val prod = (exportedProducts in Configurations.Runtime).value
val cp = (fullClasspath in Configurations.Runtime).value
val opts = (scalacOptions in Configurations.Compile).value
PluginData(
removeEntries(cp, prod),
prod,
Some(fullResolvers.value.toVector),
Some(update.value),
opts
)
},
onLoadMessage := ("Loading project definition from " + baseDirectory.value)
)
private[this] def removeEntries(
cp: Seq[Attributed[File]],

4
sbt/src/sbt-test/actions/cross-multiproject/build.sbt
View File

@ -1,6 +1,6 @@
inThisBuild(List(
inThisBuild(
crossScalaVersions := Seq("2.12.1", "2.11.8")
))
)
lazy val rootProj = (project in file("."))
.aggregate(libProj, fooPlugin)

4
sbt/src/sbt-test/actions/previous/scopes.sbt
View File

@ -22,7 +22,7 @@ x in subA in Compile := {
}
inConfig(Compile)(Seq(
inConfig(Compile)(
y in subB := {
// verify that the referenced key gets delegated
val xty = (x in Test in y).previous getOrElse 0 // 13
@ -31,7 +31,7 @@ inConfig(Compile)(Seq(
println(s"xcy=$xcy, xty=$xty")
xty * xcy
}
))
)
def parser = {
import complete.DefaultParsers._

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

@ -4,7 +4,7 @@ dependencyOverrides in ThisBuild += "com.github.nscala-time" %% "nscala-time" %
lazy val root = (project in file("."))
.dependsOn(p1 % Compile)
.settings(
inThisBuild(List(
inThisBuild(
organizationName := "eed3si9n",
organizationHomepage := Some(url("http://example.com/")),
homepage := Some(url("https://github.com/example/example")),
@ -20,7 +20,7 @@ lazy val root = (project in file("."))
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")

4
sbt/src/sbt-test/dependency-management/cached-resolution-circular/multi.sbt
View File

@ -41,8 +41,8 @@ lazy val c = project.
lazy val root = (project in file(".")).
settings(commonSettings).
settings(inThisBuild(Seq(
settings(inThisBuild(
organization := "org.example",
version := "1.0-SNAPSHOT",
updateOptions := updateOptions.value.withCachedResolution(true)
)))
))

4
sbt/src/sbt-test/dependency-management/cached-resolution-conflicts/multi.sbt
View File

@ -1,12 +1,12 @@
// https://github.com/sbt/sbt/issues/1710
// https://github.com/sbt/sbt/issues/1760
inThisBuild(Seq(
inThisBuild(
organization := "com.example",
version := "0.1.0",
scalaVersion := "2.10.4",
updateOptions := updateOptions.value.withCachedResolution(true)
))
)
def commonSettings: Seq[Def.Setting[_]] = Seq(
ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")),

4
sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt
View File

@ -27,7 +27,7 @@ lazy val b = project.
lazy val root = (project in file(".")).
aggregate(a, b).
settings(inThisBuild(Seq(
settings(inThisBuild(
organization := "org.example",
version := "1.0",
updateOptions := updateOptions.value.withCachedResolution(true),
@ -45,4 +45,4 @@ lazy val root = (project in file(".")).
sys.error("commons-io NOT found when it should NOT be excluded")
}
}
)))
))

4
sbt/src/sbt-test/dependency-management/cached-resolution-interproj/multi.sbt
View File

@ -27,7 +27,7 @@ lazy val a = project.
lazy val root = (project in file(".")).
aggregate(a).
settings(inThisBuild(Seq(
settings(inThisBuild(
organization := "org.example",
version := "1.0",
updateOptions := updateOptions.value.withCachedResolution(true),
@ -49,4 +49,4 @@ lazy val root = (project in file(".")).
sys.error("junit NOT found when it should be included: " + atestcp.toString)
}
}
)))
))

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

@ -2,12 +2,12 @@ lazy val p1 = (project in file("p1")).
settings(
checkTask(expectedMongo),
libraryDependencies += "org.mongodb" %% "casbah" % "2.4.1" pomOnly(),
inThisBuild(List(
inThisBuild(
organization := "org.example",
version := "1.0",
scalaVersion := "2.9.2",
autoScalaLibrary := false
))
)
)
lazy val p2 = (project in file("p2")).

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

@ -1,12 +1,12 @@
lazy val root = (project in file(".")).
dependsOn(sub).
aggregate(sub).
settings(inThisBuild(List(
settings(inThisBuild(
organization := "A",
version := "1.0",
ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy" / "cache")) ).value,
externalResolvers := (baseDirectory map { base => Resolver.file("local", base / "ivy" / "local" asFile)(Resolver.ivyStylePatterns) :: Nil }).value
)),
),
mavenStyle,
interProject,
name := "Publish Test"

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

@ -1,10 +1,10 @@
lazy val root = (project in file(".")).
settings(inThisBuild(List(
settings(inThisBuild(
organization := "A",
version := "1.0",
ivyPaths := baseDirectory( dir => IvyPaths(dir, Some(dir / "ivy" / "cache")) ).value,
externalResolvers := (baseDirectory map { base => Resolver.file("local", base / "ivy" / "local" asFile)(Resolver.ivyStylePatterns) :: Nil }).value
)),
),
mavenStyle,
name := "Retrieve Test",
libraryDependencies := (publishMavenStyle { style => if(style) mavenStyleDependencies else ivyStyleDependencies }).value

4
sbt/src/sbt-test/project/derived/build.sbt
View File

@ -23,7 +23,7 @@ globalDepE in Global := "globalE"
// ---------------- Derived settings
// verify that deriving is transitive
inScope(GlobalScope)(Seq(
inScope(GlobalScope)(
Def.derive(customA := customB.value + "-a"),
Def.derive(customB := thisProject.value.id + "-b"),
// verify that a setting with multiple triggers still only gets added once
@ -36,7 +36,7 @@ inScope(GlobalScope)(Seq(
// if customE were added in Global because of name, there would be an error
// because description wouldn't be found
Def.derive(customE := globalDepE.value + "-" + projectDepE.value)
))
)
// ---------------- Projects

4
sbt/src/sbt-test/tests/fork-test-group-parallel/build.sbt
View File

@ -1,7 +1,7 @@
scalaVersion in ThisBuild := "2.11.8"
concurrentRestrictions in Global := Seq(Tags.limitAll(4))
libraryDependencies += "org.specs2" %% "specs2-core" % "3.8.4" % Test
inConfig(Test)(Seq(
inConfig(Test)(
testGrouping := {
val home = javaHome.value
val strategy = outputStrategy.value
@ -22,4 +22,4 @@ inConfig(Test)(Seq(
))}
},
TaskKey[Unit]("test-failure") := test.failure.value
))
)