From 6c7faf2b8611f122a37b824c6e08e950855d939f Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Thu, 4 Apr 2019 16:58:49 -0400 Subject: [PATCH 01/24] trim update and add updateFull Fixes #4438 This slims down update's UpdateReport by removing evicted modules caller information. The larger the graph, the effect would be more pronounced. For example, I saw a graph reduce from 5.9MB to 1.1MB in JSON file. --- main/src/main/scala/sbt/Defaults.scala | 25 +++++++++++--- main/src/main/scala/sbt/Keys.scala | 1 + .../sbt/internal/LibraryManagement.scala | 34 ++++++++++++++++--- .../cache-update/build.sbt | 4 ++- 4 files changed, 54 insertions(+), 10 deletions(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 3ce80bf67..00d53e26e 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -2278,7 +2278,8 @@ object Classpaths { unresolvedWarningConfiguration in update := UnresolvedWarningConfiguration( dependencyPositions.value ), - update := (updateTask tag (Tags.Update, Tags.Network)).value, + updateFull := (updateTask tag (Tags.Update, Tags.Network)).value, + update := (updateWithoutDetails("update") tag (Tags.Update, Tags.Network)).value, update := { val report = update.value val log = streams.value.log @@ -2656,9 +2657,23 @@ object Classpaths { } } - def updateTask: Initialize[Task[UpdateReport]] = Def.task { + def updateTask: Initialize[Task[UpdateReport]] = updateTask0("updateFull", true, true) + def updateWithoutDetails(label: String): Initialize[Task[UpdateReport]] = + updateTask0(label, false, false) + + /** + * cacheLabel - label to identify an update cache + * includeCallers - include the caller information + * includeDetails - include module reports for the evicted modules + */ + private def updateTask0( + cacheLabel: String, + includeCallers: Boolean, + includeDetails: Boolean + ): Initialize[Task[UpdateReport]] = Def.task { val s = streams.value - val cacheDirectory = streams.value.cacheDirectory + val cacheDirectory = crossTarget.value / cacheLabel / updateCacheName.value + val cacheStoreFactory: CacheStoreFactory = CacheStoreFactory.directory(cacheDirectory) val isRoot = executionRoots.value contains resolvedScoped.value val shouldForce = isRoot || { @@ -2721,7 +2736,7 @@ object Classpaths { lm = dependencyResolution.value, // Ivy-free ModuleDescriptor module = ivyModule.value, - s.cacheStoreFactory.sub(updateCacheName.value), + cacheStoreFactory = cacheStoreFactory, label = label, updateConf, substituteScalaFiles(scalaOrganization.value, _)(providedScalaJars), @@ -2732,6 +2747,8 @@ object Classpaths { ewo = evictionOptions, mavenStyle = publishMavenStyle.value, compatWarning = compatibilityWarningOptions.value, + includeCallers = includeCallers, + includeDetails = includeDetails, log = s.log ) } diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index 0f5894bbf..ac2711453 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -370,6 +370,7 @@ object Keys { val ivyModule = taskKey[IvySbt#Module]("Provides the sbt interface to a configured Ivy module.").withRank(CTask) val updateCacheName = taskKey[String]("Defines the directory name used to store the update cache files (inside the streams cacheDirectory).").withRank(DTask) val update = taskKey[UpdateReport]("Resolves and optionally retrieves dependencies, producing a report.").withRank(ATask) + val updateFull = taskKey[UpdateReport]("Resolves and optionally retrieves dependencies, producing a full report with callers.").withRank(CTask) val evicted = taskKey[EvictionWarning]("Display detailed eviction warnings.").withRank(CTask) val evictionWarningOptions = settingKey[EvictionWarningOptions]("Options on eviction warnings after resolving managed dependencies.").withRank(DSetting) val transitiveUpdate = taskKey[Seq[UpdateReport]]("UpdateReports for the internal dependencies of this project.").withRank(DTask) diff --git a/main/src/main/scala/sbt/internal/LibraryManagement.scala b/main/src/main/scala/sbt/internal/LibraryManagement.scala index fc45b83c0..e6366446d 100644 --- a/main/src/main/scala/sbt/internal/LibraryManagement.scala +++ b/main/src/main/scala/sbt/internal/LibraryManagement.scala @@ -33,6 +33,8 @@ private[sbt] object LibraryManagement { ewo: EvictionWarningOptions, mavenStyle: Boolean, compatWarning: CompatibilityWarningOptions, + includeCallers: Boolean, + includeDetails: Boolean, log: Logger ): UpdateReport = { @@ -50,15 +52,15 @@ private[sbt] object LibraryManagement { throw unresolvedWarning.resolveException } log.debug(s"Done updating $label") - val finalReport = transform(report) + val report1 = transform(report) // Warn of any eviction and compatibility warnings - val ew = EvictionWarning(module, ewo, finalReport) + val ew = EvictionWarning(module, ewo, report1) ew.lines.foreach(log.warn(_)) ew.infoAllTheThings.foreach(log.info(_)) CompatibilityWarning.run(compatWarning, module, mavenStyle, log) - - finalReport + val report2 = transformDetails(report1, includeCallers, includeDetails) + report2 } /* Check if a update report is still up to date or we must resolve again. */ @@ -90,7 +92,9 @@ private[sbt] object LibraryManagement { import sbt.librarymanagement.LibraryManagementCodec._ val cachedResolve = Tracked.lastOutput[UpdateInputs, UpdateReport](cache) { case (_, Some(out)) if upToDate(inChanged, out) => markAsCached(out) - case _ => resolve + case pair => + log.debug(s""""not up to date. inChanged = $inChanged, force = $force""") + resolve } import scala.util.control.Exception.catching catching(classOf[NullPointerException], classOf[OutOfMemoryError]) @@ -150,4 +154,24 @@ private[sbt] object LibraryManagement { .withExtraAttributes(m.extraAttributes) .withConfigurations(if (confs) m.configurations else None) .branch(m.branchName) + + private[this] def transformDetails( + ur: UpdateReport, + includeCallers: Boolean, + includeDetails: Boolean + ): UpdateReport = { + val crs0 = ur.configurations + val crs1 = + if (includeDetails) crs0 + else crs0 map { _.withDetails(Vector()) } + val crs2 = + if (includeCallers) crs1 + else + crs1 map { cr => + val mrs0 = cr.modules + val mrs1 = mrs0 map { _.withCallers(Vector()) } + cr.withModules(mrs1) + } + ur.withConfigurations(crs2) + } } diff --git a/sbt/src/sbt-test/dependency-management/cache-update/build.sbt b/sbt/src/sbt-test/dependency-management/cache-update/build.sbt index db7eead25..b12fb7e29 100644 --- a/sbt/src/sbt-test/dependency-management/cache-update/build.sbt +++ b/sbt/src/sbt-test/dependency-management/cache-update/build.sbt @@ -31,7 +31,9 @@ lazy val root = (project in file(".")) // sbt resolves dependencies every compile when using %% with dependencyOverrides TaskKey[Unit]("check") := { val s = (streams in update).value - val cacheStoreFactory = s.cacheStoreFactory sub updateCacheName.value + + val cacheDirectory = crossTarget.value / "update" / updateCacheName.value + val cacheStoreFactory = sbt.util.CacheStoreFactory.directory(cacheDirectory) val module = ivyModule.value val updateConfig = updateConfiguration.value val extraInputHash0 = module.extraInputHash From 81ce14d58cfa8326f5e319fe7430ef4a3fe8dbd5 Mon Sep 17 00:00:00 2001 From: Ethan Atkins Date: Thu, 25 Apr 2019 15:56:08 -0700 Subject: [PATCH 02/24] Allow calling TaskKey.previous in input tasks I discovered that it wasn't possible to call .previous in an input task. While I understand why you can't call .previous on an InputKey, I think it makes sense to allow calling .previous on a TaskKey within an input task. --- main-settings/src/main/scala/sbt/std/TaskMacro.scala | 1 + .../sbt-test/actions/previous-in-input-task/build.sbt | 10 ++++++++++ sbt/src/sbt-test/actions/previous-in-input-task/test | 5 +++++ 3 files changed, 16 insertions(+) create mode 100644 sbt/src/sbt-test/actions/previous-in-input-task/build.sbt create mode 100644 sbt/src/sbt-test/actions/previous-in-input-task/test diff --git a/main-settings/src/main/scala/sbt/std/TaskMacro.scala b/main-settings/src/main/scala/sbt/std/TaskMacro.scala index 650914c7a..198b4adb1 100644 --- a/main-settings/src/main/scala/sbt/std/TaskMacro.scala +++ b/main-settings/src/main/scala/sbt/std/TaskMacro.scala @@ -450,6 +450,7 @@ object TaskMacro { def expand(nme: String, tpe: Type, tree: Tree): Converted[c.type] = nme match { case WrapInitTaskName => Converted.Success(wrapInitTask(tree)(c.WeakTypeTag(tpe))) + case WrapPreviousName => Converted.Success(wrapInitTask(tree)(c.WeakTypeTag(tpe))) case ParserInput.WrapInitName => Converted.Success(wrapInitParser(tree)(c.WeakTypeTag(tpe))) case WrapInitInputName => Converted.Success(wrapInitInput(tree)(c.WeakTypeTag(tpe))) case WrapInputName => Converted.Success(wrapInput(tree)(c.WeakTypeTag(tpe))) diff --git a/sbt/src/sbt-test/actions/previous-in-input-task/build.sbt b/sbt/src/sbt-test/actions/previous-in-input-task/build.sbt new file mode 100644 index 000000000..a7e169d7e --- /dev/null +++ b/sbt/src/sbt-test/actions/previous-in-input-task/build.sbt @@ -0,0 +1,10 @@ +import sjsonnew.BasicJsonProtocol._ + +val cacheTask = taskKey[Int]("task") +cacheTask := 1 + +val checkTask = inputKey[Unit]("validate that the correct value is set by cacheTask") +checkTask := { + val expected = Def.spaceDelimited("").parsed.head.toInt + assert(cacheTask.previous.getOrElse(0) == expected) +} \ No newline at end of file diff --git a/sbt/src/sbt-test/actions/previous-in-input-task/test b/sbt/src/sbt-test/actions/previous-in-input-task/test new file mode 100644 index 000000000..1b7969eea --- /dev/null +++ b/sbt/src/sbt-test/actions/previous-in-input-task/test @@ -0,0 +1,5 @@ +> checkTask 0 + +> cacheTask + +> checkTask 1 \ No newline at end of file From 38f94a6e314f58022b7ea3618580a55d9a316249 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 8 Mar 2019 20:15:04 -0500 Subject: [PATCH 03/24] Coursier dependency resolution integration This adds dependency to LM implemented using Coursier. I had to copy paste a bunch of code from sbt-coursier-shared to break the dependency to sbt. `Global / useCoursier := false` or `-Dsbt.coursier=false` be used to opt-out of using Coursier for the dependency resolution. --- build.sbt | 9 +- main/src/main/scala/sbt/Defaults.scala | 73 ++- main/src/main/scala/sbt/Keys.scala | 16 + .../main/scala/sbt/internal/LMCoursier.scala | 524 ++++++++++++++++++ .../sbt/internal/LibraryManagement.scala | 44 +- .../internal/librarymanagement/IvyXml.scala | 224 ++++++++ project/Dependencies.scala | 20 +- .../dependency-management/artifact/build.sbt | 6 +- 8 files changed, 888 insertions(+), 28 deletions(-) create mode 100644 main/src/main/scala/sbt/internal/LMCoursier.scala create mode 100644 main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala diff --git a/build.sbt b/build.sbt index 0d223c21b..f517ad661 100644 --- a/build.sbt +++ b/build.sbt @@ -590,7 +590,12 @@ lazy val mainProj = (project in file("main")) if (xs exists { s => s.contains(s""""$sv"""") }) () else sys.error("PluginCross.scala does not match up with the scalaVersion " + sv) }, - libraryDependencies ++= scalaXml.value ++ Seq(launcherInterface) ++ log4jDependencies ++ Seq(scalaCacheCaffeine), + libraryDependencies ++= { + scalaXml.value ++ + Seq(launcherInterface) ++ + log4jDependencies ++ + Seq(scalaCacheCaffeine, lmCousier) + }, Compile / scalacOptions -= "-Xfatal-warnings", managedSourceDirectories in Compile += baseDirectory.value / "src" / "main" / "contraband-scala", @@ -650,6 +655,7 @@ lazy val sbtProj = (project in file("sbt")) ) .configure(addSbtIO, addSbtCompilerBridge) +/* lazy val sbtBig = (project in file(".big")) .dependsOn(sbtProj) .settings( @@ -685,6 +691,7 @@ lazy val sbtBig = (project in file(".big")) }).transform(node).head }, ) +*/ lazy val sbtIgnoredProblems = { Vector( diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 00d53e26e..d52b6605e 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -12,6 +12,7 @@ import java.net.{ URI, URL, URLClassLoader } import java.util.Optional import java.util.concurrent.{ Callable, TimeUnit } +import coursier.core.{ Configuration => CConfiguration } import org.apache.ivy.core.module.descriptor.ModuleDescriptor import org.apache.ivy.core.module.id.ModuleRevisionId import sbt.Def.{ Initialize, ScopedKey, Setting, SettingsDefinition } @@ -200,6 +201,7 @@ object Defaults extends BuildCommon { exportJars :== false, trackInternalDependencies :== TrackLevel.TrackAlways, exportToInternal :== TrackLevel.TrackAlways, + useCoursier :== LibraryManagement.defaultUseCoursier, retrieveManaged :== false, retrieveManagedSync :== false, configurationsToRetrieve :== None, @@ -224,7 +226,12 @@ object Defaults extends BuildCommon { pomAllRepositories :== false, pomIncludeRepository :== Classpaths.defaultRepositoryFilter, updateOptions := UpdateOptions(), - forceUpdatePeriod :== None + forceUpdatePeriod :== None, + // coursier settings + csrExtraCredentials :== Nil, + csrLogger :== None, + csrCachePath :== coursier.cache.CacheDefaults.location, + csrMavenProfiles :== Set.empty, ) /** Core non-plugin settings for sbt builds. These *must* be on every build or the sbt engine will fail to run at all. */ @@ -2125,6 +2132,14 @@ object Classpaths { }).value, moduleName := normalizedName.value, ivyPaths := IvyPaths(baseDirectory.value, bootIvyHome(appConfiguration.value)), + csrCachePath := { + val old = csrCachePath.value + val ip = ivyPaths.value + val defaultIvyCache = bootIvyHome(appConfiguration.value) + if (old != coursier.cache.CacheDefaults.location) old + else if (ip.ivyHome == defaultIvyCache) old + else ip.ivyHome.getOrElse(old) + }, dependencyCacheDirectory := { val st = state.value BuildPaths.getDependencyDirectory(st, BuildPaths.getGlobalBase(st)) @@ -2181,10 +2196,7 @@ object Classpaths { ) else None }, - dependencyResolution := IvyDependencyResolution( - ivyConfiguration.value, - CustomHttp.okhttpClient.value - ), + dependencyResolution := LibraryManagement.dependencyResolutionTask.value, publisher := IvyPublisher(ivyConfiguration.value, CustomHttp.okhttpClient.value), ivyConfiguration := mkIvyConfiguration.value, ivyConfigurations := { @@ -2198,6 +2210,44 @@ object Classpaths { if (managedScalaInstance.value && scalaHome.value.isEmpty) Configurations.ScalaTool :: Nil else Nil }, + // Coursier needs these + ivyConfigurations := { + val confs = ivyConfigurations.value + val names = confs.map(_.name).toSet + val extraSources = + if (names("sources")) + None + else + Some( + Configuration.of( + id = "Sources", + name = "sources", + description = "", + isPublic = true, + extendsConfigs = Vector.empty, + transitive = false + ) + ) + + val extraDocs = + if (names("docs")) + None + else + Some( + Configuration.of( + id = "Docs", + name = "docs", + description = "", + isPublic = true, + extendsConfigs = Vector.empty, + transitive = false + ) + ) + + val use = useCoursier.value + if (use) confs ++ extraSources.toSeq ++ extraDocs.toSeq + else confs + }, moduleSettings := moduleSettings0.value, makePomConfiguration := MakePomConfiguration() .withFile((artifactPath in makePom).value) @@ -2342,8 +2392,17 @@ object Classpaths { case Right(ur) => ur } } - } tag (Tags.Update, Tags.Network)).value - ) + } tag (Tags.Update, Tags.Network)).value, + csrProject := LMCoursier.coursierProjectTask.value, + csrConfiguration := LMCoursier.coursierConfigurationTask(false, false).value, + csrResolvers := LMCoursier.coursierResolversTask.value, + csrRecursiveResolvers := LMCoursier.coursierRecursiveResolversTask.value, + csrSbtResolvers := LMCoursier.coursierSbtResolversTask.value, + csrInterProjectDependencies := LMCoursier.coursierInterProjectDependenciesTask.value, + csrFallbackDependencies := LMCoursier.coursierFallbackDependenciesTask.value, + ) ++ + IvyXml.generateIvyXmlSettings() ++ + LMCoursier.publicationsSetting(Seq(Compile, Test).map(c => c -> CConfiguration(c.name))) val jvmBaseSettings: Seq[Setting[_]] = Seq( libraryDependencies ++= autoLibraryDependency( diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index ac2711453..52eff84cc 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -32,6 +32,8 @@ import sbt.librarymanagement.ivy.{ Credentials, IvyConfiguration, IvyPaths, Upda import sbt.testing.Framework import sbt.util.{ Level, Logger } import xsbti.compile._ +import coursier.cache.CacheLogger +import coursier.lmcoursier.{ CoursierConfiguration, FallbackDependency } import scala.concurrent.duration.{ Duration, FiniteDuration } import scala.xml.{ NodeSeq, Node => XNode } @@ -351,6 +353,20 @@ object Keys { val fullClasspathAsJars = taskKey[Classpath]("The exported classpath, consisting of build products and unmanaged and managed, internal and external dependencies, all as JARs.") val internalDependencyConfigurations = settingKey[Seq[(ProjectRef, Set[String])]]("The project configurations that this configuration depends on") + val useCoursier = settingKey[Boolean]("Use Coursier for dependency resolution.").withRank(BSetting) + val csrCachePath = settingKey[File]("Coursier cache path").withRank(CSetting) + private[sbt] val csrConfiguration = taskKey[CoursierConfiguration]("General dependency management (Coursier) settings, such as the resolvers and options to use.").withRank(DTask) + private[sbt] val csrProject = taskKey[coursier.core.Project]("") + private[sbt] val csrResolvers = taskKey[Seq[Resolver]]("") + private[sbt] val csrRecursiveResolvers = taskKey[Seq[Resolver]]("Resolvers of the current project, plus those of all from its inter-dependency projects") + private[sbt] val csrSbtResolvers = taskKey[Seq[Resolver]]("Resolvers used for sbt artifacts.") + private[sbt] val csrInterProjectDependencies = taskKey[Seq[coursier.core.Project]]("Projects the current project depends on, possibly transitively") + private[sbt] val csrFallbackDependencies = taskKey[Seq[FallbackDependency]]("") + private[sbt] val csrMavenProfiles = settingKey[Set[String]]("") + private[sbt] val csrLogger = taskKey[Option[CacheLogger]]("") + private[sbt] val csrExtraCredentials = taskKey[Seq[coursier.credentials.Credentials]]("") + private[sbt] val csrPublications = taskKey[Seq[(coursier.core.Configuration, coursier.core.Publication)]]("") + val internalConfigurationMap = settingKey[Configuration => Configuration]("Maps configurations to the actual configuration used to define the classpath.").withRank(CSetting) val classpathConfiguration = taskKey[Configuration]("The configuration used to define the classpath.").withRank(CTask) val ivyConfiguration = taskKey[IvyConfiguration]("General dependency management (Ivy) settings, such as the resolvers and paths to use.").withRank(DTask) diff --git a/main/src/main/scala/sbt/internal/LMCoursier.scala b/main/src/main/scala/sbt/internal/LMCoursier.scala new file mode 100644 index 000000000..cf1a65088 --- /dev/null +++ b/main/src/main/scala/sbt/internal/LMCoursier.scala @@ -0,0 +1,524 @@ +/* + * sbt + * Copyright 2011 - 2018, Lightbend, Inc. + * Copyright 2008 - 2010, Mark Harrah + * Licensed under Apache License 2.0 (see LICENSE) + */ + +package sbt +package internal + +import coursier.core.{ + Attributes => CAttributes, + Classifier, + Configuration => CConfiguration, + Dependency => CDependency, + Extension => CExtension, + Info => CInfo, + Module, + ModuleName, + Organization => COrganization, + Project => CProject, + Publication => CPublication, + Type => CType +} +import coursier.credentials.DirectCredentials +import coursier.lmcoursier._ +import sbt.librarymanagement._ +import Keys._ +import sbt.librarymanagement.ivy.{ + FileCredentials, + Credentials, + DirectCredentials => IvyDirectCredentials +} +import sbt.ScopeFilter.Make._ +import scala.collection.JavaConverters._ + +private[sbt] object LMCoursier { + + def coursierProjectTask: Def.Initialize[sbt.Task[CProject]] = + Def.task { + Inputs.coursierProject( + projectID.value, + allDependencies.value, + excludeDependencies.value, + // should projectID.configurations be used instead? + ivyConfigurations.value, + scalaVersion.value, + scalaBinaryVersion.value, + streams.value.log + ) + } + + def coursierConfigurationTask( + withClassifiers: Boolean, + sbtClassifiers: Boolean + ): Def.Initialize[Task[CoursierConfiguration]] = + Def.taskDyn { + val resolversTask = + if (sbtClassifiers) + csrSbtResolvers + else + csrRecursiveResolvers + val classifiersTask: sbt.Def.Initialize[sbt.Task[Option[Seq[Classifier]]]] = + if (withClassifiers && !sbtClassifiers) + Def.task(Some(sbt.Keys.transitiveClassifiers.value.map(Classifier(_)))) + else + Def.task(None) + Def.task { + val rs = resolversTask.value + val scalaOrg = scalaOrganization.value + val scalaVer = scalaVersion.value + val interProjectDependencies = csrInterProjectDependencies.value + val excludeDeps = Inputs.exclusions( + excludeDependencies.value, + scalaVer, + scalaBinaryVersion.value, + streams.value.log + ) + val fallbackDeps = csrFallbackDependencies.value + val autoScalaLib = autoScalaLibrary.value && scalaModuleInfo.value.forall( + _.overrideScalaVersion + ) + val profiles = csrMavenProfiles.value + val credentials = credentialsTask.value + + val createLogger = csrLogger.value + + val cache = csrCachePath.value + + val internalSbtScalaProvider = appConfiguration.value.provider.scalaProvider + val sbtBootJars = internalSbtScalaProvider.jars() + val sbtScalaVersion = internalSbtScalaProvider.version() + val sbtScalaOrganization = "org.scala-lang" // always assuming sbt uses mainline scala + val classifiers = classifiersTask.value + val s = streams.value + Classpaths.warnResolversConflict(rs, s.log) + CoursierConfiguration() + .withResolvers(rs.toVector) + .withInterProjectDependencies(interProjectDependencies.toVector) + .withFallbackDependencies(fallbackDeps.toVector) + .withExcludeDependencies( + excludeDeps.toVector.sorted + .map { + case (o, n) => + (o.value, n.value) + } + ) + .withAutoScalaLibrary(autoScalaLib) + .withSbtScalaJars(sbtBootJars.toVector) + .withSbtScalaVersion(sbtScalaVersion) + .withSbtScalaOrganization(sbtScalaOrganization) + .withClassifiers(classifiers.toVector.flatten.map(_.value)) + .withHasClassifiers(classifiers.nonEmpty) + .withMavenProfiles(profiles.toVector.sorted) + .withScalaOrganization(scalaOrg) + .withScalaVersion(scalaVer) + .withCredentials(credentials) + .withLogger(createLogger) + .withCache(cache) + .withLog(s.log) + } + } + + val credentialsTask = Def.task { + val log = streams.value.log + + val creds = sbt.Keys.credentials.value + .flatMap { + case dc: IvyDirectCredentials => List(dc) + case fc: FileCredentials => + Credentials.loadCredentials(fc.path) match { + case Left(err) => + log.warn(s"$err, ignoring it") + Nil + case Right(dc) => List(dc) + } + } + .map { c => + DirectCredentials() + .withHost(c.host) + .withUsername(c.userName) + .withPassword(c.passwd) + .withRealm(Some(c.realm).filter(_.nonEmpty)) + } + creds ++ csrExtraCredentials.value + } + + def coursierRecursiveResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = + Def.taskDyn { + val state = sbt.Keys.state.value + val projectRef = sbt.Keys.thisProjectRef.value + + val projects = allRecursiveInterDependencies(state, projectRef) + Def.task { + csrResolvers.all(ScopeFilter(inProjects(projectRef +: projects: _*))).value.flatten + } + } + + def coursierResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = + Def.taskDyn { + val bootResOpt = bootResolvers.value + val overrideFlag = overrideBuildResolvers.value + Def.task { + val result = resultTask(bootResOpt, overrideFlag).value + val reorderResolvers = true // coursierReorderResolvers.value + val keepPreloaded = false // coursierKeepPreloaded.value + + val result0 = + if (reorderResolvers) + ResolutionParams.reorderResolvers(result) + else + result + + if (keepPreloaded) + result0 + else + result0.filter { r => + !r.name.startsWith("local-preloaded") + } + } + } + + private val pluginIvySnapshotsBase = Resolver.SbtRepositoryRoot.stripSuffix("/") + "/ivy-snapshots" + + def coursierSbtResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = Def.task { + val resolvers = + sbt.Classpaths + .bootRepositories(appConfiguration.value) + .toSeq + .flatten ++ // required because of the hack above it seems + externalResolvers.in(updateSbtClassifiers).value + + val pluginIvySnapshotsFound = resolvers.exists { + case repo: URLRepository => + repo.patterns.artifactPatterns.headOption + .exists(_.startsWith(pluginIvySnapshotsBase)) + case _ => false + } + + val resolvers0 = + if (pluginIvySnapshotsFound && !resolvers.contains(Classpaths.sbtPluginReleases)) + resolvers :+ Classpaths.sbtPluginReleases + else + resolvers + val keepPreloaded = true // coursierKeepPreloaded.value + if (keepPreloaded) + resolvers0 + else + resolvers0.filter { r => + !r.name.startsWith("local-preloaded") + } + } + + def coursierInterProjectDependenciesTask: Def.Initialize[sbt.Task[Seq[CProject]]] = + Def.taskDyn { + + val state = sbt.Keys.state.value + val projectRef = sbt.Keys.thisProjectRef.value + + val projectRefs = allRecursiveInterDependencies(state, projectRef) + + Def.task { + val projects = csrProject.all(ScopeFilter(inProjects(projectRefs: _*))).value + val projectModules = projects.map(_.module).toSet + + // this includes org.scala-sbt:global-plugins referenced from meta-builds in particular + val extraProjects = sbt.Keys.projectDescriptors.value + .map { + case (k, v) => + moduleFromIvy(k) -> v + } + .filter { + case (module, _) => + !projectModules(module) + } + .toVector + .map { + case (module, v) => + val configurations = v.getConfigurations.map { c => + CConfiguration(c.getName) -> c.getExtends.map(CConfiguration(_)).toSeq + }.toMap + val deps = v.getDependencies.flatMap(dependencyFromIvy) + CProject( + module, + v.getModuleRevisionId.getRevision, + deps, + configurations, + None, + Nil, + Nil, + Nil, + None, + None, + None, + relocated = false, + None, + Nil, + CInfo.empty + ) + } + + projects ++ extraProjects + } + } + + def coursierFallbackDependenciesTask: Def.Initialize[sbt.Task[Seq[FallbackDependency]]] = + Def.taskDyn { + val s = state.value + val projectRef = sbt.Keys.thisProjectRef.value + + val projects = allRecursiveInterDependencies(s, projectRef) + Def.task { + val allDeps = + allDependencies.all(ScopeFilter(inProjects(projectRef +: projects: _*))).value.flatten + + FromSbt.fallbackDependencies( + allDeps, + scalaVersion.in(projectRef).value, + scalaBinaryVersion.in(projectRef).value + ) + } + } + + def publicationsSetting(packageConfigs: Seq[(Configuration, CConfiguration)]): Def.Setting[_] = { + csrPublications := coursierPublicationsTask(packageConfigs: _*).value + } + + def coursierPublicationsTask( + configsMap: (Configuration, CConfiguration)* + ): Def.Initialize[sbt.Task[Seq[(CConfiguration, CPublication)]]] = + Def.task { + val s = sbt.Keys.state.value + val projectRef = sbt.Keys.thisProjectRef.value + val projId = sbt.Keys.projectID.value + val sv = sbt.Keys.scalaVersion.value + val sbv = sbt.Keys.scalaBinaryVersion.value + val ivyConfs = sbt.Keys.ivyConfigurations.value + val extracted = Project.extract(s) + import extracted._ + + val sourcesConfigOpt = + if (ivyConfigurations.value.exists(_.name == "sources")) + Some(CConfiguration("sources")) + else + None + + val docsConfigOpt = + if (ivyConfigurations.value.exists(_.name == "docs")) + Some(CConfiguration("docs")) + else + None + + val sbtBinArtifacts = + for ((config, targetConfig) <- configsMap) yield { + + val publish = getOpt( + publishArtifact + .in(projectRef) + .in(packageBin) + .in(config) + ).getOrElse(false) + + if (publish) + getOpt( + artifact + .in(projectRef) + .in(packageBin) + .in(config) + ).map(targetConfig -> _) + else + None + } + + val sbtSourceArtifacts = + for ((config, targetConfig) <- configsMap) yield { + + val publish = getOpt( + publishArtifact + .in(projectRef) + .in(packageSrc) + .in(config) + ).getOrElse(false) + + if (publish) + getOpt( + artifact + .in(projectRef) + .in(packageSrc) + .in(config) + ).map(sourcesConfigOpt.getOrElse(targetConfig) -> _) + else + None + } + + val sbtDocArtifacts = + for ((config, targetConfig) <- configsMap) yield { + + val publish = + getOpt( + publishArtifact + .in(projectRef) + .in(packageDoc) + .in(config) + ).getOrElse(false) + + if (publish) + getOpt( + artifact + .in(projectRef) + .in(packageDoc) + .in(config) + ).map(docsConfigOpt.getOrElse(targetConfig) -> _) + else + None + } + + val sbtArtifacts = sbtBinArtifacts ++ sbtSourceArtifacts ++ sbtDocArtifacts + + def artifactPublication(artifact: Artifact) = { + + val name = FromSbt.sbtCrossVersionName( + artifact.name, + projId.crossVersion, + sv, + sbv + ) + + CPublication( + name, + CType(artifact.`type`), + CExtension(artifact.extension), + artifact.classifier.fold(Classifier.empty)(Classifier(_)) + ) + } + + val sbtArtifactsPublication = sbtArtifacts.collect { + case Some((config, artifact)) => + config -> artifactPublication(artifact) + } + + val stdArtifactsSet = sbtArtifacts.flatMap(_.map { case (_, a) => a }.toSeq).toSet + + // Second-way of getting artifacts from SBT + // No obvious way of getting the corresponding publishArtifact value for the ones + // only here, it seems. + val extraSbtArtifacts = getOpt( + sbt.Keys.artifacts + .in(projectRef) + ).getOrElse(Nil) + .filterNot(stdArtifactsSet) + + // Seems that SBT does that - if an artifact has no configs, + // it puts it in all of them. See for example what happens to + // the standalone JAR artifact of the coursier cli module. + def allConfigsIfEmpty(configs: Iterable[ConfigRef]): Iterable[ConfigRef] = + if (configs.isEmpty) ivyConfs.filter(_.isPublic).map(c => ConfigRef(c.name)) else configs + + val extraSbtArtifactsPublication = for { + artifact <- extraSbtArtifacts + config <- allConfigsIfEmpty(artifact.configurations.map(x => ConfigRef(x.name))) + // FIXME If some configurations from artifact.configurations are not public, they may leak here :\ + } yield CConfiguration(config.name) -> artifactPublication(artifact) + + sbtArtifactsPublication ++ extraSbtArtifactsPublication + } + + private def moduleFromIvy(id: org.apache.ivy.core.module.id.ModuleRevisionId): Module = + Module( + COrganization(id.getOrganisation), + ModuleName(id.getName), + id.getExtraAttributes.asScala.map { + case (k0, v0) => k0.asInstanceOf[String] -> v0.asInstanceOf[String] + }.toMap + ) + + private def dependencyFromIvy( + desc: org.apache.ivy.core.module.descriptor.DependencyDescriptor + ): Seq[(CConfiguration, CDependency)] = { + + val id = desc.getDependencyRevisionId + val module = moduleFromIvy(id) + val exclusions = desc.getAllExcludeRules.map { rule => + // we're ignoring rule.getConfigurations and rule.getMatcher here + val modId = rule.getId.getModuleId + // we're ignoring modId.getAttributes here + (COrganization(modId.getOrganisation), ModuleName(modId.getName)) + }.toSet + + val configurations = desc.getModuleConfigurations.toVector + .flatMap(s => coursier.ivy.IvyXml.mappings(s)) + + def dependency(conf: CConfiguration, attr: CAttributes) = CDependency( + module, + id.getRevision, + conf, + exclusions, + attr, + optional = false, + desc.isTransitive + ) + + val attributes: CConfiguration => CAttributes = { + + val artifacts = desc.getAllDependencyArtifacts + + val m = artifacts.toVector.flatMap { art => + val attr = CAttributes(CType(art.getType), Classifier.empty) + art.getConfigurations.map(CConfiguration(_)).toVector.map { conf => + conf -> attr + } + }.toMap + + c => m.getOrElse(c, CAttributes.empty) + } + + configurations.map { + case (from, to) => + from -> dependency(to, attributes(to)) + } + } + + private def resultTask( + bootResOpt: Option[Seq[Resolver]], + overrideFlag: Boolean + ): Def.Initialize[sbt.Task[Seq[Resolver]]] = + bootResOpt.filter(_ => overrideFlag) match { + case Some(r) => Def.task(r) + case None => + Def.taskDyn { + val extRes = externalResolvers.value + val isSbtPlugin = sbtPlugin.value + if (isSbtPlugin) + Def.task { + Seq( + sbtResolver.value, + Classpaths.sbtPluginReleases + ) ++ extRes + } else + Def.task(extRes) + } + } + + def allRecursiveInterDependencies(state: sbt.State, projectRef: sbt.ProjectRef) = { + def dependencies(map: Map[String, Seq[String]], id: String): Set[String] = { + + def helper(map: Map[String, Seq[String]], acc: Set[String]): Set[String] = + if (acc.exists(map.contains)) { + val (kept, rem) = map.partition { case (k, _) => acc(k) } + helper(rem, acc ++ kept.valuesIterator.flatten) + } else + acc + + helper(map - id, map.getOrElse(id, Nil).toSet) + } + + val allProjectsDeps = + for (p <- Project.structure(state).allProjects) + yield p.id -> p.dependencies.map(_.project.project) + + val deps = dependencies(allProjectsDeps.toMap, projectRef.project) + + Project.structure(state).allProjectRefs.filter(p => deps(p.project)) + } +} diff --git a/main/src/main/scala/sbt/internal/LibraryManagement.scala b/main/src/main/scala/sbt/internal/LibraryManagement.scala index e6366446d..eaed30432 100644 --- a/main/src/main/scala/sbt/internal/LibraryManagement.scala +++ b/main/src/main/scala/sbt/internal/LibraryManagement.scala @@ -5,12 +5,15 @@ * Licensed under Apache License 2.0 (see LICENSE) */ -package sbt.internal +package sbt +package internal +import coursier.lmcoursier.CoursierDependencyResolution import java.io.File - import sbt.internal.librarymanagement._ +import sbt.internal.util.{ ConsoleAppender, LogOption } import sbt.librarymanagement._ +import sbt.librarymanagement.ivy.IvyDependencyResolution import sbt.librarymanagement.syntax._ import sbt.util.{ CacheStore, CacheStoreFactory, Logger, Tracked } import sbt.io.IO @@ -19,6 +22,43 @@ private[sbt] object LibraryManagement { private type UpdateInputs = (Long, ModuleSettings, UpdateConfiguration) + def defaultUseCoursier: Boolean = { + val coursierOpt = sys.props + .get("sbt.coursier") + .flatMap( + str => + ConsoleAppender.parseLogOption(str) match { + case LogOption.Always => Some(true) + case LogOption.Never => Some(false) + case _ => None + } + ) + val ivyOpt = sys.props + .get("sbt.ivy") + .flatMap( + str => + ConsoleAppender.parseLogOption(str) match { + case LogOption.Always => Some(true) + case LogOption.Never => Some(false) + case _ => None + } + ) + val notIvyOpt = ivyOpt map { !_ } + coursierOpt.orElse(notIvyOpt).getOrElse(true) + } + + def dependencyResolutionTask: Def.Initialize[Task[DependencyResolution]] = Def.taskDyn { + if (Keys.useCoursier.value) { + Def.task { CoursierDependencyResolution(Keys.csrConfiguration.value) } + } else + Def.task { + IvyDependencyResolution( + Keys.ivyConfiguration.value, + CustomHttp.okhttpClient.value + ) + } + } + def cachedUpdate( lm: DependencyResolution, module: ModuleDescriptor, diff --git a/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala new file mode 100644 index 000000000..99db26f58 --- /dev/null +++ b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala @@ -0,0 +1,224 @@ +/* + * sbt + * Copyright 2011 - 2018, Lightbend, Inc. + * Copyright 2008 - 2010, Mark Harrah + * Licensed under Apache License 2.0 (see LICENSE) + */ + +package sbt +package internal +package librarymanagement + +import java.nio.charset.StandardCharsets.UTF_8 +import java.nio.file.Files + +import coursier.core.{ Configuration, Project } +import org.apache.ivy.core.module.id.ModuleRevisionId +import Def.Setting +import sbt.Keys.{ + csrProject, + csrPublications, + publishLocalConfiguration, + publishConfiguration, + useCoursier +} +import sbt.librarymanagement.PublishConfiguration +import scala.collection.JavaConverters._ +import scala.xml.{ Node, PrefixedAttribute } + +object IvyXml { + import sbt.Project._ + + def rawContent( + currentProject: Project, + shadedConfigOpt: Option[Configuration] + ): String = { + + // Important: width = Int.MaxValue, so that no tag gets truncated. + // In particular, that prevents things like to be split to + // + // + // by the pretty-printer. + // See https://github.com/sbt/sbt/issues/3412. + val printer = new scala.xml.PrettyPrinter(Int.MaxValue, 2) + + """""" + '\n' + + printer.format(content(currentProject, shadedConfigOpt)) + } + + // These are required for publish to be fine, later on. + def writeFiles( + currentProject: Project, + shadedConfigOpt: Option[Configuration], + ivySbt: IvySbt, + log: sbt.util.Logger + ): Unit = { + + val ivyCacheManager = ivySbt.withIvy(log)(ivy => ivy.getResolutionCacheManager) + + val ivyModule = ModuleRevisionId.newInstance( + currentProject.module.organization.value, + currentProject.module.name.value, + currentProject.version, + currentProject.module.attributes.asJava + ) + + val cacheIvyFile = ivyCacheManager.getResolvedIvyFileInCache(ivyModule) + val cacheIvyPropertiesFile = ivyCacheManager.getResolvedIvyPropertiesInCache(ivyModule) + + val content0 = rawContent(currentProject, shadedConfigOpt) + cacheIvyFile.getParentFile.mkdirs() + log.info(s"Writing Ivy file $cacheIvyFile") + Files.write(cacheIvyFile.toPath, content0.getBytes(UTF_8)) + + // Just writing an empty file here... Are these only used? + cacheIvyPropertiesFile.getParentFile.mkdirs() + Files.write(cacheIvyPropertiesFile.toPath, Array.emptyByteArray) + () + } + + def content(project0: Project, shadedConfigOpt: Option[Configuration]): Node = { + + val filterOutDependencies = + shadedConfigOpt.toSet[Configuration].flatMap { shadedConfig => + project0.dependencies + .collect { case (`shadedConfig`, dep) => dep } + } + + val project: Project = project0.copy( + dependencies = project0.dependencies.collect { + case p @ (_, dep) if !filterOutDependencies(dep) => p + } + ) + + val infoAttrs = project.module.attributes.foldLeft[xml.MetaData](xml.Null) { + case (acc, (k, v)) => + new PrefixedAttribute("e", k, v, acc) + } + + val licenseElems = project.info.licenses.map { + case (name, urlOpt) => + val n = + + urlOpt.fold(n) { url => + n % .attributes + } + } + + val infoElem = { + + {licenseElems} + {project.info.description} + + } % infoAttrs + + val confElems = project.configurations.toVector.collect { + case (name, extends0) if !shadedConfigOpt.contains(name) => + val extends1 = shadedConfigOpt.fold(extends0)(c => extends0.filter(_ != c)) + val n = + if (extends1.nonEmpty) + n % .attributes + else + n + } + + val publications = project.publications + .groupBy { case (_, p) => p } + .mapValues { _.map { case (cfg, _) => cfg } } + + val publicationElems = publications.map { + case (pub, configs) => + val n = + + + if (pub.classifier.nonEmpty) + n % .attributes + else + n + } + + val dependencyElems = project.dependencies.toVector.map { + case (conf, dep) => + val excludes = dep.exclusions.toSeq.map { + case (org, name) => + + } + + val n = + ${dep.configuration.value}"}> + {excludes} + + + val moduleAttrs = dep.module.attributes.foldLeft[xml.MetaData](xml.Null) { + case (acc, (k, v)) => + new PrefixedAttribute("e", k, v, acc) + } + + n % moduleAttrs + } + + + {infoElem} + {confElems} + {publicationElems} + {dependencyElems} + + } + + def makeIvyXmlBefore[T]( + task: TaskKey[T], + shadedConfigOpt: Option[Configuration] + ): Setting[Task[T]] = + task := task.dependsOn { + Def.taskDyn { + val doGen = useCoursier.value + if (doGen) + Def.task { + val currentProject = { + val proj = csrProject.value + val publications = csrPublications.value + proj.copy(publications = publications) + } + IvyXml.writeFiles( + currentProject, + shadedConfigOpt, + sbt.Keys.ivySbt.value, + sbt.Keys.streams.value.log + ) + } else + Def.task(()) + } + }.value + + private lazy val needsIvyXmlLocal = Seq(publishLocalConfiguration) ++ getPubConf( + "makeIvyXmlLocalConfiguration" + ) + private lazy val needsIvyXml = Seq(publishConfiguration) ++ getPubConf( + "makeIvyXmlConfiguration" + ) + + private[this] def getPubConf(method: String): List[TaskKey[PublishConfiguration]] = + try { + val cls = sbt.Keys.getClass + val m = cls.getMethod(method) + val task = m.invoke(sbt.Keys).asInstanceOf[TaskKey[PublishConfiguration]] + List(task) + } catch { + case _: Throwable => // FIXME Too wide + Nil + } + + def generateIvyXmlSettings( + shadedConfigOpt: Option[Configuration] = None + ): Seq[Setting[_]] = + (needsIvyXml ++ needsIvyXmlLocal).map(IvyXml.makeIvyXmlBefore(_, shadedConfigOpt)) + +} diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 226b6567f..64c9a8f26 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -29,22 +29,7 @@ object Dependencies { private val utilScripted = "org.scala-sbt" %% "util-scripted" % utilVersion private val libraryManagementCore = "org.scala-sbt" %% "librarymanagement-core" % lmVersion - - private val libraryManagementImpl = { - val lmOrganization = - sys.props.get("sbt.build.lm.organization") match { - case Some(impl) => impl - case _ => "org.scala-sbt" - } - - val lmModuleName = - sys.props.get("sbt.build.lm.moduleName") match { - case Some(impl) => impl - case _ => "librarymanagement-ivy" - } - - lmOrganization %% lmModuleName % lmVersion - } + private val libraryManagementImpl = "org.scala-sbt" %% "librarymanagement-ivy" % lmVersion val launcherVersion = "1.0.4" val launcherInterface = "org.scala-sbt" % "launcher-interface" % launcherVersion @@ -115,6 +100,9 @@ object Dependencies { def addSbtZincCompile(p: Project): Project = addSbtModule(p, sbtZincPath, "zincCompile", zincCompile) + val lmCousierVersion = "1.1.0-M14" + val lmCousier = "io.get-coursier" %% "lm-coursier" % lmCousierVersion + val sjsonNewScalaJson = Def.setting { "com.eed3si9n" %% "sjson-new-scalajson" % contrabandSjsonNewVersion.value } diff --git a/sbt/src/sbt-test/dependency-management/artifact/build.sbt b/sbt/src/sbt-test/dependency-management/artifact/build.sbt index 7a737bbec..5ba1238bf 100644 --- a/sbt/src/sbt-test/dependency-management/artifact/build.sbt +++ b/sbt/src/sbt-test/dependency-management/artifact/build.sbt @@ -35,7 +35,9 @@ def retrieveID = org % "test-retrieve" % "2.0" // check that the test class is on the compile classpath, either because it was compiled or because it was properly retrieved def checkTask(classpath: TaskKey[Classpath]) = Def task { - val loader = ClasspathUtilities.toLoader((classpath in Compile).value.files, scalaInstance.value.loader) + val deps = libraryDependencies.value + val cp = (classpath in Compile).value.files + val loader = ClasspathUtilities.toLoader(cp, scalaInstance.value.loader) try { Class.forName("test.Test", false, loader); () } - catch { case _: ClassNotFoundException | _: NoClassDefFoundError => sys.error("Dependency not retrieved properly") } + catch { case _: ClassNotFoundException | _: NoClassDefFoundError => sys.error(s"Dependency not retrieved properly: $deps, $cp") } } From 21782a51f03fd5c7df0779a1a0c4c9538542cd61 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Wed, 17 Apr 2019 18:23:24 -0400 Subject: [PATCH 04/24] write info.apiURL to ivy.xml Ref https://github.com/coursier/coursier/issues/1123 --- main/src/main/scala/sbt/internal/LMCoursier.scala | 10 ++++++++-- .../scala/sbt/internal/librarymanagement/IvyXml.scala | 9 +++++---- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/main/src/main/scala/sbt/internal/LMCoursier.scala b/main/src/main/scala/sbt/internal/LMCoursier.scala index cf1a65088..6d9ff7056 100644 --- a/main/src/main/scala/sbt/internal/LMCoursier.scala +++ b/main/src/main/scala/sbt/internal/LMCoursier.scala @@ -38,16 +38,22 @@ private[sbt] object LMCoursier { def coursierProjectTask: Def.Initialize[sbt.Task[CProject]] = Def.task { - Inputs.coursierProject( + val auOpt = apiURL.value + val proj = Inputs.coursierProject( projectID.value, allDependencies.value, excludeDependencies.value, - // should projectID.configurations be used instead? ivyConfigurations.value, scalaVersion.value, scalaBinaryVersion.value, streams.value.log ) + auOpt match { + case Some(au) => + val props = proj.properties :+ ("info.apiURL" -> au.toString) + proj.copy(properties = props) + case _ => proj + } } def coursierConfigurationTask( diff --git a/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala index 99db26f58..7cb58451a 100644 --- a/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala +++ b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala @@ -91,10 +91,11 @@ object IvyXml { } ) - val infoAttrs = project.module.attributes.foldLeft[xml.MetaData](xml.Null) { - case (acc, (k, v)) => - new PrefixedAttribute("e", k, v, acc) - } + val infoAttrs = + (project.module.attributes.toSeq ++ project.properties).foldLeft[xml.MetaData](xml.Null) { + case (acc, (k, v)) => + new PrefixedAttribute("e", k, v, acc) + } val licenseElems = project.info.licenses.map { case (name, urlOpt) => From 35a0ee4321973f591b55f5234da71b315e913630 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Wed, 17 Apr 2019 21:46:37 -0400 Subject: [PATCH 05/24] relax dependency-management/compiler-bridge-binary --- .../compiler-bridge-binary/build.sbt | 13 +++++++++++-- .../compiler-bridge-binary/test | 1 + 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt index a3b3bf1f4..6f8d12fb0 100644 --- a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt +++ b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt @@ -1,4 +1,6 @@ -scalaVersion := "2.12.6" +ThisBuild / scalaVersion := "2.12.6" + +lazy val check = taskKey[Unit]("") // We can't use "%%" here without breaking the "== bridgeModule" check below val bridgeModule = "org.scala-sbt" % s"compiler-bridge_2.12" % "1.2.1" @@ -10,7 +12,14 @@ scalaCompilerBridgeSource := "shouldnotbeused" % "dummy" % "dummy" scalaCompilerBridgeBinaryJar := { for { toolReport <- update.value.configuration(Configurations.ScalaTool) - m <- toolReport.modules.find(m => m.module == bridgeModule) + m <- toolReport.modules.find(m => m.module.name == bridgeModule.name) (_, file) <- m.artifacts.find(art => art._1.`type` == Artifact.DefaultType) } yield file } + +check := { + val toolReport = update.value.configuration(Configurations.ScalaTool).get + val m = toolReport.modules.find(m => m.module.name == bridgeModule.name) + val bridge = scalaCompilerBridgeBinaryJar.value + bridge.getOrElse(sys.error(s"bridge JAR is missing: $toolReport")) +} diff --git a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/test b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/test index 5df2af1f3..5f1fbe2c5 100644 --- a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/test +++ b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/test @@ -1 +1,2 @@ +> check > compile From 6a99906386aff0ee32bdcf907182705d2b3e81cb Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Thu, 18 Apr 2019 19:16:11 -0400 Subject: [PATCH 06/24] manually expand ivy.home Ref https://github.com/coursier/coursier/issues/1124 --- .../main/scala/sbt/internal/LMCoursier.scala | 38 +++++++++++++------ 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/main/src/main/scala/sbt/internal/LMCoursier.scala b/main/src/main/scala/sbt/internal/LMCoursier.scala index 6d9ff7056..f39198ee2 100644 --- a/main/src/main/scala/sbt/internal/LMCoursier.scala +++ b/main/src/main/scala/sbt/internal/LMCoursier.scala @@ -24,6 +24,7 @@ import coursier.core.{ } import coursier.credentials.DirectCredentials import coursier.lmcoursier._ +import sbt.io.IO import sbt.librarymanagement._ import Keys._ import sbt.librarymanagement.ivy.{ @@ -167,20 +168,35 @@ private[sbt] object LMCoursier { val bootResOpt = bootResolvers.value val overrideFlag = overrideBuildResolvers.value Def.task { - val result = resultTask(bootResOpt, overrideFlag).value + val result0 = resultTask(bootResOpt, overrideFlag).value val reorderResolvers = true // coursierReorderResolvers.value val keepPreloaded = false // coursierKeepPreloaded.value - - val result0 = - if (reorderResolvers) - ResolutionParams.reorderResolvers(result) - else - result - - if (keepPreloaded) - result0 + val paths = ivyPaths.value + val result1 = + if (reorderResolvers) ResolutionParams.reorderResolvers(result0) + else result0 + val result2 = + paths.ivyHome match { + case Some(ivyHome) => + val ivyHomeUri = IO.toURI(ivyHome).getSchemeSpecificPart + result1 map { + case r: FileRepository => + val ivyPatterns = r.patterns.ivyPatterns map { + _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri) + } + val artifactPatterns = r.patterns.artifactPatterns map { + _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri) + } + val p = + r.patterns.withIvyPatterns(ivyPatterns).withArtifactPatterns(artifactPatterns) + r.withPatterns(p) + case r => r + } + case _ => result1 + } + if (keepPreloaded) result2 else - result0.filter { r => + result2.filter { r => !r.name.startsWith("local-preloaded") } } From 9b0ffde51917c83d1114068588cc78ea3bfbeb61 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 12:31:03 -0400 Subject: [PATCH 07/24] disable metadata-only-resolver test --- .../metadata-only-resolver/{test => disable} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename sbt/src/sbt-test/dependency-management/metadata-only-resolver/{test => disable} (100%) diff --git a/sbt/src/sbt-test/dependency-management/metadata-only-resolver/test b/sbt/src/sbt-test/dependency-management/metadata-only-resolver/disable similarity index 100% rename from sbt/src/sbt-test/dependency-management/metadata-only-resolver/test rename to sbt/src/sbt-test/dependency-management/metadata-only-resolver/disable From e206e797fe8dab24b467bdc9726385b9249c3acd Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 12:32:17 -0400 Subject: [PATCH 08/24] set up specific dependencyResolution instances --- main/src/main/scala/sbt/Defaults.scala | 103 ++++++++++-------- .../dependency-management/sources/build.sbt | 24 ++-- 2 files changed, 68 insertions(+), 59 deletions(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index d52b6605e..fc760a954 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -2348,51 +2348,60 @@ object Classpaths { ew.infoAllTheThings foreach { log.info(_) } ew }, - classifiersModule in updateClassifiers := { - 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, - None, - externalModules, - ivyConfigurations.in(updateClassifiers).value.toVector, - transitiveClassifiers.in(updateClassifiers).value.toVector + ) ++ + inTask(updateClassifiers)( + Seq( + classifiersModule := { + 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, + None, + externalModules, + ivyConfigurations.value.toVector, + transitiveClassifiers.value.toVector + ) + }, + dependencyResolution := LibraryManagement.dependencyResolutionTask.value, + csrConfiguration := LMCoursier.coursierConfigurationTask(true, false).value, + updateClassifiers in TaskGlobal := (Def.task { + val s = streams.value + val is = ivySbt.value + val lm = dependencyResolution.value + val mod = classifiersModule.value + val updateConfig0 = updateConfiguration.value + val updateConfig = updateConfig0 + .withMetadataDirectory(dependencyCacheDirectory.value) + .withArtifactFilter( + updateConfig0.artifactFilter.map(af => af.withInverted(!af.inverted)) + ) + val app = appConfiguration.value + val srcTypes = sourceArtifactTypes.value + val docTypes = docArtifactTypes.value + val out = is.withIvy(s.log)(_.getSettings.getDefaultIvyUserDir) + val uwConfig = (unresolvedWarningConfiguration in update).value + withExcludes(out, mod.classifiers, lock(app)) { excludes => + lm.updateClassifiers( + GetClassifiersConfiguration( + mod, + excludes.toVector, + updateConfig, + // scalaModule, + srcTypes.toVector, + docTypes.toVector + ), + uwConfig, + Vector.empty, + s.log + ) match { + case Left(_) => ??? + case Right(ur) => ur + } + } + } tag (Tags.Update, Tags.Network)).value, ) - }, - updateClassifiers := (Def.task { - val s = streams.value - val is = ivySbt.value - val lm = dependencyResolution.value - val mod = (classifiersModule in updateClassifiers).value - val updateConfig0 = updateConfiguration.value - val updateConfig = updateConfig0 - .withMetadataDirectory(dependencyCacheDirectory.value) - .withArtifactFilter(updateConfig0.artifactFilter.map(af => af.withInverted(!af.inverted))) - val app = appConfiguration.value - val srcTypes = sourceArtifactTypes.value - val docTypes = docArtifactTypes.value - val out = is.withIvy(s.log)(_.getSettings.getDefaultIvyUserDir) - val uwConfig = (unresolvedWarningConfiguration in update).value - withExcludes(out, mod.classifiers, lock(app)) { excludes => - lm.updateClassifiers( - GetClassifiersConfiguration( - mod, - excludes.toVector, - updateConfig, - // scalaModule, - srcTypes.toVector, - docTypes.toVector - ), - uwConfig, - Vector.empty, - s.log - ) match { - case Left(_) => ??? - case Right(ur) => ur - } - } - } tag (Tags.Update, Tags.Network)).value, + ) ++ Seq( csrProject := LMCoursier.coursierProjectTask.value, csrConfiguration := LMCoursier.coursierConfigurationTask(false, false).value, csrResolvers := LMCoursier.coursierResolversTask.value, @@ -2563,10 +2572,8 @@ object Classpaths { ).withScalaOrganization(scalaOrganization.value) ) }, - dependencyResolution := IvyDependencyResolution( - ivyConfiguration.value, - CustomHttp.okhttpClient.value - ), + dependencyResolution := LibraryManagement.dependencyResolutionTask.value, + csrConfiguration := LMCoursier.coursierConfigurationTask(false, true).value, updateSbtClassifiers in TaskGlobal := (Def.task { val lm = dependencyResolution.value val s = streams.value diff --git a/sbt/src/sbt-test/dependency-management/sources/build.sbt b/sbt/src/sbt-test/dependency-management/sources/build.sbt index 7feee83fe..91f35d197 100644 --- a/sbt/src/sbt-test/dependency-management/sources/build.sbt +++ b/sbt/src/sbt-test/dependency-management/sources/build.sbt @@ -1,5 +1,7 @@ -lazy val root = (project in file(".")). - settings( +ThisBuild / useCoursier := false + +lazy val root = (project in file(".")) + .settings( libraryDependencies += "net.liftweb" % "lift-webkit" % "1.0" intransitive(), libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5" intransitive(), autoScalaLibrary := false, @@ -11,15 +13,15 @@ lazy val root = (project in file(".")). def getSources(report: UpdateReport) = report.matching(artifactFilter(`classifier` = "sources") ) def checkSources(report: UpdateReport): Unit = -{ - val srcs = getSources(report) - if(srcs.isEmpty) - sys.error("No sources retrieved") - else if(srcs.size != 2) - sys.error("Incorrect sources retrieved:\n\t" + srcs.mkString("\n\t")) - else - () -} + { + val srcs = getSources(report) + if(srcs.isEmpty) + sys.error(s"No sources retrieved\n\n$report") + else if(srcs.size != 2) + sys.error("Incorrect sources retrieved:\n\t" + srcs.mkString("\n\t")) + else + () + } def checkBinaries(report: UpdateReport): Unit = { From 697b2b534a359f18a4348d6b4500e7dcad84b760 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 13:53:05 -0400 Subject: [PATCH 09/24] add additional resolver to help Coursier --- sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt b/sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt index 55b3bac97..493c6dcac 100644 --- a/sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt +++ b/sbt/src/sbt-test/project/cross-plugins-defaults/build.sbt @@ -11,12 +11,15 @@ lazy val root = (project in file(".")) sbtPlugin := true, TaskKey[Unit]("check") := mkCheck("2.12", "1.0", "1.").value, - TaskKey[Unit]("check2") := mkCheck("2.10", "0.13", "0.13").value + TaskKey[Unit]("check2") := mkCheck("2.10", "0.13", "0.13").value, + + // Coursier requires extra resolver for sbt 0.13 + resolvers += Resolver.typesafeIvyRepo("releases"), ) lazy val app = (project in file("app")) -def mkCheck(scalaBinV: String, sbtBinVer: String, sbtVerPrefix: String) = Def task { +def mkCheck(scalaBinV: String, sbtBinVer: String, sbtVerPrefix: String) = Def.task { val crossV = (sbtVersion in pluginCrossBuild).value val crossBinV = (sbtBinaryVersion in pluginCrossBuild).value val sv = projectID.value.extraAttributes("e:scalaVersion") From 5614cfcbb6e9379bcab9815d97deb424642d0f81 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 14:06:06 -0400 Subject: [PATCH 10/24] Move log to outer task --- main/src/main/scala/sbt/internal/LMCoursier.scala | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/main/src/main/scala/sbt/internal/LMCoursier.scala b/main/src/main/scala/sbt/internal/LMCoursier.scala index f39198ee2..57c3505b4 100644 --- a/main/src/main/scala/sbt/internal/LMCoursier.scala +++ b/main/src/main/scala/sbt/internal/LMCoursier.scala @@ -62,6 +62,8 @@ private[sbt] object LMCoursier { sbtClassifiers: Boolean ): Def.Initialize[Task[CoursierConfiguration]] = Def.taskDyn { + val s = streams.value + val log = s.log val resolversTask = if (sbtClassifiers) csrSbtResolvers @@ -99,8 +101,7 @@ private[sbt] object LMCoursier { val sbtScalaVersion = internalSbtScalaProvider.version() val sbtScalaOrganization = "org.scala-lang" // always assuming sbt uses mainline scala val classifiers = classifiersTask.value - val s = streams.value - Classpaths.warnResolversConflict(rs, s.log) + Classpaths.warnResolversConflict(rs, log) CoursierConfiguration() .withResolvers(rs.toVector) .withInterProjectDependencies(interProjectDependencies.toVector) @@ -124,7 +125,7 @@ private[sbt] object LMCoursier { .withCredentials(credentials) .withLogger(createLogger) .withCache(cache) - .withLog(s.log) + .withLog(log) } } From 944e955d063883de9192f3ad528749db228731d8 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 16:43:17 -0400 Subject: [PATCH 11/24] put sbtCp ahead of resolved JARs Ref https://github.com/sbt/sbt/pull/4443 Ref https://github.com/coursier/coursier/issues/1128 This is a workaround for Coursier not excluding sbt modules. --- main/src/main/scala/sbt/Defaults.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index fc760a954..90988dcca 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -1924,7 +1924,7 @@ object Classpaths { classpathTypes.value, update.value ) - if (isMeta && !force) mjars ++ sbtCp + if (isMeta && !force) sbtCp ++ mjars else mjars }, exportedProducts := trackedExportedProducts(TrackLevel.TrackAlways).value, From b47ed4e62a3f50c1b736bf18ed627772de19c37c Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 17:04:34 -0400 Subject: [PATCH 12/24] mark dependency-management/default-resolvers pending --- .../dependency-management/default-resolvers/{test => pending} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename sbt/src/repo-override-test/dependency-management/default-resolvers/{test => pending} (100%) diff --git a/sbt/src/repo-override-test/dependency-management/default-resolvers/test b/sbt/src/repo-override-test/dependency-management/default-resolvers/pending similarity index 100% rename from sbt/src/repo-override-test/dependency-management/default-resolvers/test rename to sbt/src/repo-override-test/dependency-management/default-resolvers/pending From 9a666b541851c2bddb49cc4cf517849ec40e8c85 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 01:07:27 -0400 Subject: [PATCH 13/24] use Ivy for some tests --- .../sbt-test/actions/external-doc/build.sbt | 3 +++ .../classloader-cache/snapshot/build.sbt | 3 ++- .../dependency-management/artifact/build.sbt | 8 +++++--- .../cache-classifiers/multi.sbt | 3 +++ .../cached-resolution-classifier/multi.sbt | 2 ++ .../cached-resolution-exclude/multi.sbt | 2 ++ .../circular-dependency/changes/multi.sbt | 2 ++ .../configurations-to-retrieve/build.sbt | 20 +++++++++---------- .../conflict-manager/build.sbt | 2 ++ .../default-artifact/build.sbt | 16 ++++++++------- .../default-artifact/repo/a/b/1.0.0/ivy.xml | 8 ++++---- .../ext-pom-classifier/build.sbt | 2 ++ .../extra/changes/UseColor.sbt | 2 ++ .../force-update-period/build.sbt | 2 ++ .../dependency-management/info/build.sbt | 2 ++ .../ivy-settings-a/build.sbt | 2 ++ .../ivy-settings-b/build.sbt | 2 ++ .../ivy-settings-c/build.sbt | 2 ++ .../ivy-settings-multi-a/build.sbt | 2 ++ .../ivy-settings-multi-b/build.sbt | 2 ++ .../changes/use-plugins.sbt | 2 ++ .../pom-classpaths/build.sbt | 2 ++ .../pom-parent-pom/build.sbt | 2 ++ .../retrieve-managed-sync/build.sbt | 2 ++ .../scala-organization/build.sbt | 2 ++ .../snapshot-resolution/build.sbt | 3 +++ .../test-artifact/cache.sbt | 4 ++-- .../dependency-management/url/build.sbt | 8 +++----- sbt/src/sbt-test/project/extra/build.sbt | 2 ++ 29 files changed, 82 insertions(+), 32 deletions(-) diff --git a/sbt/src/sbt-test/actions/external-doc/build.sbt b/sbt/src/sbt-test/actions/external-doc/build.sbt index 80ead271f..834ad7004 100644 --- a/sbt/src/sbt-test/actions/external-doc/build.sbt +++ b/sbt/src/sbt-test/actions/external-doc/build.sbt @@ -1,3 +1,6 @@ +// https://github.com/coursier/coursier/issues/1123 +ThisBuild / useCoursier := false + Seq( autoAPIMappings in ThisBuild := true, publishArtifact in (ThisBuild, packageDoc) := false, diff --git a/sbt/src/sbt-test/classloader-cache/snapshot/build.sbt b/sbt/src/sbt-test/classloader-cache/snapshot/build.sbt index 73ebc2aa9..a54646805 100644 --- a/sbt/src/sbt-test/classloader-cache/snapshot/build.sbt +++ b/sbt/src/sbt-test/classloader-cache/snapshot/build.sbt @@ -1,9 +1,10 @@ import java.nio.file.Files import java.nio.file.attribute.FileTime - import scala.collection.JavaConverters._ val rewriteIvy = inputKey[Unit]("Rewrite ivy directory") +ThisBuild / useCoursier := false + val snapshot = (project in file(".")).settings( name := "akka-test", scalaVersion := "2.12.8", diff --git a/sbt/src/sbt-test/dependency-management/artifact/build.sbt b/sbt/src/sbt-test/dependency-management/artifact/build.sbt index 5ba1238bf..6e51258c1 100644 --- a/sbt/src/sbt-test/dependency-management/artifact/build.sbt +++ b/sbt/src/sbt-test/dependency-management/artifact/build.sbt @@ -3,8 +3,10 @@ import sbt.internal.inc.classpath.ClasspathUtilities lazy val checkFull = taskKey[Unit]("") lazy val check = taskKey[Unit]("") -lazy val root = (project in file(".")). - settings( +ThisBuild / useCoursier := false + +lazy val root = (project in file(".")) + .settings( ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")), publishTo := Some(Resolver.file("Test Publish Repo", file("test-repo"))), resolvers += (baseDirectory { base => "Test Repo" at (base / "test-repo").toURI.toString }).value, @@ -34,7 +36,7 @@ def publishedID = org % artifactID % vers artifacts(mainArtifact) def retrieveID = org % "test-retrieve" % "2.0" // check that the test class is on the compile classpath, either because it was compiled or because it was properly retrieved -def checkTask(classpath: TaskKey[Classpath]) = Def task { +def checkTask(classpath: TaskKey[Classpath]) = Def.task { val deps = libraryDependencies.value val cp = (classpath in Compile).value.files val loader = ClasspathUtilities.toLoader(cp, scalaInstance.value.loader) diff --git a/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt b/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt index 75e55de1d..5c155cb2e 100644 --- a/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt +++ b/sbt/src/sbt-test/dependency-management/cache-classifiers/multi.sbt @@ -1,5 +1,8 @@ ThisBuild / scalaVersion := "2.12.8" +// TTL of Coursier is 24h +ThisBuild / useCoursier := false + def localCache = ivyPaths := IvyPaths(baseDirectory.value, Some((baseDirectory in ThisBuild).value / "ivy" / "cache")) diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt index 237f70774..e3057754e 100644 --- a/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt +++ b/sbt/src/sbt-test/dependency-management/cached-resolution-classifier/multi.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val check = taskKey[Unit]("Runs the check") def commonSettings: Seq[Def.Setting[_]] = diff --git a/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt b/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt index 7bca9158b..05659cdf1 100644 --- a/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt +++ b/sbt/src/sbt-test/dependency-management/cached-resolution-exclude/multi.sbt @@ -1,6 +1,8 @@ // https://github.com/sbt/sbt/issues/1649 lazy val check = taskKey[Unit]("Runs the check") +ThisBuild / useCoursier := false + def commonSettings: Seq[Def.Setting[_]] = Seq( ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((baseDirectory in LocalRootProject).value / "ivy-cache")), diff --git a/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt b/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt index c86962b24..ce0d2665f 100644 --- a/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt +++ b/sbt/src/sbt-test/dependency-management/circular-dependency/changes/multi.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val check = taskKey[Unit]("Runs the check") def commonSettings: Seq[Def.Setting[_]] = diff --git a/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt b/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt index e8a4aeabd..d03c0f295 100644 --- a/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt +++ b/sbt/src/sbt-test/dependency-management/configurations-to-retrieve/build.sbt @@ -1,11 +1,11 @@ -configurationsToRetrieve := Some(Vector(Compile)) +ThisBuild / useCoursier := false -retrieveManaged := true - -libraryDependencies += "log4j" % "log4j" % "1.2.16" % "compile" - -autoScalaLibrary := false - -managedDirectory := file("dependencies") - -retrievePattern := "[conf]/[artifact]-[revision](-[classifier]).[ext]" +lazy val root = (project in file(".")) + .settings( + configurationsToRetrieve := Some(Vector(Compile)), + retrieveManaged := true, + libraryDependencies += "log4j" % "log4j" % "1.2.16" % "compile", + autoScalaLibrary := false, + managedDirectory := file("dependencies"), + retrievePattern := "[conf]/[artifact]-[revision](-[classifier]).[ext]", + ) diff --git a/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt b/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt index b5cfdf07b..0dc7a72fc 100644 --- a/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt +++ b/sbt/src/sbt-test/dependency-management/conflict-manager/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + libraryDependencies ++= Seq( "org.spark-project" %% "spark-core" % "0.5.1", "log4j" % "log4j" % "1.2.17" diff --git a/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt b/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt index 829951e2e..c7fe3b549 100644 --- a/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt +++ b/sbt/src/sbt-test/dependency-management/default-artifact/build.sbt @@ -1,11 +1,13 @@ +ThisBuild / useCoursier := false + resolvers += Resolver.file("buggy", file("repo"))( - Patterns( - ivyPatterns = Vector("[organization]/[module]/[revision]/ivy.xml"), - artifactPatterns = Vector("[organization]/[module]/[revision]/[artifact].[ext]"), - isMavenCompatible = false, - descriptorOptional = true, - skipConsistencyCheck = true - ) + Patterns( + ivyPatterns = Vector("[organization]/[module]/[revision]/ivy.xml"), + artifactPatterns = Vector("[organization]/[module]/[revision]/[artifact].[ext]"), + isMavenCompatible = false, + descriptorOptional = true, + skipConsistencyCheck = true + ) ) libraryDependencies += "a" % "b" % "1.0.0" % "compile->runtime" artifacts(Artifact("b1", "jar", "jar")) diff --git a/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml b/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml index 53fe74fc9..165b4c192 100644 --- a/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml +++ b/sbt/src/sbt-test/dependency-management/default-artifact/repo/a/b/1.0.0/ivy.xml @@ -1,13 +1,13 @@ - a + a - + - - + + diff --git a/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt b/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt index cfbfbdb21..d3253a483 100644 --- a/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt +++ b/sbt/src/sbt-test/dependency-management/ext-pom-classifier/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val root = (project in file(".")) .settings( scalaVersion := "2.12.6", diff --git a/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt b/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt index fdb138835..2fc37decd 100644 --- a/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt +++ b/sbt/src/sbt-test/dependency-management/extra/changes/UseColor.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val root = (project in file(".")) .settings( organization := "org.example", diff --git a/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt b/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt index 1912a7fbb..11bcdf94e 100644 --- a/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt +++ b/sbt/src/sbt-test/dependency-management/force-update-period/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + libraryDependencies += "log4j" % "log4j" % "1.2.16" % "compile" autoScalaLibrary := false diff --git a/sbt/src/sbt-test/dependency-management/info/build.sbt b/sbt/src/sbt-test/dependency-management/info/build.sbt index 02b4f1447..185711816 100644 --- a/sbt/src/sbt-test/dependency-management/info/build.sbt +++ b/sbt/src/sbt-test/dependency-management/info/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + import scala.xml._ lazy val root = (project in file(".")). diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt index f2e37783d..aabb0862d 100644 --- a/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt +++ b/sbt/src/sbt-test/dependency-management/ivy-settings-a/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + externalIvySettings() externalIvyFile() diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt index eb3bde0f2..95d2dfa06 100644 --- a/sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt +++ b/sbt/src/sbt-test/dependency-management/ivy-settings-b/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + externalIvySettings() libraryDependencies += "org.scalacheck" % "scalacheck" % "1.5" diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt index c9beeb2f3..2e7cbd392 100644 --- a/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt +++ b/sbt/src/sbt-test/dependency-management/ivy-settings-c/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val commonSettings = Seq( autoScalaLibrary := false, scalaModuleInfo := None, diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt index d218debd4..12b354173 100644 --- a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt +++ b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-a/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val commonSettings = Seq( autoScalaLibrary := false, unmanagedJars in Compile ++= (scalaInstance map (_.allJars.toSeq)).value diff --git a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt index 0718f9071..94a522095 100644 --- a/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt +++ b/sbt/src/sbt-test/dependency-management/ivy-settings-multi-b/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val a = (project in file(".")). settings(externalIvySettings()) dependsOn(b) diff --git a/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt b/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt index 777b3f0ae..175234505 100644 --- a/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt +++ b/sbt/src/sbt-test/dependency-management/latest-local-plugin/changes/use-plugins.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + addSbtPlugin("org.example" % "def" % "latest.integration") resolvers ++= { diff --git a/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt b/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt index 2cef1bd25..8e57b688a 100644 --- a/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt +++ b/sbt/src/sbt-test/dependency-management/pom-classpaths/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + import complete._ import complete.DefaultParsers._ diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt b/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt index 458581d12..fa8e4369f 100644 --- a/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + val checkIvyXml = taskKey[Unit]("Checks the ivy.xml transform was correct") lazy val root = (project in file(".")). diff --git a/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt b/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt index 4568f6663..980fcc3cd 100644 --- a/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt +++ b/sbt/src/sbt-test/dependency-management/retrieve-managed-sync/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + retrieveManaged := true libraryDependencies += "log4j" % "log4j" % "1.2.16" diff --git a/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt b/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt index 82a7dce27..42d335c4d 100644 --- a/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt +++ b/sbt/src/sbt-test/dependency-management/scala-organization/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + organization := "org.dummy" scalaOrganization := "org.other" diff --git a/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt b/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt index b7d912223..be1d08d66 100644 --- a/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt +++ b/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt @@ -1,6 +1,9 @@ ThisBuild / organization := "com.example" ThisBuild / scalaVersion := "2.12.8" +// TTL is 24h so we can't detect the change +ThisBuild / useCoursier := false + def customIvyPaths: Seq[Def.Setting[_]] = Seq( ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some((baseDirectory in ThisBuild).value / "ivy-cache")) ) diff --git a/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt b/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt index 54bded6d5..f6fe7926d 100644 --- a/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt +++ b/sbt/src/sbt-test/dependency-management/test-artifact/cache.sbt @@ -1,10 +1,10 @@ +ThisBuild / useCoursier := false + ivyPaths := { val base = baseDirectory.value IvyPaths(base, Some(base / "ivy-cache")) } managedScalaInstance := false - autoScalaLibrary := false - crossPaths := false diff --git a/sbt/src/sbt-test/dependency-management/url/build.sbt b/sbt/src/sbt-test/dependency-management/url/build.sbt index 4e384ca23..f3b8f6fa2 100644 --- a/sbt/src/sbt-test/dependency-management/url/build.sbt +++ b/sbt/src/sbt-test/dependency-management/url/build.sbt @@ -11,14 +11,12 @@ lazy val root = (project in file(".")). def checkClasspath(conf: Configuration) = fullClasspath in conf map { cp => - try - { + try { val loader = ClasspathUtilities.toLoader(cp.files) Class.forName("org.jsoup.Jsoup", false, loader) () } - catch - { - case _: ClassNotFoundException => sys.error("Dependency not downloaded.") + catch { + case _: ClassNotFoundException => sys.error(s"could not instantiate org.jsoup.Jsoup: ${cp.files}") } } diff --git a/sbt/src/sbt-test/project/extra/build.sbt b/sbt/src/sbt-test/project/extra/build.sbt index 113584958..556d3e61b 100644 --- a/sbt/src/sbt-test/project/extra/build.sbt +++ b/sbt/src/sbt-test/project/extra/build.sbt @@ -1,3 +1,5 @@ +ThisBuild / useCoursier := false + lazy val root = (project in file(".")). settings( autoScalaLibrary := false, From 795601f5942dc0f37310c2447056d99335094004 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 18:02:07 -0400 Subject: [PATCH 14/24] mark dependency-management/url pending Ref https://github.com/coursier/coursier/issues/1127 --- sbt/src/sbt-test/dependency-management/url/{test => pending} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename sbt/src/sbt-test/dependency-management/url/{test => pending} (100%) diff --git a/sbt/src/sbt-test/dependency-management/url/test b/sbt/src/sbt-test/dependency-management/url/pending similarity index 100% rename from sbt/src/sbt-test/dependency-management/url/test rename to sbt/src/sbt-test/dependency-management/url/pending From 4b4359f7b1c6a123e4033ca95cea14daa9630380 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 19 Apr 2019 18:02:25 -0400 Subject: [PATCH 15/24] mark dependency-management/dynamic-revision pending --- .../dependency-management/dynamic-revision/{test => pending} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename sbt/src/sbt-test/dependency-management/dynamic-revision/{test => pending} (100%) diff --git a/sbt/src/sbt-test/dependency-management/dynamic-revision/test b/sbt/src/sbt-test/dependency-management/dynamic-revision/pending similarity index 100% rename from sbt/src/sbt-test/dependency-management/dynamic-revision/test rename to sbt/src/sbt-test/dependency-management/dynamic-revision/pending From ca53934941c58700f61d771ef7051602c56ad0cc Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 20 Apr 2019 02:12:01 -0400 Subject: [PATCH 16/24] fix csrCachePath --- main/src/main/scala/sbt/Defaults.scala | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 90988dcca..274c7d21a 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -2138,7 +2138,11 @@ object Classpaths { val defaultIvyCache = bootIvyHome(appConfiguration.value) if (old != coursier.cache.CacheDefaults.location) old else if (ip.ivyHome == defaultIvyCache) old - else ip.ivyHome.getOrElse(old) + else + ip.ivyHome match { + case Some(home) => home / "coursier-cache" + case _ => old + } }, dependencyCacheDirectory := { val st = state.value From 464325ad1dbc94e00a6a7107c3a1b0b6f328e370 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 20 Apr 2019 02:31:44 -0400 Subject: [PATCH 17/24] add a simpler version of snapshot-resolution Ivy is able to check for SNAPSHOT across different resolvers. Coursier seems to be sticky about the resolver within the TTL (24h). --- .../snapshot-local/build.sbt | 38 +++++++++++++++++++ .../snapshot-local/changes/BadCommon.scala | 2 + .../snapshot-local/changes/GoodCommon.scala | 3 ++ .../common/src/main/scala/Common.scala | 3 ++ .../dependent/src/main/scala/User.scala | 3 ++ .../dependency-management/snapshot-local/test | 21 ++++++++++ .../sbt/scriptedtest/ScriptedTests.scala | 1 + 7 files changed, 71 insertions(+) create mode 100644 sbt/src/sbt-test/dependency-management/snapshot-local/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/snapshot-local/changes/BadCommon.scala create mode 100644 sbt/src/sbt-test/dependency-management/snapshot-local/changes/GoodCommon.scala create mode 100644 sbt/src/sbt-test/dependency-management/snapshot-local/common/src/main/scala/Common.scala create mode 100644 sbt/src/sbt-test/dependency-management/snapshot-local/dependent/src/main/scala/User.scala create mode 100644 sbt/src/sbt-test/dependency-management/snapshot-local/test diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/build.sbt b/sbt/src/sbt-test/dependency-management/snapshot-local/build.sbt new file mode 100644 index 000000000..d87463465 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/snapshot-local/build.sbt @@ -0,0 +1,38 @@ +ThisBuild / organization := "com.example" +ThisBuild / scalaVersion := "2.12.8" + +def customIvyPaths: Seq[Def.Setting[_]] = Seq( + ivyPaths := IvyPaths((baseDirectory in ThisBuild).value, Some((baseDirectory in ThisBuild).value / "ivy-cache")) +) + +lazy val sharedResolver: Resolver = { + val r = Resolver.defaultShared + r withConfiguration (r.configuration withIsLocal false) + //MavenRepository("example-shared-repo", "file:///tmp/shared-maven-repo-bad-example") + //Resolver.file("example-shared-repo", repoDir)(Resolver.defaultPatterns) +} + +lazy val common = project + .settings(customIvyPaths) + .settings( + organization := "com.badexample", + name := "badexample", + version := "1.0-SNAPSHOT", + publishTo := Some(sharedResolver), + crossVersion := Disabled(), + publishMavenStyle := (sharedResolver match { + case repo: PatternsBasedRepository => repo.patterns.isMavenCompatible + case _: RawRepository => false // TODO - look deeper + case _: MavenRepository => true + case _ => false // TODO - Handle chain repository? + }) + ) + +lazy val dependent = project + .settings(customIvyPaths) + .settings( + // Ignore the inter-project resolver, so we force to look remotely. + resolvers += sharedResolver, + fullResolvers := fullResolvers.value.filterNot(_==projectResolver.value), + libraryDependencies += "com.badexample" % "badexample" % "1.0-SNAPSHOT" + ) diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/changes/BadCommon.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/BadCommon.scala new file mode 100644 index 000000000..4df4235d5 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/BadCommon.scala @@ -0,0 +1,2 @@ +object Common { +} \ No newline at end of file diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/changes/GoodCommon.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/GoodCommon.scala new file mode 100644 index 000000000..3f9b39258 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/snapshot-local/changes/GoodCommon.scala @@ -0,0 +1,3 @@ +object Common { + def name = "common" +} \ No newline at end of file diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/common/src/main/scala/Common.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/common/src/main/scala/Common.scala new file mode 100644 index 000000000..d6175ce12 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/snapshot-local/common/src/main/scala/Common.scala @@ -0,0 +1,3 @@ +object Common { + +} \ No newline at end of file diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/dependent/src/main/scala/User.scala b/sbt/src/sbt-test/dependency-management/snapshot-local/dependent/src/main/scala/User.scala new file mode 100644 index 000000000..8bc6103c8 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/snapshot-local/dependent/src/main/scala/User.scala @@ -0,0 +1,3 @@ +object User { + println(Common.name) +} \ No newline at end of file diff --git a/sbt/src/sbt-test/dependency-management/snapshot-local/test b/sbt/src/sbt-test/dependency-management/snapshot-local/test new file mode 100644 index 000000000..9fa3d37ba --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/snapshot-local/test @@ -0,0 +1,21 @@ +# Ivy is able to check for SNAPSHOT across different resolvers +# Coursier seems to be sticky about the resolver within the TTL + +> show dependent/fullResolvers + +# Validate that a bad dependency fails the compile +$ copy-file changes/BadCommon.scala common/src/main/scala/Common.scala +> common/publishLocal + +# Force dep resolution to be successful, then compilation to fail +> dependent/update +-> dependent/compile + +# Push new good change to the same repository. +$ copy-file changes/GoodCommon.scala common/src/main/scala/Common.scala +$ sleep 1000 +> common/publishLocal + +# This should compile now because Coursier checks for local update +> show dependent/update +> dependent/compile diff --git a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala index db1727a2a..bc71ce893 100644 --- a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala +++ b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala @@ -212,6 +212,7 @@ final class ScriptedTests( case "dependency-management/pom-parent-pom" => LauncherBased // tbd case "dependency-management/publish-to-maven-local-file" => LauncherBased // sbt/Package$ case "dependency-management/snapshot-resolution" => LauncherBased // tbd + case "dependency-management/snapshot-local" => LauncherBased // tbd case "dependency-management/test-artifact" => LauncherBased // sbt/Package$ case "dependency-management/transitive-version-range" => LauncherBased // tbd case "dependency-management/update-sbt-classifiers" => LauncherBased // tbd From 7658f147622a6ee3a3cdb116d0b4bd6f0c54f8a2 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sun, 21 Apr 2019 04:40:38 -0400 Subject: [PATCH 18/24] Add maven-plugin and test-jar to classpathTypes Ref https://github.com/sbt/sbt-native-packager/issues/1053 Ref https://github.com/coursier/coursier/issues/450 --- main/src/main/scala/sbt/Defaults.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 274c7d21a..ceb89bff2 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -215,7 +215,7 @@ object Defaults extends BuildCommon { crossVersion :== Disabled(), buildDependencies := Classpaths.constructBuildDependencies.value, version :== "0.1.0-SNAPSHOT", - classpathTypes :== Set("jar", "bundle") ++ CustomPomParser.JarPackagings, + classpathTypes :== Set("jar", "bundle", "maven-plugin", "test-jar") ++ CustomPomParser.JarPackagings, artifactClassifier :== None, checksums := Classpaths.bootChecksums(appConfiguration.value), conflictManager := ConflictManager.default, From 24db77edc5c30ce2f62c353d646b1b4c4204ad3b Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 22 Apr 2019 00:16:41 -0400 Subject: [PATCH 19/24] copy some tests from coursier/sbt-coursier Copying over sbt-coursier integration tests that do not depend on Coursier-specific things, but excercises sbt integration. --- .travis.yml | 1 + main/src/main/scala/sbt/Keys.scala | 2 +- .../aar-packaging/build.sbt | 6 + .../aar-packaging/src/main/scala/Main.scala | 6 + .../dependency-management/aar-packaging/test | 3 + .../auto-scala-library/build.sbt | 20 +++ .../auto-scala-library/test | 1 + .../classifier2/build.sbt | 2 + .../classifier2/src/main/scala/Main.scala | 18 +++ .../dependency-management/classifier2/test | 1 + .../exclude-dependencies2/build.sbt | 11 ++ .../exclude-dependencies2/coursier | Bin 0 -> 11811 bytes .../src/main/scala/Main.scala | 32 ++++ .../exclude-dependencies2/test | 5 + .../a/src/main/scala/A.scala | 6 + .../b/src/main/scala/Main.scala | 9 ++ .../build.sbt | 20 +++ .../fallback-dependencies-inter-project/test | 3 + .../global-plugins/build.sbt | 1 + .../global-plugins/global/plugins/metals.sbt | 2 + .../dependency-management/global-plugins/test | 2 + .../build.sbt | 3 + .../src/main/scala/Main.scala | 8 + .../hadoop-yarn-server-resourcemanager/test | 3 + .../a/src/main/scala/A.scala | 6 + .../b/src/main/scala/Main.scala | 14 ++ .../inter-project-resolvers/build.sbt | 24 +++ .../inter-project-resolvers/test | 3 + .../inter-project/a/src/main/scala/A.scala | 6 + .../inter-project/b/src/main/scala/Main.scala | 13 ++ .../inter-project/build.sbt | 32 ++++ .../dependency-management/inter-project/test | 3 + .../no-pom-artifact/build.sbt | 30 ++++ .../no-pom-artifact/test | 1 + .../dependency-management/profiles/build.sbt | 5 + .../dependency-management/profiles/output | 1 + .../profiles/src/main/scala/Main.scala | 19 +++ .../dependency-management/profiles/test | 3 + .../dependency-management/typelevel/build.sbt | 3 + .../typelevel/src/main/scala/Main.scala | 8 + .../dependency-management/typelevel/test | 3 + .../url-no-head/build.sbt | 3 + .../url-no-head/src/main/scala/Main.scala | 11 ++ .../dependency-management/url-no-head/test | 3 + .../version-interval/build.sbt | 35 +++++ .../version-interval/test | 1 + sbt/src/sbt-test/plugins/dotty/LICENSE | 25 ++++ sbt/src/sbt-test/plugins/dotty/README.md | 1 + sbt/src/sbt-test/plugins/dotty/build.sbt | 1 + .../plugins/dotty/project/build.properties | 3 + .../plugins/dotty/project/plugins.sbt | 1 + .../plugins/dotty/src/main/scala/Main.scala | 16 ++ .../dotty/src/main/scala/TraitParams.scala | 21 +++ sbt/src/sbt-test/plugins/dotty/test | 1 + .../plugins/neo-sbt-scalafmt/build.sbt | 2 + .../neo-sbt-scalafmt/project/extra.sbt | 1 + .../src/main/scala/Main.scala | 6 + .../sbt-test/plugins/neo-sbt-scalafmt/test | 1 + .../plugins/sbt-native-packager/build.sbt | 20 +++ .../sbt-native-packager/project/plugins.sbt | 1 + .../src/main/scala/Main.scala | 6 + .../sbt-test/plugins/sbt-native-packager/test | 5 + sbt/src/sbt-test/plugins/scala-js/build.sbt | 3 + .../plugins/scala-js/project/extra.sbt | 1 + sbt/src/sbt-test/plugins/scala-js/test | 1 + sbt/src/sbt-test/plugins/unidoc/build.sbt | 5 + .../sbt-test/plugins/unidoc/project/extra.sbt | 1 + .../plugins/unidoc/src/main/scala/Foo.scala | 3 + sbt/src/sbt-test/plugins/unidoc/test | 1 + .../sbt/scriptedtest/ScriptedTests.scala | 141 +++++++----------- 70 files changed, 570 insertions(+), 89 deletions(-) create mode 100644 sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/aar-packaging/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/aar-packaging/test create mode 100644 sbt/src/sbt-test/dependency-management/auto-scala-library/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/auto-scala-library/test create mode 100644 sbt/src/sbt-test/dependency-management/classifier2/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/classifier2/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/classifier2/test create mode 100644 sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt create mode 100755 sbt/src/sbt-test/dependency-management/exclude-dependencies2/coursier create mode 100644 sbt/src/sbt-test/dependency-management/exclude-dependencies2/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/exclude-dependencies2/test create mode 100644 sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/a/src/main/scala/A.scala create mode 100644 sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/b/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/test create mode 100644 sbt/src/sbt-test/dependency-management/global-plugins/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/global-plugins/global/plugins/metals.sbt create mode 100644 sbt/src/sbt-test/dependency-management/global-plugins/test create mode 100644 sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/test create mode 100644 sbt/src/sbt-test/dependency-management/inter-project-resolvers/a/src/main/scala/A.scala create mode 100644 sbt/src/sbt-test/dependency-management/inter-project-resolvers/b/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/inter-project-resolvers/test create mode 100644 sbt/src/sbt-test/dependency-management/inter-project/a/src/main/scala/A.scala create mode 100644 sbt/src/sbt-test/dependency-management/inter-project/b/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/inter-project/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/inter-project/test create mode 100644 sbt/src/sbt-test/dependency-management/no-pom-artifact/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/no-pom-artifact/test create mode 100644 sbt/src/sbt-test/dependency-management/profiles/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/profiles/output create mode 100644 sbt/src/sbt-test/dependency-management/profiles/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/profiles/test create mode 100644 sbt/src/sbt-test/dependency-management/typelevel/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/typelevel/test create mode 100644 sbt/src/sbt-test/dependency-management/url-no-head/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/url-no-head/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/dependency-management/url-no-head/test create mode 100644 sbt/src/sbt-test/dependency-management/version-interval/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/version-interval/test create mode 100644 sbt/src/sbt-test/plugins/dotty/LICENSE create mode 100644 sbt/src/sbt-test/plugins/dotty/README.md create mode 100644 sbt/src/sbt-test/plugins/dotty/build.sbt create mode 100644 sbt/src/sbt-test/plugins/dotty/project/build.properties create mode 100644 sbt/src/sbt-test/plugins/dotty/project/plugins.sbt create mode 100644 sbt/src/sbt-test/plugins/dotty/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/plugins/dotty/src/main/scala/TraitParams.scala create mode 100644 sbt/src/sbt-test/plugins/dotty/test create mode 100644 sbt/src/sbt-test/plugins/neo-sbt-scalafmt/build.sbt create mode 100644 sbt/src/sbt-test/plugins/neo-sbt-scalafmt/project/extra.sbt create mode 100644 sbt/src/sbt-test/plugins/neo-sbt-scalafmt/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/plugins/neo-sbt-scalafmt/test create mode 100644 sbt/src/sbt-test/plugins/sbt-native-packager/build.sbt create mode 100644 sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt create mode 100644 sbt/src/sbt-test/plugins/sbt-native-packager/src/main/scala/Main.scala create mode 100644 sbt/src/sbt-test/plugins/sbt-native-packager/test create mode 100644 sbt/src/sbt-test/plugins/scala-js/build.sbt create mode 100644 sbt/src/sbt-test/plugins/scala-js/project/extra.sbt create mode 100644 sbt/src/sbt-test/plugins/scala-js/test create mode 100644 sbt/src/sbt-test/plugins/unidoc/build.sbt create mode 100644 sbt/src/sbt-test/plugins/unidoc/project/extra.sbt create mode 100644 sbt/src/sbt-test/plugins/unidoc/src/main/scala/Foo.scala create mode 100644 sbt/src/sbt-test/plugins/unidoc/test diff --git a/.travis.yml b/.travis.yml index d37eb6afa..5f721d033 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,6 +17,7 @@ env: - SBT_CMD="scripted dependency-management/*2of4" - SBT_CMD="scripted dependency-management/*3of4" - SBT_CMD="scripted dependency-management/*4of4" + - SBT_CMD="scripted plugins/*" - SBT_CMD="scripted package/* reporter/* run/* project-load/*" - SBT_CMD="scripted project/*1of2" - SBT_CMD="scripted project/*2of2" diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index 52eff84cc..7464c2f0f 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -355,6 +355,7 @@ object Keys { val useCoursier = settingKey[Boolean]("Use Coursier for dependency resolution.").withRank(BSetting) val csrCachePath = settingKey[File]("Coursier cache path").withRank(CSetting) + val csrMavenProfiles = settingKey[Set[String]]("").withRank(CSetting) private[sbt] val csrConfiguration = taskKey[CoursierConfiguration]("General dependency management (Coursier) settings, such as the resolvers and options to use.").withRank(DTask) private[sbt] val csrProject = taskKey[coursier.core.Project]("") private[sbt] val csrResolvers = taskKey[Seq[Resolver]]("") @@ -362,7 +363,6 @@ object Keys { private[sbt] val csrSbtResolvers = taskKey[Seq[Resolver]]("Resolvers used for sbt artifacts.") private[sbt] val csrInterProjectDependencies = taskKey[Seq[coursier.core.Project]]("Projects the current project depends on, possibly transitively") private[sbt] val csrFallbackDependencies = taskKey[Seq[FallbackDependency]]("") - private[sbt] val csrMavenProfiles = settingKey[Set[String]]("") private[sbt] val csrLogger = taskKey[Option[CacheLogger]]("") private[sbt] val csrExtraCredentials = taskKey[Seq[coursier.credentials.Credentials]]("") private[sbt] val csrPublications = taskKey[Seq[(coursier.core.Configuration, coursier.core.Publication)]]("") diff --git a/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt b/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt new file mode 100644 index 000000000..97b5c2cff --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt @@ -0,0 +1,6 @@ +scalaVersion := "2.11.8" + +libraryDependencies += ("com.rengwuxian.materialedittext" % "library" % "2.1.4") + .exclude("com.android.support", "support-v4") + .exclude("com.android.support", "support-annotations") + .exclude("com.android.support", "appcompat-v7") diff --git a/sbt/src/sbt-test/dependency-management/aar-packaging/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/aar-packaging/src/main/scala/Main.scala new file mode 100644 index 000000000..61295349d --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/aar-packaging/src/main/scala/Main.scala @@ -0,0 +1,6 @@ +import java.io.File +import java.nio.file.Files + +object Main extends App { + Files.write(new File("output").toPath, "OK".getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/aar-packaging/test b/sbt/src/sbt-test/dependency-management/aar-packaging/test new file mode 100644 index 000000000..2182f57b0 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/aar-packaging/test @@ -0,0 +1,3 @@ +$ delete output +> run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/auto-scala-library/build.sbt b/sbt/src/sbt-test/dependency-management/auto-scala-library/build.sbt new file mode 100644 index 000000000..20969e7e5 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/auto-scala-library/build.sbt @@ -0,0 +1,20 @@ +autoScalaLibrary := false +libraryDependencies += "com.chuusai" % "shapeless_2.12" % "2.3.2" + +val checkScalaLibrary = TaskKey[Unit]("checkScalaLibrary") + +checkScalaLibrary := { + val scalaLibsJars = managedClasspath + .in(Compile) + .value + .map(_.data.getName) + .filter(_.startsWith("scala-library")) + .sorted + val expectedScalaLibsJars = Seq( + "scala-library-2.12.0.jar" + ) + assert( + scalaLibsJars == expectedScalaLibsJars, + s"$scalaLibsJars != $expectedScalaLibsJars" + ) +} diff --git a/sbt/src/sbt-test/dependency-management/auto-scala-library/test b/sbt/src/sbt-test/dependency-management/auto-scala-library/test new file mode 100644 index 000000000..f56f5a75e --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/auto-scala-library/test @@ -0,0 +1 @@ +> checkScalaLibrary diff --git a/sbt/src/sbt-test/dependency-management/classifier2/build.sbt b/sbt/src/sbt-test/dependency-management/classifier2/build.sbt new file mode 100644 index 000000000..21f304a4b --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/classifier2/build.sbt @@ -0,0 +1,2 @@ +scalaVersion := "2.11.8" +libraryDependencies += "org.jclouds.api" % "nova" % "1.5.9" classifier "tests" diff --git a/sbt/src/sbt-test/dependency-management/classifier2/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/classifier2/src/main/scala/Main.scala new file mode 100644 index 000000000..b1a40797d --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/classifier2/src/main/scala/Main.scala @@ -0,0 +1,18 @@ +import java.io.File +import java.nio.file.Files + +import scala.util.Try + +object Main extends App { + + def classFound(clsName: String) = Try( + Thread.currentThread() + .getContextClassLoader() + .loadClass(clsName) + ).toOption.nonEmpty + + val name = "org.jclouds.openstack.nova.functions.ParseServerFromJsonResponseTest" + val classifierTest = classFound(name) + + assert(classifierTest, s"Couldn't find $name") +} diff --git a/sbt/src/sbt-test/dependency-management/classifier2/test b/sbt/src/sbt-test/dependency-management/classifier2/test new file mode 100644 index 000000000..62ea636c1 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/classifier2/test @@ -0,0 +1 @@ +> run diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt new file mode 100644 index 000000000..627874b74 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt @@ -0,0 +1,11 @@ + +scalaVersion := "2.11.8" + +organization := "io.get-coursier.test" +name := "sbt-coursier-exclude-dependencies" +version := "0.1.0-SNAPSHOT" + +libraryDependencies += "com.github.alexarchambault" %% "argonaut-shapeless_6.1" % "1.0.0-RC1" + +excludeDependencies += sbt.ExclusionRule("com.chuusai", "shapeless_2.11") +excludeDependencies += "io.argonaut" %% "argonaut" diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/coursier b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/coursier new file mode 100755 index 0000000000000000000000000000000000000000..6cada6f8bfeee885fead8a7cbfbeab130ad6b10f GIT binary patch literal 11811 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 run +$ exists output +> publishLocal +$ exec java -jar coursier launch io.get-coursier.test:sbt-coursier-exclude-dependencies_2.11:0.1.0-SNAPSHOT diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/a/src/main/scala/A.scala b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/a/src/main/scala/A.scala new file mode 100644 index 000000000..954405774 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/a/src/main/scala/A.scala @@ -0,0 +1,6 @@ + +case class A(msg: String) + +object A { + def default = A("OK") +} diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/b/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/b/src/main/scala/Main.scala new file mode 100644 index 000000000..59bb6d372 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/b/src/main/scala/Main.scala @@ -0,0 +1,9 @@ +import java.io.File +import java.nio.file.Files + +object Main extends App { + + val msg = shapeless.Generic[A].to(A.default).head + + Files.write(new File("output").toPath, msg.getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt new file mode 100644 index 000000000..93f7aa347 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt @@ -0,0 +1,20 @@ + +lazy val a = project + .settings(sharedSettings) + .settings( + libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.234" from "https://oss.sonatype.org/content/repositories/releases/com/chuusai/shapeless_2.11/2.3.1/shapeless_2.11-2.3.1.jar" + ) + +lazy val b = project + .dependsOn(a) + .settings(sharedSettings) + +lazy val root = project + .in(file(".")) + .aggregate(a, b) + .settings(sharedSettings) + + +lazy val sharedSettings = Seq( + scalaVersion := "2.11.8" +) diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/test b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/test new file mode 100644 index 000000000..ea53e1abb --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/test @@ -0,0 +1,3 @@ +$ delete output +> b/run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/global-plugins/build.sbt b/sbt/src/sbt-test/dependency-management/global-plugins/build.sbt new file mode 100644 index 000000000..5642f168f --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/global-plugins/build.sbt @@ -0,0 +1 @@ +scalaVersion := "2.12.8" diff --git a/sbt/src/sbt-test/dependency-management/global-plugins/global/plugins/metals.sbt b/sbt/src/sbt-test/dependency-management/global-plugins/global/plugins/metals.sbt new file mode 100644 index 000000000..8aae08736 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/global-plugins/global/plugins/metals.sbt @@ -0,0 +1,2 @@ +addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % "1.2.5") +addSbtPlugin("org.scalameta" % "sbt-metals" % "0.4.4") diff --git a/sbt/src/sbt-test/dependency-management/global-plugins/test b/sbt/src/sbt-test/dependency-management/global-plugins/test new file mode 100644 index 000000000..67a8b1ff1 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/global-plugins/test @@ -0,0 +1,2 @@ +> metalsEnable +> bloopInstall diff --git a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt new file mode 100644 index 000000000..983b4325e --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt @@ -0,0 +1,3 @@ +scalaVersion := "2.11.8" + +libraryDependencies += "org.apache.hadoop" % "hadoop-yarn-server-resourcemanager" % "2.7.1" diff --git a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/src/main/scala/Main.scala new file mode 100644 index 000000000..032874759 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/src/main/scala/Main.scala @@ -0,0 +1,8 @@ +import java.io.File +import java.nio.file.Files + +import org.apache.zookeeper.ZooKeeper + +object Main extends App { + Files.write(new File("output").toPath, classOf[ZooKeeper].getSimpleName.getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/test b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/test new file mode 100644 index 000000000..2182f57b0 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/test @@ -0,0 +1,3 @@ +$ delete output +> run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/a/src/main/scala/A.scala b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/a/src/main/scala/A.scala new file mode 100644 index 000000000..954405774 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/a/src/main/scala/A.scala @@ -0,0 +1,6 @@ + +case class A(msg: String) + +object A { + def default = A("OK") +} diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/b/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/b/src/main/scala/Main.scala new file mode 100644 index 000000000..f2c112187 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/b/src/main/scala/Main.scala @@ -0,0 +1,14 @@ +import java.io.File +import java.nio.file.Files + +import scalaz.stream._ +import scalaz.concurrent.Task + +object Main extends App { + + val pch = Process.constant((i:Int) => Task.now(())).take(3) + val count = Process.constant(1).toSource.to(pch).runLog.run.size + assert(count == 3) + + Files.write(new File("output").toPath, A.default.msg.getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt new file mode 100644 index 000000000..d375b4ab6 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt @@ -0,0 +1,24 @@ + +lazy val a = project + .settings(sharedSettings) + .settings( + resolvers += "Scalaz Bintray Repo" at "https://dl.bintray.com/scalaz/releases" + ) + +lazy val b = project + .dependsOn(a) + .settings(sharedSettings) + .settings( + // resolver added in inter-project dependency only - should still be fine + libraryDependencies += "org.scalaz.stream" %% "scalaz-stream" % "0.7.1a" + ) + +lazy val root = project + .in(file(".")) + .aggregate(a, b) + .settings(sharedSettings) + + +lazy val sharedSettings = Seq( + scalaVersion := "2.11.8" +) diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/test b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/test new file mode 100644 index 000000000..ea53e1abb --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/test @@ -0,0 +1,3 @@ +$ delete output +> b/run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/inter-project/a/src/main/scala/A.scala b/sbt/src/sbt-test/dependency-management/inter-project/a/src/main/scala/A.scala new file mode 100644 index 000000000..5308caa95 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project/a/src/main/scala/A.scala @@ -0,0 +1,6 @@ + +object A { + + def msg = "OK" + +} diff --git a/sbt/src/sbt-test/dependency-management/inter-project/b/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/inter-project/b/src/main/scala/Main.scala new file mode 100644 index 000000000..624039aa5 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project/b/src/main/scala/Main.scala @@ -0,0 +1,13 @@ +import java.io.File +import java.nio.file.Files + +import argonaut._, Argonaut._, ArgonautShapeless._ + +object Main extends App { + + case class CC(i: Int, s: String) + + val msg = CC(2, A.msg).asJson.spaces2 + + Files.write(new File("output").toPath, msg.getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/inter-project/build.sbt b/sbt/src/sbt-test/dependency-management/inter-project/build.sbt new file mode 100644 index 000000000..ca35179d2 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project/build.sbt @@ -0,0 +1,32 @@ + +lazy val sharedSettings = Seq( + scalaVersion := "2.11.8" +) + +/** Module with the same Maven coordinates as shapeless 2.3.1 */ +lazy val `shapeless-mock` = project + .settings(sharedSettings) + .settings( + organization := "com.chuusai", + name := "shapeless", + version := "2.3.1" + ) + +lazy val a = project + .settings(sharedSettings) + .settings( + organization := "com.pany", + name := "a", + version := "0.0.1" + ) + +/** Transitively depends on the - real - shapeless 2.3.1 */ +lazy val b = project + .dependsOn(a) + .settings(sharedSettings) + .settings( + organization := "com.pany", + name := "b", + version := "0.0.1", + libraryDependencies += "com.github.alexarchambault" %% "argonaut-shapeless_6.2" % "1.2.0-M1" + ) diff --git a/sbt/src/sbt-test/dependency-management/inter-project/test b/sbt/src/sbt-test/dependency-management/inter-project/test new file mode 100644 index 000000000..ea53e1abb --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/inter-project/test @@ -0,0 +1,3 @@ +$ delete output +> b/run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/no-pom-artifact/build.sbt b/sbt/src/sbt-test/dependency-management/no-pom-artifact/build.sbt new file mode 100644 index 000000000..7465c34d7 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/no-pom-artifact/build.sbt @@ -0,0 +1,30 @@ + +lazy val noPomCheck = TaskKey[Unit]("noPomCheck") + +noPomCheck := { + + val log = streams.value.log + + val configReport = update.value + .configuration(Compile) + .getOrElse { + throw new Exception( + "compile configuration not found in update report" + ) + } + + val artifacts = configReport + .modules + .flatMap(_.artifacts) + .map(_._1) + + val pomArtifacts = artifacts + .filter { a => + a.`type` == "pom" && a.classifier.isEmpty + } + + for (a <- pomArtifacts) + log.error(s"Found POM artifact $a") + + assert(pomArtifacts.isEmpty) +} diff --git a/sbt/src/sbt-test/dependency-management/no-pom-artifact/test b/sbt/src/sbt-test/dependency-management/no-pom-artifact/test new file mode 100644 index 000000000..67b4dc666 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/no-pom-artifact/test @@ -0,0 +1 @@ +> noPomCheck diff --git a/sbt/src/sbt-test/dependency-management/profiles/build.sbt b/sbt/src/sbt-test/dependency-management/profiles/build.sbt new file mode 100644 index 000000000..0dde988c3 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/profiles/build.sbt @@ -0,0 +1,5 @@ +ThisBuild / scalaVersion := "2.11.8" + +Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat +libraryDependencies += "org.apache.spark" %% "spark-sql" % "1.6.2" +csrMavenProfiles += "hadoop-2.6" diff --git a/sbt/src/sbt-test/dependency-management/profiles/output b/sbt/src/sbt-test/dependency-management/profiles/output new file mode 100644 index 000000000..a0aba9318 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/profiles/output @@ -0,0 +1 @@ +OK \ No newline at end of file diff --git a/sbt/src/sbt-test/dependency-management/profiles/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/profiles/src/main/scala/Main.scala new file mode 100644 index 000000000..9ac86fe34 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/profiles/src/main/scala/Main.scala @@ -0,0 +1,19 @@ +import java.io.File +import java.nio.file.Files + +object Main extends App { + val p = new java.util.Properties + p.load( + Thread.currentThread() + .getContextClassLoader + .getResource("common-version-info.properties") + .openStream() + ) + + val hadoopVersion = p.getProperty("version") + Console.err.println(s"Found hadoop version $hadoopVersion") + + assert(hadoopVersion == "2.6.0") + + Files.write(new File("output").toPath, "OK".getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/profiles/test b/sbt/src/sbt-test/dependency-management/profiles/test new file mode 100644 index 000000000..2182f57b0 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/profiles/test @@ -0,0 +1,3 @@ +$ delete output +> run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/typelevel/build.sbt b/sbt/src/sbt-test/dependency-management/typelevel/build.sbt new file mode 100644 index 000000000..6a6bacd66 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/typelevel/build.sbt @@ -0,0 +1,3 @@ +scalaOrganization := "org.typelevel" +scalaVersion := "2.11.7" +scalacOptions += "-Xexperimental" diff --git a/sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala new file mode 100644 index 000000000..32ca74bee --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala @@ -0,0 +1,8 @@ +import java.io.File +import java.nio.file.Files + +object Main extends App { + val n': 2.type = 2 + + Files.write(new File("output").toPath, "OK".getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/typelevel/test b/sbt/src/sbt-test/dependency-management/typelevel/test new file mode 100644 index 000000000..2182f57b0 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/typelevel/test @@ -0,0 +1,3 @@ +$ delete output +> run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt b/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt new file mode 100644 index 000000000..bba414888 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt @@ -0,0 +1,3 @@ +scalaVersion := "2.11.8" + +libraryDependencies += "ccl.northwestern.edu" % "netlogo" % "5.3.1" % "provided" from s"https://github.com/NetLogo/NetLogo/releases/download/5.3.1/NetLogo.jar" diff --git a/sbt/src/sbt-test/dependency-management/url-no-head/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/url-no-head/src/main/scala/Main.scala new file mode 100644 index 000000000..d75f66eaf --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/url-no-head/src/main/scala/Main.scala @@ -0,0 +1,11 @@ +import java.io.File +import java.nio.file.Files + +object Main extends App { + // Not using directly the NetLogo 5.x lib, which seems to depend on Scala 2.9 + // Can't find a way to check that NetLogo.jar is in the classpath + // These don't work, even with fork := true: + // assert(Thread.currentThread.getContextClassLoader.getResource("org/nlogo/nvm/Task.class") != null) + // Thread.currentThread.getContextClassLoader.getResource("org/nlogo/nvm/Task.class") + Files.write(new File("output").toPath, "OK".getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/dependency-management/url-no-head/test b/sbt/src/sbt-test/dependency-management/url-no-head/test new file mode 100644 index 000000000..2182f57b0 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/url-no-head/test @@ -0,0 +1,3 @@ +$ delete output +> run +$ exists output diff --git a/sbt/src/sbt-test/dependency-management/version-interval/build.sbt b/sbt/src/sbt-test/dependency-management/version-interval/build.sbt new file mode 100644 index 000000000..efeaf236e --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/version-interval/build.sbt @@ -0,0 +1,35 @@ + +libraryDependencies += "org.json4s" %% "json4s-native" % "[3.3.0,3.5.0)" + + +lazy val actualVersionCheck = taskKey[Unit]("") + +actualVersionCheck := { + + val log = streams.value.log + + val configReport = update.value + .configuration(Compile) + .getOrElse { + sys.error("compile configuration not found in update report") + } + + val modules = configReport + .modules + .map(_.module) + + assert(modules.nonEmpty) + assert(modules.exists(_.name.startsWith("json4s-native"))) + + val wrongModules = modules.filter { m => + val v = m.revision + v.contains("[") || v.contains("]") || v.contains("(") || v.contains(")") + } + + if (wrongModules.nonEmpty) { + log.error("Found unexpected intervals in revisions") + for (m <- wrongModules) + log.error(s" ${m.organization}:${m.name}:${m.revision}") + sys.error("Found intervals in revisions") + } +} diff --git a/sbt/src/sbt-test/dependency-management/version-interval/test b/sbt/src/sbt-test/dependency-management/version-interval/test new file mode 100644 index 000000000..99803d595 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/version-interval/test @@ -0,0 +1 @@ +> actualVersionCheck diff --git a/sbt/src/sbt-test/plugins/dotty/LICENSE b/sbt/src/sbt-test/plugins/dotty/LICENSE new file mode 100644 index 000000000..728844ee3 --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2015 The dotty-example-project contributors. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/sbt/src/sbt-test/plugins/dotty/README.md b/sbt/src/sbt-test/plugins/dotty/README.md new file mode 100644 index 000000000..e476c5c1d --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/README.md @@ -0,0 +1 @@ +Cut-n-pasted from https://github.com/lampepfl/dotty-example-project/tree/a753b14e281bbaa6c69f26298913ad6feba969c7 diff --git a/sbt/src/sbt-test/plugins/dotty/build.sbt b/sbt/src/sbt-test/plugins/dotty/build.sbt new file mode 100644 index 000000000..e38070b5e --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/build.sbt @@ -0,0 +1 @@ +scalaVersion := "0.13.0-RC1" diff --git a/sbt/src/sbt-test/plugins/dotty/project/build.properties b/sbt/src/sbt-test/plugins/dotty/project/build.properties new file mode 100644 index 000000000..16dc090c5 --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/project/build.properties @@ -0,0 +1,3 @@ +# sbt-coursier scripted tests: required, as we default to sbt 1.0.3, +# but sbt-dotty requires sbt >= 1.2.7 +sbt.version=1.2.7 diff --git a/sbt/src/sbt-test/plugins/dotty/project/plugins.sbt b/sbt/src/sbt-test/plugins/dotty/project/plugins.sbt new file mode 100644 index 000000000..b5de60fc6 --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/project/plugins.sbt @@ -0,0 +1 @@ +addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.3.0") diff --git a/sbt/src/sbt-test/plugins/dotty/src/main/scala/Main.scala b/sbt/src/sbt-test/plugins/dotty/src/main/scala/Main.scala new file mode 100644 index 000000000..8a44ae4ef --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/src/main/scala/Main.scala @@ -0,0 +1,16 @@ + +object Main { + + def main(args: Array[String]): Unit = { + + runExample("Trait Params")(TraitParams.test) + + } + + private def runExample(name: String)(f: => Unit) = { + println(Console.MAGENTA + s"$name example:" + Console.RESET) + f + println() + } + +} diff --git a/sbt/src/sbt-test/plugins/dotty/src/main/scala/TraitParams.scala b/sbt/src/sbt-test/plugins/dotty/src/main/scala/TraitParams.scala new file mode 100644 index 000000000..5d4409971 --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/src/main/scala/TraitParams.scala @@ -0,0 +1,21 @@ +/** + * Trait Parameters: https://dotty.epfl.ch/docs/reference/other-new-features/trait-parameters.html + */ +object TraitParams { + + trait Base(val msg: String) + class A extends Base("Hello") + class B extends Base("Dotty!") + + // Union types only exist in Dotty, so there's no chance that this will accidentally be compiled with Scala 2 + private def printMessages(msgs: (A | B)*) = println(msgs.map(_.msg).mkString(" ")) + + def test: Unit = { + + printMessages(new A, new B) + + // Sanity check the classpath: this won't run if the dotty jar is not present. + val x: Int => Int = z => z + x(1) + } +} diff --git a/sbt/src/sbt-test/plugins/dotty/test b/sbt/src/sbt-test/plugins/dotty/test new file mode 100644 index 000000000..62ea636c1 --- /dev/null +++ b/sbt/src/sbt-test/plugins/dotty/test @@ -0,0 +1 @@ +> run diff --git a/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/build.sbt b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/build.sbt new file mode 100644 index 000000000..6dcc058c2 --- /dev/null +++ b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/build.sbt @@ -0,0 +1,2 @@ +scalaVersion := "2.12.2" +enablePlugins(ScalafmtPlugin) diff --git a/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/project/extra.sbt b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/project/extra.sbt new file mode 100644 index 000000000..4aa3881f4 --- /dev/null +++ b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/project/extra.sbt @@ -0,0 +1 @@ +addSbtPlugin("com.lucidchart" % "sbt-scalafmt" % "1.15") diff --git a/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/src/main/scala/Main.scala b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/src/main/scala/Main.scala new file mode 100644 index 000000000..61295349d --- /dev/null +++ b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/src/main/scala/Main.scala @@ -0,0 +1,6 @@ +import java.io.File +import java.nio.file.Files + +object Main extends App { + Files.write(new File("output").toPath, "OK".getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/test b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/test new file mode 100644 index 000000000..97b42a4f4 --- /dev/null +++ b/sbt/src/sbt-test/plugins/neo-sbt-scalafmt/test @@ -0,0 +1 @@ +> scalafmt diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/build.sbt b/sbt/src/sbt-test/plugins/sbt-native-packager/build.sbt new file mode 100644 index 000000000..4c3343012 --- /dev/null +++ b/sbt/src/sbt-test/plugins/sbt-native-packager/build.sbt @@ -0,0 +1,20 @@ +ThisBuild / scalaVersion := "2.12.8" + +name := "hello" +enablePlugins(JavaAppPackaging) + +lazy val check = taskKey[Unit]("") + +check := { + val cmd = "target/universal/stage/bin/hello" + val cmd0 = + if (sys.props("os.name").toLowerCase(java.util.Locale.ROOT).contains("windows")) + cmd + ".bat" + else + cmd + val b = new ProcessBuilder(cmd0) + b.inheritIO() + val p = b.start() + val retCode = p.waitFor() + assert(retCode == 0, s"Command $cmd returned code $retCode") +} diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt b/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt new file mode 100644 index 000000000..44cfb3f47 --- /dev/null +++ b/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt @@ -0,0 +1 @@ +addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.3") diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/src/main/scala/Main.scala b/sbt/src/sbt-test/plugins/sbt-native-packager/src/main/scala/Main.scala new file mode 100644 index 000000000..61295349d --- /dev/null +++ b/sbt/src/sbt-test/plugins/sbt-native-packager/src/main/scala/Main.scala @@ -0,0 +1,6 @@ +import java.io.File +import java.nio.file.Files + +object Main extends App { + Files.write(new File("output").toPath, "OK".getBytes("UTF-8")) +} diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/test b/sbt/src/sbt-test/plugins/sbt-native-packager/test new file mode 100644 index 000000000..bb563a74f --- /dev/null +++ b/sbt/src/sbt-test/plugins/sbt-native-packager/test @@ -0,0 +1,5 @@ +$ delete output +> stage +> check +$ exists output +$ delete output diff --git a/sbt/src/sbt-test/plugins/scala-js/build.sbt b/sbt/src/sbt-test/plugins/scala-js/build.sbt new file mode 100644 index 000000000..2c43a4b30 --- /dev/null +++ b/sbt/src/sbt-test/plugins/scala-js/build.sbt @@ -0,0 +1,3 @@ +scalaVersion := "2.12.3" +enablePlugins(ScalaJSPlugin) +libraryDependencies += "org.scala-js" %%% "scalajs-java-time" % "0.2.2" diff --git a/sbt/src/sbt-test/plugins/scala-js/project/extra.sbt b/sbt/src/sbt-test/plugins/scala-js/project/extra.sbt new file mode 100644 index 000000000..4f6de4f49 --- /dev/null +++ b/sbt/src/sbt-test/plugins/scala-js/project/extra.sbt @@ -0,0 +1 @@ +addSbtPlugin("org.scala-js" % "sbt-scalajs" % "0.6.19") diff --git a/sbt/src/sbt-test/plugins/scala-js/test b/sbt/src/sbt-test/plugins/scala-js/test new file mode 100644 index 000000000..103bd8d2f --- /dev/null +++ b/sbt/src/sbt-test/plugins/scala-js/test @@ -0,0 +1 @@ +> update diff --git a/sbt/src/sbt-test/plugins/unidoc/build.sbt b/sbt/src/sbt-test/plugins/unidoc/build.sbt new file mode 100644 index 000000000..3aa46422f --- /dev/null +++ b/sbt/src/sbt-test/plugins/unidoc/build.sbt @@ -0,0 +1,5 @@ +scalaVersion := "2.12.1" +scalacOptions += "-Xfatal-warnings" // required for the test + +enablePlugins(ScalaUnidocPlugin) +autoAPIMappings := true diff --git a/sbt/src/sbt-test/plugins/unidoc/project/extra.sbt b/sbt/src/sbt-test/plugins/unidoc/project/extra.sbt new file mode 100644 index 000000000..ade7d89a5 --- /dev/null +++ b/sbt/src/sbt-test/plugins/unidoc/project/extra.sbt @@ -0,0 +1 @@ +addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.4.2") diff --git a/sbt/src/sbt-test/plugins/unidoc/src/main/scala/Foo.scala b/sbt/src/sbt-test/plugins/unidoc/src/main/scala/Foo.scala new file mode 100644 index 000000000..b5ba8323e --- /dev/null +++ b/sbt/src/sbt-test/plugins/unidoc/src/main/scala/Foo.scala @@ -0,0 +1,3 @@ + +/** Default instances for Scala's [[scala.concurrent.Future Future]]. */ +class Foo diff --git a/sbt/src/sbt-test/plugins/unidoc/test b/sbt/src/sbt-test/plugins/unidoc/test new file mode 100644 index 000000000..7439923b4 --- /dev/null +++ b/sbt/src/sbt-test/plugins/unidoc/test @@ -0,0 +1 @@ +> unidoc diff --git a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala index bc71ce893..a3fb7cf27 100644 --- a/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala +++ b/scripted-sbt-redux/src/main/scala/sbt/scriptedtest/ScriptedTests.scala @@ -167,94 +167,59 @@ final class ScriptedTests( import RemoteSbtCreatorKind._ val (group, name) = testName s"$group/$name" match { - case "actions/add-alias" => LauncherBased // sbt/Package$ - case "actions/cross-multiproject" => LauncherBased // tbd - case "actions/external-doc" => LauncherBased // sbt/Package$ - case "actions/input-task" => LauncherBased // sbt/Package$ - case "actions/input-task-dyn" => LauncherBased // sbt/Package$ - case "classloader-cache/akka-actor-system" => LauncherBased // sbt/Package$ - case "classloader-cache/jni" => LauncherBased // sbt/Package$ - case "classloader-cache/library-mismatch" => LauncherBased // sbt/Package$ - case "classloader-cache/runtime-layers" => LauncherBased // sbt/Package$ - case "classloader-cache/package-private" => LauncherBased // sbt/Package$ - case "compiler-project/dotty-compiler-plugin" => LauncherBased // sbt/Package$ - case "compiler-project/run-test" => LauncherBased // sbt/Package$ - case "compiler-project/src-dep-plugin" => LauncherBased // sbt/Package$ - case "dependency-management/artifact" => LauncherBased // tbd - case "dependency-management/cache-classifiers" => LauncherBased // tbd - case "dependency-management/cache-local" => LauncherBased // tbd - case "dependency-management/cache-resolver" => LauncherBased // sbt/Package$ - case "dependency-management/cache-update" => LauncherBased // tbd - case "dependency-management/cached-resolution-circular" => LauncherBased // tbd - case "dependency-management/cached-resolution-classifier" => LauncherBased // tbd - case "dependency-management/cached-resolution-configurations" => LauncherBased // tbd - case "dependency-management/cached-resolution-conflicts" => LauncherBased // tbd - case "dependency-management/cached-resolution-exclude" => LauncherBased // tbd - case "dependency-management/cached-resolution-force" => LauncherBased // tbd - case "dependency-management/cached-resolution-interproj" => LauncherBased // tbd - case "dependency-management/cached-resolution-overrides" => LauncherBased // tbd - case "dependency-management/chainresolver" => LauncherBased // tbd - case "dependency-management/circular-dependency" => LauncherBased // tbd - case "dependency-management/classifier" => LauncherBased // tbd - case "dependency-management/default-resolvers" => LauncherBased // tbd - case "dependency-management/deliver-artifacts" => LauncherBased // tbd - case "dependency-management/exclude-transitive" => LauncherBased // tbd - case "dependency-management/extra" => LauncherBased // tbd - case "dependency-management/force" => LauncherBased // tbd - case "dependency-management/info" => LauncherBased // tbd - case "dependency-management/inline-dependencies-a" => LauncherBased // tbd - case "dependency-management/ivy-settings-c" => LauncherBased // sbt/Package$ - case "dependency-management/latest-local-plugin" => LauncherBased // sbt/Package$ - case "dependency-management/metadata-only-resolver" => LauncherBased // tbd - case "dependency-management/no-file-fails-publish" => LauncherBased // tbd - case "dependency-management/override" => LauncherBased // tbd - case "dependency-management/parent-publish" => LauncherBased // sbt/Package$ - case "dependency-management/pom-parent-pom" => LauncherBased // tbd - case "dependency-management/publish-to-maven-local-file" => LauncherBased // sbt/Package$ - case "dependency-management/snapshot-resolution" => LauncherBased // tbd - case "dependency-management/snapshot-local" => LauncherBased // tbd - case "dependency-management/test-artifact" => LauncherBased // sbt/Package$ - case "dependency-management/transitive-version-range" => LauncherBased // tbd - case "dependency-management/update-sbt-classifiers" => LauncherBased // tbd - case "dependency-management/url" => LauncherBased // tbd - case "java/argfile" => LauncherBased // sbt/Package$ - case "java/cross" => LauncherBased // sbt/Package$ - case "java/basic" => LauncherBased // sbt/Package$ - case "java/varargs-main" => LauncherBased // sbt/Package$ - case "package/lazy-name" => LauncherBased // sbt/Package$ - case "package/manifest" => LauncherBased // sbt/Package$ - case "package/resources" => LauncherBased // sbt/Package$ - case "project/Class.forName" => LauncherBased // sbt/Package$ - case "project/binary-plugin" => LauncherBased // sbt/Package$ - case "project/default-settings" => LauncherBased // sbt/Package$ - case "project/extra" => LauncherBased // tbd - case "project/flatten" => LauncherBased // sbt/Package$ - case "project/generated-root-no-publish" => LauncherBased // tbd - case "project/giter8-plugin" => LauncherBased // tbd - case "project/lib" => LauncherBased // sbt/Package$ - case "project/scripted-plugin" => LauncherBased // tbd - case "project/scripted-skip-incompatible" => LauncherBased // sbt/Package$ - case "project/session-update-from-cmd" => LauncherBased // tbd - case "project/transitive-plugins" => LauncherBased // tbd - case "run/awt" => LauncherBased // sbt/Package$ - case "run/classpath" => LauncherBased // sbt/Package$ - case "run/daemon" => LauncherBased // sbt/Package$ - case "run/daemon-exit" => LauncherBased // sbt/Package$ - case "run/error" => LauncherBased // sbt/Package$ - case "run/fork" => LauncherBased // sbt/Package$ - case "run/fork-loader" => LauncherBased // sbt/Package$ - case "run/non-local-main" => LauncherBased // sbt/Package$ - case "run/spawn" => LauncherBased // sbt/Package$ - case "run/spawn-exit" => LauncherBased // sbt/Package$ - case "source-dependencies/binary" => LauncherBased // sbt/Package$ - case "source-dependencies/export-jars" => LauncherBased // sbt/Package$ - case "source-dependencies/implicit-search" => LauncherBased // sbt/Package$ - case "source-dependencies/java-basic" => LauncherBased // sbt/Package$ - case "source-dependencies/less-inter-inv" => LauncherBased // sbt/Package$ - case "source-dependencies/less-inter-inv-java" => LauncherBased // sbt/Package$ - case "source-dependencies/linearization" => LauncherBased // sbt/Package$ - case "source-dependencies/named" => LauncherBased // sbt/Package$ - case "source-dependencies/specialized" => LauncherBased // sbt/Package$ + case "actions/add-alias" => LauncherBased // sbt/Package$ + case "actions/cross-multiproject" => LauncherBased // tbd + case "actions/external-doc" => LauncherBased // sbt/Package$ + case "actions/input-task" => LauncherBased // sbt/Package$ + case "actions/input-task-dyn" => LauncherBased // sbt/Package$ + case "classloader-cache/akka-actor-system" => LauncherBased // sbt/Package$ + case "classloader-cache/jni" => LauncherBased // sbt/Package$ + case "classloader-cache/library-mismatch" => LauncherBased // sbt/Package$ + case "classloader-cache/runtime-layers" => LauncherBased // sbt/Package$ + case "classloader-cache/package-private" => LauncherBased // sbt/Package$ + case "compiler-project/dotty-compiler-plugin" => LauncherBased // sbt/Package$ + case "compiler-project/run-test" => LauncherBased // sbt/Package$ + case "compiler-project/src-dep-plugin" => LauncherBased // sbt/Package$ + case gn if gn.startsWith("dependency-management/") => LauncherBased // sbt/Package$ + case gn if gn.startsWith("plugins/") => LauncherBased // sbt/Package$ + case "java/argfile" => LauncherBased // sbt/Package$ + case "java/cross" => LauncherBased // sbt/Package$ + case "java/basic" => LauncherBased // sbt/Package$ + case "java/varargs-main" => LauncherBased // sbt/Package$ + case "package/lazy-name" => LauncherBased // sbt/Package$ + case "package/manifest" => LauncherBased // sbt/Package$ + case "package/resources" => LauncherBased // sbt/Package$ + case "project/Class.forName" => LauncherBased // sbt/Package$ + case "project/binary-plugin" => LauncherBased // sbt/Package$ + case "project/default-settings" => LauncherBased // sbt/Package$ + case "project/extra" => LauncherBased // tbd + case "project/flatten" => LauncherBased // sbt/Package$ + case "project/generated-root-no-publish" => LauncherBased // tbd + case "project/giter8-plugin" => LauncherBased // tbd + case "project/lib" => LauncherBased // sbt/Package$ + case "project/scripted-plugin" => LauncherBased // tbd + case "project/scripted-skip-incompatible" => LauncherBased // sbt/Package$ + case "project/session-update-from-cmd" => LauncherBased // tbd + case "project/transitive-plugins" => LauncherBased // tbd + case "run/awt" => LauncherBased // sbt/Package$ + case "run/classpath" => LauncherBased // sbt/Package$ + case "run/daemon" => LauncherBased // sbt/Package$ + case "run/daemon-exit" => LauncherBased // sbt/Package$ + case "run/error" => LauncherBased // sbt/Package$ + case "run/fork" => LauncherBased // sbt/Package$ + case "run/fork-loader" => LauncherBased // sbt/Package$ + case "run/non-local-main" => LauncherBased // sbt/Package$ + case "run/spawn" => LauncherBased // sbt/Package$ + case "run/spawn-exit" => LauncherBased // sbt/Package$ + case "source-dependencies/binary" => LauncherBased // sbt/Package$ + case "source-dependencies/export-jars" => LauncherBased // sbt/Package$ + case "source-dependencies/implicit-search" => LauncherBased // sbt/Package$ + case "source-dependencies/java-basic" => LauncherBased // sbt/Package$ + case "source-dependencies/less-inter-inv" => LauncherBased // sbt/Package$ + case "source-dependencies/less-inter-inv-java" => LauncherBased // sbt/Package$ + case "source-dependencies/linearization" => LauncherBased // sbt/Package$ + case "source-dependencies/named" => LauncherBased // sbt/Package$ + case "source-dependencies/specialized" => LauncherBased // sbt/Package$ case "tests/test-cross" => LauncherBased // the sbt metabuild classpath leaks into the test interface classloader in older versions of sbt case _ => RunFromSourceBased From 258a8930a5707ba5888a003e1f799ce8ef546b33 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 22 Apr 2019 10:54:39 -0400 Subject: [PATCH 20/24] bump Scala 2.11 to 2.11.12 because we use JDK 11 --- .../dependency-management/aar-packaging/build.sbt | 2 +- .../dependency-management/chainresolver/build.sbt | 2 +- .../sbt-test/dependency-management/classifier2/build.sbt | 2 +- .../compiler-bridge-binary/build.sbt | 4 ++-- .../dependency-management/exclude-dependencies/build.sbt | 4 ++-- .../exclude-dependencies2/build.sbt | 2 +- .../fallback-dependencies-inter-project/build.sbt | 9 +-------- .../hadoop-yarn-server-resourcemanager/build.sbt | 2 +- .../inter-project-resolvers/build.sbt | 9 +-------- .../dependency-management/inter-project/build.sbt | 8 +------- .../sbt-test/dependency-management/profiles/build.sbt | 2 +- .../scala-organization-version-check/build.sbt | 2 +- .../scala-version-check-exempt/build.sbt | 2 +- .../transitive-version-range/build.sbt | 5 +++-- .../sbt-test/dependency-management/typelevel/build.sbt | 3 --- .../typelevel/src/main/scala/Main.scala | 8 -------- sbt/src/sbt-test/dependency-management/typelevel/test | 3 --- .../update-sbt-classifiers/build.sbt | 2 +- .../sbt-test/dependency-management/url-no-head/build.sbt | 2 +- .../plugins/sbt-native-packager/project/plugins.sbt | 2 +- 20 files changed, 21 insertions(+), 54 deletions(-) delete mode 100644 sbt/src/sbt-test/dependency-management/typelevel/build.sbt delete mode 100644 sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala delete mode 100644 sbt/src/sbt-test/dependency-management/typelevel/test diff --git a/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt b/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt index 97b5c2cff..67a22204e 100644 --- a/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt +++ b/sbt/src/sbt-test/dependency-management/aar-packaging/build.sbt @@ -1,4 +1,4 @@ -scalaVersion := "2.11.8" +ThisBuild / scalaVersion := "2.11.12" libraryDependencies += ("com.rengwuxian.materialedittext" % "library" % "2.1.4") .exclude("com.android.support", "support-v4") diff --git a/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt b/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt index e63b0921e..8906939b2 100644 --- a/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt +++ b/sbt/src/sbt-test/dependency-management/chainresolver/build.sbt @@ -3,7 +3,7 @@ lazy val check = taskKey[Unit]("Runs the check") def commonSettings: Seq[Def.Setting[_]] = Seq( ivyPaths := IvyPaths( (baseDirectory in ThisBuild).value, Some((target in LocalRootProject).value / "ivy-cache")), - scalaVersion in ThisBuild := "2.11.7", + scalaVersion in ThisBuild := "2.11.12", organization in ThisBuild := "com.example", version in ThisBuild := "0.1.0-SNAPSHOT", autoScalaLibrary := false, diff --git a/sbt/src/sbt-test/dependency-management/classifier2/build.sbt b/sbt/src/sbt-test/dependency-management/classifier2/build.sbt index 21f304a4b..133599913 100644 --- a/sbt/src/sbt-test/dependency-management/classifier2/build.sbt +++ b/sbt/src/sbt-test/dependency-management/classifier2/build.sbt @@ -1,2 +1,2 @@ -scalaVersion := "2.11.8" +ThisBuild / scalaVersion := "2.11.12" libraryDependencies += "org.jclouds.api" % "nova" % "1.5.9" classifier "tests" diff --git a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt index 6f8d12fb0..391353a8e 100644 --- a/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt +++ b/sbt/src/sbt-test/dependency-management/compiler-bridge-binary/build.sbt @@ -1,9 +1,9 @@ -ThisBuild / scalaVersion := "2.12.6" +ThisBuild / scalaVersion := "2.12.8" lazy val check = taskKey[Unit]("") // We can't use "%%" here without breaking the "== bridgeModule" check below -val bridgeModule = "org.scala-sbt" % s"compiler-bridge_2.12" % "1.2.1" +val bridgeModule = "org.scala-sbt" % s"compiler-bridge_2.12" % "1.3.0-M3" libraryDependencies += bridgeModule % Configurations.ScalaTool diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt index b7f1ef752..15e4df170 100644 --- a/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt +++ b/sbt/src/sbt-test/dependency-management/exclude-dependencies/build.sbt @@ -9,14 +9,14 @@ val repatchTwitter = "com.eed3si9n" %% "repatch-twitter-core" % "dispatch0.11.1_ lazy val a = (project in file("a")). settings( - scalaVersion := "2.11.4", + scalaVersion := "2.11.12", libraryDependencies += dispatch, excludeDependencies += "org.slf4j" ) lazy val b = (project in file("b")). settings( - scalaVersion := "2.11.4", + scalaVersion := "2.11.12", libraryDependencies += repatchTwitter, excludeDependencies += "net.databinder.dispatch" %% "dispatch-core" ) diff --git a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt index 627874b74..7b75a187f 100644 --- a/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt +++ b/sbt/src/sbt-test/dependency-management/exclude-dependencies2/build.sbt @@ -1,5 +1,5 @@ -scalaVersion := "2.11.8" +ThisBuild / scalaVersion := "2.11.12" organization := "io.get-coursier.test" name := "sbt-coursier-exclude-dependencies" diff --git a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt index 93f7aa347..98731216b 100644 --- a/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt +++ b/sbt/src/sbt-test/dependency-management/fallback-dependencies-inter-project/build.sbt @@ -1,20 +1,13 @@ +ThisBuild / scalaVersion := "2.11.12" lazy val a = project - .settings(sharedSettings) .settings( libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.234" from "https://oss.sonatype.org/content/repositories/releases/com/chuusai/shapeless_2.11/2.3.1/shapeless_2.11-2.3.1.jar" ) lazy val b = project .dependsOn(a) - .settings(sharedSettings) lazy val root = project .in(file(".")) .aggregate(a, b) - .settings(sharedSettings) - - -lazy val sharedSettings = Seq( - scalaVersion := "2.11.8" -) diff --git a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt index 983b4325e..8e7c4a097 100644 --- a/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt +++ b/sbt/src/sbt-test/dependency-management/hadoop-yarn-server-resourcemanager/build.sbt @@ -1,3 +1,3 @@ -scalaVersion := "2.11.8" +ThisBuild / scalaVersion := "2.11.12" libraryDependencies += "org.apache.hadoop" % "hadoop-yarn-server-resourcemanager" % "2.7.1" diff --git a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt index d375b4ab6..625c7c0d2 100644 --- a/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt +++ b/sbt/src/sbt-test/dependency-management/inter-project-resolvers/build.sbt @@ -1,13 +1,12 @@ +ThisBuild / scalaVersion := "2.11.12" lazy val a = project - .settings(sharedSettings) .settings( resolvers += "Scalaz Bintray Repo" at "https://dl.bintray.com/scalaz/releases" ) lazy val b = project .dependsOn(a) - .settings(sharedSettings) .settings( // resolver added in inter-project dependency only - should still be fine libraryDependencies += "org.scalaz.stream" %% "scalaz-stream" % "0.7.1a" @@ -16,9 +15,3 @@ lazy val b = project lazy val root = project .in(file(".")) .aggregate(a, b) - .settings(sharedSettings) - - -lazy val sharedSettings = Seq( - scalaVersion := "2.11.8" -) diff --git a/sbt/src/sbt-test/dependency-management/inter-project/build.sbt b/sbt/src/sbt-test/dependency-management/inter-project/build.sbt index ca35179d2..800464482 100644 --- a/sbt/src/sbt-test/dependency-management/inter-project/build.sbt +++ b/sbt/src/sbt-test/dependency-management/inter-project/build.sbt @@ -1,11 +1,7 @@ - -lazy val sharedSettings = Seq( - scalaVersion := "2.11.8" -) +ThisBuild / scalaVersion := "2.11.12" /** Module with the same Maven coordinates as shapeless 2.3.1 */ lazy val `shapeless-mock` = project - .settings(sharedSettings) .settings( organization := "com.chuusai", name := "shapeless", @@ -13,7 +9,6 @@ lazy val `shapeless-mock` = project ) lazy val a = project - .settings(sharedSettings) .settings( organization := "com.pany", name := "a", @@ -23,7 +18,6 @@ lazy val a = project /** Transitively depends on the - real - shapeless 2.3.1 */ lazy val b = project .dependsOn(a) - .settings(sharedSettings) .settings( organization := "com.pany", name := "b", diff --git a/sbt/src/sbt-test/dependency-management/profiles/build.sbt b/sbt/src/sbt-test/dependency-management/profiles/build.sbt index 0dde988c3..33b6f2f72 100644 --- a/sbt/src/sbt-test/dependency-management/profiles/build.sbt +++ b/sbt/src/sbt-test/dependency-management/profiles/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.11.8" +ThisBuild / scalaVersion := "2.11.12" Compile / classLoaderLayeringStrategy := ClassLoaderLayeringStrategy.Flat libraryDependencies += "org.apache.spark" %% "spark-sql" % "1.6.2" diff --git a/sbt/src/sbt-test/dependency-management/scala-organization-version-check/build.sbt b/sbt/src/sbt-test/dependency-management/scala-organization-version-check/build.sbt index efb198677..c969842f7 100644 --- a/sbt/src/sbt-test/dependency-management/scala-organization-version-check/build.sbt +++ b/sbt/src/sbt-test/dependency-management/scala-organization-version-check/build.sbt @@ -2,7 +2,7 @@ scalaOrganization := "org.other" scalaArtifacts += "thing" -scalaVersion := "2.11.8" +ThisBuild / scalaVersion := "2.11.12" libraryDependencies ++= Seq( "org.other" % "thing" % "1.2.3", diff --git a/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt b/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt index 6f66bc879..540318393 100644 --- a/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt +++ b/sbt/src/sbt-test/dependency-management/scala-version-check-exempt/build.sbt @@ -1,6 +1,6 @@ // https://github.com/sbt/sbt/issues/1818 -scalaVersion := "2.11.5" +ThisBuild / scalaVersion := "2.11.12" libraryDependencies += "org.scala-lang" %% "scala-actors-migration" % "1.1.0" libraryDependencies += "org.scala-lang" %% "scala-pickling" % "0.9.1" diff --git a/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt b/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt index 0f8c84c1e..6e3467d19 100644 --- a/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt +++ b/sbt/src/sbt-test/dependency-management/transitive-version-range/build.sbt @@ -1,5 +1,6 @@ +ThisBuild / scalaVersion := "2.11.12" + organization := "com.test" name := "maven-version-range-bug" version := "1.0.0-SNAPSHOT" -scalaVersion := "2.11.6" -libraryDependencies += "com.amazonaws" % "aws-java-sdk" % "1.7.8.1" \ No newline at end of file +libraryDependencies += "com.amazonaws" % "aws-java-sdk" % "1.7.8.1" diff --git a/sbt/src/sbt-test/dependency-management/typelevel/build.sbt b/sbt/src/sbt-test/dependency-management/typelevel/build.sbt deleted file mode 100644 index 6a6bacd66..000000000 --- a/sbt/src/sbt-test/dependency-management/typelevel/build.sbt +++ /dev/null @@ -1,3 +0,0 @@ -scalaOrganization := "org.typelevel" -scalaVersion := "2.11.7" -scalacOptions += "-Xexperimental" diff --git a/sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala b/sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala deleted file mode 100644 index 32ca74bee..000000000 --- a/sbt/src/sbt-test/dependency-management/typelevel/src/main/scala/Main.scala +++ /dev/null @@ -1,8 +0,0 @@ -import java.io.File -import java.nio.file.Files - -object Main extends App { - val n': 2.type = 2 - - Files.write(new File("output").toPath, "OK".getBytes("UTF-8")) -} diff --git a/sbt/src/sbt-test/dependency-management/typelevel/test b/sbt/src/sbt-test/dependency-management/typelevel/test deleted file mode 100644 index 2182f57b0..000000000 --- a/sbt/src/sbt-test/dependency-management/typelevel/test +++ /dev/null @@ -1,3 +0,0 @@ -$ delete output -> run -$ exists output diff --git a/sbt/src/sbt-test/dependency-management/update-sbt-classifiers/build.sbt b/sbt/src/sbt-test/dependency-management/update-sbt-classifiers/build.sbt index 36f0b199b..cde5ebc0e 100644 --- a/sbt/src/sbt-test/dependency-management/update-sbt-classifiers/build.sbt +++ b/sbt/src/sbt-test/dependency-management/update-sbt-classifiers/build.sbt @@ -1,4 +1,4 @@ -scalaVersion := "2.11.11" +ThisBuild / scalaVersion := "2.11.12" ivyConfiguration := { throw new RuntimeException("updateSbtClassifiers should use updateSbtClassifiers / ivyConfiguration") diff --git a/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt b/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt index bba414888..9fdc2681d 100644 --- a/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt +++ b/sbt/src/sbt-test/dependency-management/url-no-head/build.sbt @@ -1,3 +1,3 @@ -scalaVersion := "2.11.8" +ThisBuild / scalaVersion := "2.11.12" libraryDependencies += "ccl.northwestern.edu" % "netlogo" % "5.3.1" % "provided" from s"https://github.com/NetLogo/NetLogo/releases/download/5.3.1/NetLogo.jar" diff --git a/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt b/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt index 44cfb3f47..414d83d34 100644 --- a/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt +++ b/sbt/src/sbt-test/plugins/sbt-native-packager/project/plugins.sbt @@ -1 +1 @@ -addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.3") +addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.20") From f354a626c71e22766b716b2fc643ec1561db6f4b Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 26 Apr 2019 17:33:14 -0400 Subject: [PATCH 21/24] use lm-coursier-shaded This uses lm-coursier-shaded, and follows along the changes in https://github.com/coursier/sbt-coursier/pull/58. --- build.sbt | 2 +- main/src/main/scala/sbt/Defaults.scala | 16 +- main/src/main/scala/sbt/Keys.scala | 12 +- main/src/main/scala/sbt/Project.scala | 22 + .../scala/sbt/internal/BuildStructure.scala | 6 + .../main/scala/sbt/internal/LMCoursier.scala | 443 +----------------- .../sbt/internal/LibraryManagement.scala | 2 +- .../CoursierArtifactsTasks.scala | 157 +++++++ .../CoursierInputsTasks.scala | 235 ++++++++++ .../CoursierRepositoriesTasks.scala | 111 +++++ .../internal/librarymanagement/IvyXml.scala | 20 +- project/Dependencies.scala | 4 +- 12 files changed, 570 insertions(+), 460 deletions(-) create mode 100644 main/src/main/scala/sbt/internal/librarymanagement/CoursierArtifactsTasks.scala create mode 100644 main/src/main/scala/sbt/internal/librarymanagement/CoursierInputsTasks.scala create mode 100644 main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala diff --git a/build.sbt b/build.sbt index f517ad661..2bec08fac 100644 --- a/build.sbt +++ b/build.sbt @@ -594,7 +594,7 @@ lazy val mainProj = (project in file("main")) scalaXml.value ++ Seq(launcherInterface) ++ log4jDependencies ++ - Seq(scalaCacheCaffeine, lmCousier) + Seq(scalaCacheCaffeine, lmCoursierShaded) }, Compile / scalacOptions -= "-Xfatal-warnings", managedSourceDirectories in Compile += diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index ceb89bff2..4e0a41e65 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -12,7 +12,7 @@ import java.net.{ URI, URL, URLClassLoader } import java.util.Optional import java.util.concurrent.{ Callable, TimeUnit } -import coursier.core.{ Configuration => CConfiguration } +import lmcoursier.definitions.{ Configuration => CConfiguration } import org.apache.ivy.core.module.descriptor.ModuleDescriptor import org.apache.ivy.core.module.id.ModuleRevisionId import sbt.Def.{ Initialize, ScopedKey, Setting, SettingsDefinition } @@ -230,7 +230,7 @@ object Defaults extends BuildCommon { // coursier settings csrExtraCredentials :== Nil, csrLogger :== None, - csrCachePath :== coursier.cache.CacheDefaults.location, + csrCachePath :== LMCoursier.defaultCacheLocation, csrMavenProfiles :== Set.empty, ) @@ -2136,7 +2136,7 @@ object Classpaths { val old = csrCachePath.value val ip = ivyPaths.value val defaultIvyCache = bootIvyHome(appConfiguration.value) - if (old != coursier.cache.CacheDefaults.location) old + if (old != LMCoursier.defaultCacheLocation) old else if (ip.ivyHome == defaultIvyCache) old else ip.ivyHome match { @@ -2406,13 +2406,13 @@ object Classpaths { } tag (Tags.Update, Tags.Network)).value, ) ) ++ Seq( - csrProject := LMCoursier.coursierProjectTask.value, + csrProject := CoursierInputsTasks.coursierProjectTask.value, csrConfiguration := LMCoursier.coursierConfigurationTask(false, false).value, - csrResolvers := LMCoursier.coursierResolversTask.value, - csrRecursiveResolvers := LMCoursier.coursierRecursiveResolversTask.value, + csrResolvers := CoursierRepositoriesTasks.coursierResolversTask.value, + csrRecursiveResolvers := CoursierRepositoriesTasks.coursierRecursiveResolversTask.value, csrSbtResolvers := LMCoursier.coursierSbtResolversTask.value, - csrInterProjectDependencies := LMCoursier.coursierInterProjectDependenciesTask.value, - csrFallbackDependencies := LMCoursier.coursierFallbackDependenciesTask.value, + csrInterProjectDependencies := CoursierInputsTasks.coursierInterProjectDependenciesTask.value, + csrFallbackDependencies := CoursierInputsTasks.coursierFallbackDependenciesTask.value, ) ++ IvyXml.generateIvyXmlSettings() ++ LMCoursier.publicationsSetting(Seq(Compile, Test).map(c => c -> CConfiguration(c.name))) diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index 7464c2f0f..500e02f7c 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -32,8 +32,8 @@ import sbt.librarymanagement.ivy.{ Credentials, IvyConfiguration, IvyPaths, Upda import sbt.testing.Framework import sbt.util.{ Level, Logger } import xsbti.compile._ -import coursier.cache.CacheLogger -import coursier.lmcoursier.{ CoursierConfiguration, FallbackDependency } +import lmcoursier.definitions.CacheLogger +import lmcoursier.{ CoursierConfiguration, FallbackDependency } import scala.concurrent.duration.{ Duration, FiniteDuration } import scala.xml.{ NodeSeq, Node => XNode } @@ -357,15 +357,15 @@ object Keys { val csrCachePath = settingKey[File]("Coursier cache path").withRank(CSetting) val csrMavenProfiles = settingKey[Set[String]]("").withRank(CSetting) private[sbt] val csrConfiguration = taskKey[CoursierConfiguration]("General dependency management (Coursier) settings, such as the resolvers and options to use.").withRank(DTask) - private[sbt] val csrProject = taskKey[coursier.core.Project]("") + private[sbt] val csrProject = taskKey[lmcoursier.definitions.Project]("") private[sbt] val csrResolvers = taskKey[Seq[Resolver]]("") private[sbt] val csrRecursiveResolvers = taskKey[Seq[Resolver]]("Resolvers of the current project, plus those of all from its inter-dependency projects") private[sbt] val csrSbtResolvers = taskKey[Seq[Resolver]]("Resolvers used for sbt artifacts.") - private[sbt] val csrInterProjectDependencies = taskKey[Seq[coursier.core.Project]]("Projects the current project depends on, possibly transitively") + private[sbt] val csrInterProjectDependencies = taskKey[Seq[lmcoursier.definitions.Project]]("Projects the current project depends on, possibly transitively") private[sbt] val csrFallbackDependencies = taskKey[Seq[FallbackDependency]]("") private[sbt] val csrLogger = taskKey[Option[CacheLogger]]("") - private[sbt] val csrExtraCredentials = taskKey[Seq[coursier.credentials.Credentials]]("") - private[sbt] val csrPublications = taskKey[Seq[(coursier.core.Configuration, coursier.core.Publication)]]("") + private[sbt] val csrExtraCredentials = taskKey[Seq[lmcoursier.credentials.Credentials]]("") + private[sbt] val csrPublications = taskKey[Seq[(lmcoursier.definitions.Configuration, lmcoursier.definitions.Publication)]]("") val internalConfigurationMap = settingKey[Configuration => Configuration]("Maps configurations to the actual configuration used to define the classpath.").withRank(CSetting) val classpathConfiguration = taskKey[Configuration]("The configuration used to define the classpath.").withRank(CTask) diff --git a/main/src/main/scala/sbt/Project.scala b/main/src/main/scala/sbt/Project.scala index 9a55a760a..d570c3432 100755 --- a/main/src/main/scala/sbt/Project.scala +++ b/main/src/main/scala/sbt/Project.scala @@ -758,6 +758,28 @@ object Project extends ProjectExtra { def updateExtraBuilds(s: State, f: List[URI] => List[URI]): State = setExtraBuilds(s, f(extraBuilds(s))) + // used by Coursier integration + private[sbt] def transitiveInterDependencies( + state: State, + projectRef: ProjectRef + ): Seq[ProjectRef] = { + def dependencies(map: Map[ProjectRef, Seq[ProjectRef]], id: ProjectRef): Set[ProjectRef] = { + def helper(map: Map[ProjectRef, Seq[ProjectRef]], acc: Set[ProjectRef]): Set[ProjectRef] = + if (acc.exists(map.contains)) { + val (kept, rem) = map.partition { case (k, _) => acc(k) } + helper(rem, acc ++ kept.valuesIterator.flatten) + } else + acc + helper(map - id, map.getOrElse(id, Nil).toSet) + } + val allProjectsDeps: Map[ProjectRef, Seq[ProjectRef]] = + (for { + (p, ref) <- Project.structure(state).allProjectPairs + } yield ref -> p.dependencies.map(_.project)).toMap + val deps = dependencies(allProjectsDeps.toMap, projectRef) + Project.structure(state).allProjectRefs.filter(p => deps(p)) + } + object LoadAction extends Enumeration { val Return, Current, Plugins = Value } diff --git a/main/src/main/scala/sbt/internal/BuildStructure.scala b/main/src/main/scala/sbt/internal/BuildStructure.scala index a1b556fe5..309e72844 100644 --- a/main/src/main/scala/sbt/internal/BuildStructure.scala +++ b/main/src/main/scala/sbt/internal/BuildStructure.scala @@ -38,6 +38,12 @@ final class BuildStructure( case (build, unit) => refs(build, unit.defined.values.toSeq) } def allProjectRefs(build: URI): Seq[ProjectRef] = refs(build, allProjects(build)) + def allProjectPairs: Seq[(ResolvedProject, ProjectRef)] = + for { + (build, unit) <- units.toSeq + p: ResolvedProject <- unit.defined.values.toSeq + } yield (p, ProjectRef(build, p.id)) + val extra: BuildUtil[ResolvedProject] = BuildUtil(root, units, index.keyIndex, data) private[this] def refs(build: URI, projects: Seq[ResolvedProject]): Seq[ProjectRef] = projects.map { p => diff --git a/main/src/main/scala/sbt/internal/LMCoursier.scala b/main/src/main/scala/sbt/internal/LMCoursier.scala index 57c3505b4..7dec70905 100644 --- a/main/src/main/scala/sbt/internal/LMCoursier.scala +++ b/main/src/main/scala/sbt/internal/LMCoursier.scala @@ -8,54 +8,15 @@ package sbt package internal -import coursier.core.{ - Attributes => CAttributes, - Classifier, - Configuration => CConfiguration, - Dependency => CDependency, - Extension => CExtension, - Info => CInfo, - Module, - ModuleName, - Organization => COrganization, - Project => CProject, - Publication => CPublication, - Type => CType -} -import coursier.credentials.DirectCredentials -import coursier.lmcoursier._ -import sbt.io.IO +import java.io.File +import lmcoursier.definitions.{ Classifier, Configuration => CConfiguration } +import lmcoursier._ import sbt.librarymanagement._ import Keys._ -import sbt.librarymanagement.ivy.{ - FileCredentials, - Credentials, - DirectCredentials => IvyDirectCredentials -} -import sbt.ScopeFilter.Make._ -import scala.collection.JavaConverters._ +import sbt.internal.librarymanagement.{ CoursierArtifactsTasks, CoursierInputsTasks } private[sbt] object LMCoursier { - - def coursierProjectTask: Def.Initialize[sbt.Task[CProject]] = - Def.task { - val auOpt = apiURL.value - val proj = Inputs.coursierProject( - projectID.value, - allDependencies.value, - excludeDependencies.value, - ivyConfigurations.value, - scalaVersion.value, - scalaBinaryVersion.value, - streams.value.log - ) - auOpt match { - case Some(au) => - val props = proj.properties :+ ("info.apiURL" -> au.toString) - proj.copy(properties = props) - case _ => proj - } - } + def defaultCacheLocation: File = CoursierDependencyResolution.defaultCacheLocation def coursierConfigurationTask( withClassifiers: Boolean, @@ -90,7 +51,7 @@ private[sbt] object LMCoursier { _.overrideScalaVersion ) val profiles = csrMavenProfiles.value - val credentials = credentialsTask.value + val credentials = CoursierInputsTasks.credentialsTask.value val createLogger = csrLogger.value @@ -107,11 +68,10 @@ private[sbt] object LMCoursier { .withInterProjectDependencies(interProjectDependencies.toVector) .withFallbackDependencies(fallbackDeps.toVector) .withExcludeDependencies( - excludeDeps.toVector.sorted - .map { - case (o, n) => - (o.value, n.value) - } + excludeDeps.toVector.map { + case (o, n) => + (o.value, n.value) + }.sorted ) .withAutoScalaLibrary(autoScalaLib) .withSbtScalaJars(sbtBootJars.toVector) @@ -129,80 +89,6 @@ private[sbt] object LMCoursier { } } - val credentialsTask = Def.task { - val log = streams.value.log - - val creds = sbt.Keys.credentials.value - .flatMap { - case dc: IvyDirectCredentials => List(dc) - case fc: FileCredentials => - Credentials.loadCredentials(fc.path) match { - case Left(err) => - log.warn(s"$err, ignoring it") - Nil - case Right(dc) => List(dc) - } - } - .map { c => - DirectCredentials() - .withHost(c.host) - .withUsername(c.userName) - .withPassword(c.passwd) - .withRealm(Some(c.realm).filter(_.nonEmpty)) - } - creds ++ csrExtraCredentials.value - } - - def coursierRecursiveResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = - Def.taskDyn { - val state = sbt.Keys.state.value - val projectRef = sbt.Keys.thisProjectRef.value - - val projects = allRecursiveInterDependencies(state, projectRef) - Def.task { - csrResolvers.all(ScopeFilter(inProjects(projectRef +: projects: _*))).value.flatten - } - } - - def coursierResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = - Def.taskDyn { - val bootResOpt = bootResolvers.value - val overrideFlag = overrideBuildResolvers.value - Def.task { - val result0 = resultTask(bootResOpt, overrideFlag).value - val reorderResolvers = true // coursierReorderResolvers.value - val keepPreloaded = false // coursierKeepPreloaded.value - val paths = ivyPaths.value - val result1 = - if (reorderResolvers) ResolutionParams.reorderResolvers(result0) - else result0 - val result2 = - paths.ivyHome match { - case Some(ivyHome) => - val ivyHomeUri = IO.toURI(ivyHome).getSchemeSpecificPart - result1 map { - case r: FileRepository => - val ivyPatterns = r.patterns.ivyPatterns map { - _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri) - } - val artifactPatterns = r.patterns.artifactPatterns map { - _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri) - } - val p = - r.patterns.withIvyPatterns(ivyPatterns).withArtifactPatterns(artifactPatterns) - r.withPatterns(p) - case r => r - } - case _ => result1 - } - if (keepPreloaded) result2 - else - result2.filter { r => - !r.name.startsWith("local-preloaded") - } - } - } - private val pluginIvySnapshotsBase = Resolver.SbtRepositoryRoot.stripSuffix("/") + "/ivy-snapshots" def coursierSbtResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = Def.task { @@ -234,314 +120,7 @@ private[sbt] object LMCoursier { } } - def coursierInterProjectDependenciesTask: Def.Initialize[sbt.Task[Seq[CProject]]] = - Def.taskDyn { - - val state = sbt.Keys.state.value - val projectRef = sbt.Keys.thisProjectRef.value - - val projectRefs = allRecursiveInterDependencies(state, projectRef) - - Def.task { - val projects = csrProject.all(ScopeFilter(inProjects(projectRefs: _*))).value - val projectModules = projects.map(_.module).toSet - - // this includes org.scala-sbt:global-plugins referenced from meta-builds in particular - val extraProjects = sbt.Keys.projectDescriptors.value - .map { - case (k, v) => - moduleFromIvy(k) -> v - } - .filter { - case (module, _) => - !projectModules(module) - } - .toVector - .map { - case (module, v) => - val configurations = v.getConfigurations.map { c => - CConfiguration(c.getName) -> c.getExtends.map(CConfiguration(_)).toSeq - }.toMap - val deps = v.getDependencies.flatMap(dependencyFromIvy) - CProject( - module, - v.getModuleRevisionId.getRevision, - deps, - configurations, - None, - Nil, - Nil, - Nil, - None, - None, - None, - relocated = false, - None, - Nil, - CInfo.empty - ) - } - - projects ++ extraProjects - } - } - - def coursierFallbackDependenciesTask: Def.Initialize[sbt.Task[Seq[FallbackDependency]]] = - Def.taskDyn { - val s = state.value - val projectRef = sbt.Keys.thisProjectRef.value - - val projects = allRecursiveInterDependencies(s, projectRef) - Def.task { - val allDeps = - allDependencies.all(ScopeFilter(inProjects(projectRef +: projects: _*))).value.flatten - - FromSbt.fallbackDependencies( - allDeps, - scalaVersion.in(projectRef).value, - scalaBinaryVersion.in(projectRef).value - ) - } - } - def publicationsSetting(packageConfigs: Seq[(Configuration, CConfiguration)]): Def.Setting[_] = { - csrPublications := coursierPublicationsTask(packageConfigs: _*).value - } - - def coursierPublicationsTask( - configsMap: (Configuration, CConfiguration)* - ): Def.Initialize[sbt.Task[Seq[(CConfiguration, CPublication)]]] = - Def.task { - val s = sbt.Keys.state.value - val projectRef = sbt.Keys.thisProjectRef.value - val projId = sbt.Keys.projectID.value - val sv = sbt.Keys.scalaVersion.value - val sbv = sbt.Keys.scalaBinaryVersion.value - val ivyConfs = sbt.Keys.ivyConfigurations.value - val extracted = Project.extract(s) - import extracted._ - - val sourcesConfigOpt = - if (ivyConfigurations.value.exists(_.name == "sources")) - Some(CConfiguration("sources")) - else - None - - val docsConfigOpt = - if (ivyConfigurations.value.exists(_.name == "docs")) - Some(CConfiguration("docs")) - else - None - - val sbtBinArtifacts = - for ((config, targetConfig) <- configsMap) yield { - - val publish = getOpt( - publishArtifact - .in(projectRef) - .in(packageBin) - .in(config) - ).getOrElse(false) - - if (publish) - getOpt( - artifact - .in(projectRef) - .in(packageBin) - .in(config) - ).map(targetConfig -> _) - else - None - } - - val sbtSourceArtifacts = - for ((config, targetConfig) <- configsMap) yield { - - val publish = getOpt( - publishArtifact - .in(projectRef) - .in(packageSrc) - .in(config) - ).getOrElse(false) - - if (publish) - getOpt( - artifact - .in(projectRef) - .in(packageSrc) - .in(config) - ).map(sourcesConfigOpt.getOrElse(targetConfig) -> _) - else - None - } - - val sbtDocArtifacts = - for ((config, targetConfig) <- configsMap) yield { - - val publish = - getOpt( - publishArtifact - .in(projectRef) - .in(packageDoc) - .in(config) - ).getOrElse(false) - - if (publish) - getOpt( - artifact - .in(projectRef) - .in(packageDoc) - .in(config) - ).map(docsConfigOpt.getOrElse(targetConfig) -> _) - else - None - } - - val sbtArtifacts = sbtBinArtifacts ++ sbtSourceArtifacts ++ sbtDocArtifacts - - def artifactPublication(artifact: Artifact) = { - - val name = FromSbt.sbtCrossVersionName( - artifact.name, - projId.crossVersion, - sv, - sbv - ) - - CPublication( - name, - CType(artifact.`type`), - CExtension(artifact.extension), - artifact.classifier.fold(Classifier.empty)(Classifier(_)) - ) - } - - val sbtArtifactsPublication = sbtArtifacts.collect { - case Some((config, artifact)) => - config -> artifactPublication(artifact) - } - - val stdArtifactsSet = sbtArtifacts.flatMap(_.map { case (_, a) => a }.toSeq).toSet - - // Second-way of getting artifacts from SBT - // No obvious way of getting the corresponding publishArtifact value for the ones - // only here, it seems. - val extraSbtArtifacts = getOpt( - sbt.Keys.artifacts - .in(projectRef) - ).getOrElse(Nil) - .filterNot(stdArtifactsSet) - - // Seems that SBT does that - if an artifact has no configs, - // it puts it in all of them. See for example what happens to - // the standalone JAR artifact of the coursier cli module. - def allConfigsIfEmpty(configs: Iterable[ConfigRef]): Iterable[ConfigRef] = - if (configs.isEmpty) ivyConfs.filter(_.isPublic).map(c => ConfigRef(c.name)) else configs - - val extraSbtArtifactsPublication = for { - artifact <- extraSbtArtifacts - config <- allConfigsIfEmpty(artifact.configurations.map(x => ConfigRef(x.name))) - // FIXME If some configurations from artifact.configurations are not public, they may leak here :\ - } yield CConfiguration(config.name) -> artifactPublication(artifact) - - sbtArtifactsPublication ++ extraSbtArtifactsPublication - } - - private def moduleFromIvy(id: org.apache.ivy.core.module.id.ModuleRevisionId): Module = - Module( - COrganization(id.getOrganisation), - ModuleName(id.getName), - id.getExtraAttributes.asScala.map { - case (k0, v0) => k0.asInstanceOf[String] -> v0.asInstanceOf[String] - }.toMap - ) - - private def dependencyFromIvy( - desc: org.apache.ivy.core.module.descriptor.DependencyDescriptor - ): Seq[(CConfiguration, CDependency)] = { - - val id = desc.getDependencyRevisionId - val module = moduleFromIvy(id) - val exclusions = desc.getAllExcludeRules.map { rule => - // we're ignoring rule.getConfigurations and rule.getMatcher here - val modId = rule.getId.getModuleId - // we're ignoring modId.getAttributes here - (COrganization(modId.getOrganisation), ModuleName(modId.getName)) - }.toSet - - val configurations = desc.getModuleConfigurations.toVector - .flatMap(s => coursier.ivy.IvyXml.mappings(s)) - - def dependency(conf: CConfiguration, attr: CAttributes) = CDependency( - module, - id.getRevision, - conf, - exclusions, - attr, - optional = false, - desc.isTransitive - ) - - val attributes: CConfiguration => CAttributes = { - - val artifacts = desc.getAllDependencyArtifacts - - val m = artifacts.toVector.flatMap { art => - val attr = CAttributes(CType(art.getType), Classifier.empty) - art.getConfigurations.map(CConfiguration(_)).toVector.map { conf => - conf -> attr - } - }.toMap - - c => m.getOrElse(c, CAttributes.empty) - } - - configurations.map { - case (from, to) => - from -> dependency(to, attributes(to)) - } - } - - private def resultTask( - bootResOpt: Option[Seq[Resolver]], - overrideFlag: Boolean - ): Def.Initialize[sbt.Task[Seq[Resolver]]] = - bootResOpt.filter(_ => overrideFlag) match { - case Some(r) => Def.task(r) - case None => - Def.taskDyn { - val extRes = externalResolvers.value - val isSbtPlugin = sbtPlugin.value - if (isSbtPlugin) - Def.task { - Seq( - sbtResolver.value, - Classpaths.sbtPluginReleases - ) ++ extRes - } else - Def.task(extRes) - } - } - - def allRecursiveInterDependencies(state: sbt.State, projectRef: sbt.ProjectRef) = { - def dependencies(map: Map[String, Seq[String]], id: String): Set[String] = { - - def helper(map: Map[String, Seq[String]], acc: Set[String]): Set[String] = - if (acc.exists(map.contains)) { - val (kept, rem) = map.partition { case (k, _) => acc(k) } - helper(rem, acc ++ kept.valuesIterator.flatten) - } else - acc - - helper(map - id, map.getOrElse(id, Nil).toSet) - } - - val allProjectsDeps = - for (p <- Project.structure(state).allProjects) - yield p.id -> p.dependencies.map(_.project.project) - - val deps = dependencies(allProjectsDeps.toMap, projectRef.project) - - Project.structure(state).allProjectRefs.filter(p => deps(p.project)) + csrPublications := CoursierArtifactsTasks.coursierPublicationsTask(packageConfigs: _*).value } } diff --git a/main/src/main/scala/sbt/internal/LibraryManagement.scala b/main/src/main/scala/sbt/internal/LibraryManagement.scala index eaed30432..a6f12b680 100644 --- a/main/src/main/scala/sbt/internal/LibraryManagement.scala +++ b/main/src/main/scala/sbt/internal/LibraryManagement.scala @@ -8,7 +8,7 @@ package sbt package internal -import coursier.lmcoursier.CoursierDependencyResolution +import lmcoursier.CoursierDependencyResolution import java.io.File import sbt.internal.librarymanagement._ import sbt.internal.util.{ ConsoleAppender, LogOption } diff --git a/main/src/main/scala/sbt/internal/librarymanagement/CoursierArtifactsTasks.scala b/main/src/main/scala/sbt/internal/librarymanagement/CoursierArtifactsTasks.scala new file mode 100644 index 000000000..23e64aae2 --- /dev/null +++ b/main/src/main/scala/sbt/internal/librarymanagement/CoursierArtifactsTasks.scala @@ -0,0 +1,157 @@ +/* + * sbt + * Copyright 2011 - 2018, Lightbend, Inc. + * Copyright 2008 - 2010, Mark Harrah + * Licensed under Apache License 2.0 (see LICENSE) + */ + +package sbt +package internal +package librarymanagement + +import lmcoursier.definitions.{ + Classifier, + Configuration => CConfiguration, + Extension => CExtension, + Publication => CPublication, + Type => CType +} +import sbt.librarymanagement._ +import sbt.Keys._ + +object CoursierArtifactsTasks { + def coursierPublicationsTask( + configsMap: (sbt.librarymanagement.Configuration, CConfiguration)* + ): Def.Initialize[sbt.Task[Seq[(CConfiguration, CPublication)]]] = + Def.task { + val s = sbt.Keys.state.value + val projectRef = sbt.Keys.thisProjectRef.value + val projId = sbt.Keys.projectID.value + val sv = sbt.Keys.scalaVersion.value + val sbv = sbt.Keys.scalaBinaryVersion.value + val ivyConfs = sbt.Keys.ivyConfigurations.value + val extracted = Project.extract(s) + import extracted._ + + val sourcesConfigOpt = + if (ivyConfigurations.value.exists(_.name == "sources")) + Some(CConfiguration("sources")) + else + None + + val docsConfigOpt = + if (ivyConfigurations.value.exists(_.name == "docs")) + Some(CConfiguration("docs")) + else + None + + val sbtBinArtifacts = + for ((config, targetConfig) <- configsMap) yield { + + val publish = getOpt( + publishArtifact + .in(projectRef) + .in(packageBin) + .in(config) + ).getOrElse(false) + + if (publish) + getOpt( + artifact + .in(projectRef) + .in(packageBin) + .in(config) + ).map(targetConfig -> _) + else + None + } + + val sbtSourceArtifacts = + for ((config, targetConfig) <- configsMap) yield { + + val publish = getOpt( + publishArtifact + .in(projectRef) + .in(packageSrc) + .in(config) + ).getOrElse(false) + + if (publish) + getOpt( + artifact + .in(projectRef) + .in(packageSrc) + .in(config) + ).map(sourcesConfigOpt.getOrElse(targetConfig) -> _) + else + None + } + + val sbtDocArtifacts = + for ((config, targetConfig) <- configsMap) yield { + + val publish = + getOpt( + publishArtifact + .in(projectRef) + .in(packageDoc) + .in(config) + ).getOrElse(false) + + if (publish) + getOpt( + artifact + .in(projectRef) + .in(packageDoc) + .in(config) + ).map(docsConfigOpt.getOrElse(targetConfig) -> _) + else + None + } + + val sbtArtifacts = sbtBinArtifacts ++ sbtSourceArtifacts ++ sbtDocArtifacts + + def artifactPublication(artifact: Artifact) = { + + val name = CrossVersion(projId.crossVersion, sv, sbv) + .fold(artifact.name)(_(artifact.name)) + + CPublication( + name, + CType(artifact.`type`), + CExtension(artifact.extension), + artifact.classifier.fold(Classifier(""))(Classifier(_)) + ) + } + + val sbtArtifactsPublication = sbtArtifacts.collect { + case Some((config, artifact)) => + config -> artifactPublication(artifact) + } + + val stdArtifactsSet = sbtArtifacts.flatMap(_.map { case (_, a) => a }.toSeq).toSet + + // Second-way of getting artifacts from SBT + // No obvious way of getting the corresponding publishArtifact value for the ones + // only here, it seems. + val extraSbtArtifacts = getOpt( + sbt.Keys.artifacts + .in(projectRef) + ).getOrElse(Nil) + .filterNot(stdArtifactsSet) + + // Seems that SBT does that - if an artifact has no configs, + // it puts it in all of them. See for example what happens to + // the standalone JAR artifact of the coursier cli module. + def allConfigsIfEmpty(configs: Iterable[ConfigRef]): Iterable[ConfigRef] = + if (configs.isEmpty) ivyConfs.filter(_.isPublic).map(c => ConfigRef(c.name)) else configs + + val extraSbtArtifactsPublication = for { + artifact <- extraSbtArtifacts + config <- allConfigsIfEmpty(artifact.configurations.map(x => ConfigRef(x.name))) + // FIXME If some configurations from artifact.configurations are not public, they may leak here :\ + } yield CConfiguration(config.name) -> artifactPublication(artifact) + + sbtArtifactsPublication ++ extraSbtArtifactsPublication + } +} diff --git a/main/src/main/scala/sbt/internal/librarymanagement/CoursierInputsTasks.scala b/main/src/main/scala/sbt/internal/librarymanagement/CoursierInputsTasks.scala new file mode 100644 index 000000000..e50b1a874 --- /dev/null +++ b/main/src/main/scala/sbt/internal/librarymanagement/CoursierInputsTasks.scala @@ -0,0 +1,235 @@ +/* + * sbt + * Copyright 2011 - 2018, Lightbend, Inc. + * Copyright 2008 - 2010, Mark Harrah + * Licensed under Apache License 2.0 (see LICENSE) + */ + +package sbt +package internal +package librarymanagement + +import sbt.librarymanagement._ +import sbt.util.Logger +import sbt.Keys._ +import lmcoursier.definitions.{ + Attributes => CAttributes, + Classifier, + Configuration => CConfiguration, + Dependency => CDependency, + // Extension => CExtension, + Info => CInfo, + Module, + ModuleName, + Organization => COrganization, + Project => CProject, + // Publication => CPublication, + Type => CType +} +import lmcoursier.credentials.DirectCredentials +import lmcoursier.{ FallbackDependency, FromSbt, Inputs } +import sbt.librarymanagement.ivy.{ + FileCredentials, + Credentials, + DirectCredentials => IvyDirectCredentials +} +import sbt.ScopeFilter.Make._ +import scala.collection.JavaConverters._ + +private[sbt] object CoursierInputsTasks { + private def coursierProject0( + projId: ModuleID, + dependencies: Seq[ModuleID], + excludeDeps: Seq[InclExclRule], + configurations: Seq[sbt.librarymanagement.Configuration], + sv: String, + sbv: String, + log: Logger + ): CProject = { + + val exclusions0 = Inputs.exclusions(excludeDeps, sv, sbv, log) + + val configMap = Inputs.configExtends(configurations) + + val proj = FromSbt.project( + projId, + dependencies, + configMap, + sv, + sbv + ) + + proj.copy( + dependencies = proj.dependencies.map { + case (config, dep) => + (config, dep.copy(exclusions = dep.exclusions ++ exclusions0)) + } + ) + } + + private[sbt] def coursierProjectTask: Def.Initialize[sbt.Task[CProject]] = + Def.task { + val auOpt = apiURL.value + val proj = coursierProject0( + projectID.value, + allDependencies.value, + allExcludeDependencies.value, + // should projectID.configurations be used instead? + ivyConfigurations.value, + scalaVersion.value, + scalaBinaryVersion.value, + streams.value.log + ) + auOpt match { + case Some(au) => + val props = proj.properties :+ ("info.apiURL" -> au.toString) + proj.copy(properties = props) + case _ => proj + } + } + + private def moduleFromIvy(id: org.apache.ivy.core.module.id.ModuleRevisionId): Module = + Module( + COrganization(id.getOrganisation), + ModuleName(id.getName), + id.getExtraAttributes.asScala.map { + case (k0, v0) => k0.asInstanceOf[String] -> v0.asInstanceOf[String] + }.toMap + ) + + private def dependencyFromIvy( + desc: org.apache.ivy.core.module.descriptor.DependencyDescriptor + ): Seq[(CConfiguration, CDependency)] = { + + val id = desc.getDependencyRevisionId + val module = moduleFromIvy(id) + val exclusions = desc.getAllExcludeRules.map { rule => + // we're ignoring rule.getConfigurations and rule.getMatcher here + val modId = rule.getId.getModuleId + // we're ignoring modId.getAttributes here + (COrganization(modId.getOrganisation), ModuleName(modId.getName)) + }.toSet + + val configurations = desc.getModuleConfigurations.toVector + .flatMap(Inputs.ivyXmlMappings) + + def dependency(conf: CConfiguration, attr: CAttributes) = CDependency( + module, + id.getRevision, + conf, + exclusions, + attr, + optional = false, + desc.isTransitive + ) + + val attributes: CConfiguration => CAttributes = { + + val artifacts = desc.getAllDependencyArtifacts + + val m = artifacts.toVector.flatMap { art => + val attr = CAttributes(CType(art.getType), Classifier("")) + art.getConfigurations.map(CConfiguration(_)).toVector.map { conf => + conf -> attr + } + }.toMap + + c => m.getOrElse(c, CAttributes(CType(""), Classifier(""))) + } + + configurations.map { + case (from, to) => + from -> dependency(to, attributes(to)) + } + } + + private[sbt] def coursierInterProjectDependenciesTask: Def.Initialize[sbt.Task[Seq[CProject]]] = + Def.taskDyn { + + val state = sbt.Keys.state.value + val projectRef = sbt.Keys.thisProjectRef.value + + val projectRefs = Project.transitiveInterDependencies(state, projectRef) + + Def.task { + val projects = csrProject.all(ScopeFilter(inProjects(projectRefs: _*))).value + val projectModules = projects.map(_.module).toSet + + // this includes org.scala-sbt:global-plugins referenced from meta-builds in particular + val extraProjects = sbt.Keys.projectDescriptors.value + .map { + case (k, v) => + moduleFromIvy(k) -> v + } + .filter { + case (module, _) => + !projectModules(module) + } + .toVector + .map { + case (module, v) => + val configurations = v.getConfigurations.map { c => + CConfiguration(c.getName) -> c.getExtends.map(CConfiguration(_)).toSeq + }.toMap + val deps = v.getDependencies.flatMap(dependencyFromIvy) + CProject( + module, + v.getModuleRevisionId.getRevision, + deps, + configurations, + Nil, + None, + Nil, + CInfo("", "", Nil, Nil, None) + ) + } + + projects ++ extraProjects + } + } + + private[sbt] def coursierFallbackDependenciesTask + : Def.Initialize[sbt.Task[Seq[FallbackDependency]]] = + Def.taskDyn { + val state = sbt.Keys.state.value + val projectRef = sbt.Keys.thisProjectRef.value + + val projects = Project.transitiveInterDependencies(state, projectRef) + + Def.task { + val allDeps = + allDependencies.all(ScopeFilter(inProjects(projectRef +: projects: _*))).value.flatten + + FromSbt.fallbackDependencies( + allDeps, + scalaVersion.value, + scalaBinaryVersion.value + ) + } + } + + val credentialsTask = Def.task { + val log = streams.value.log + val creds = sbt.Keys.credentials.value + .flatMap { + case dc: IvyDirectCredentials => List(dc) + case fc: FileCredentials => + Credentials.loadCredentials(fc.path) match { + case Left(err) => + log.warn(s"$err, ignoring it") + Nil + case Right(dc) => List(dc) + } + } + .map { c => + DirectCredentials() + .withHost(c.host) + .withUsername(c.userName) + .withPassword(c.passwd) + .withRealm(Some(c.realm).filter(_.nonEmpty)) + .withHttpsOnly(false) + .withMatchHost(true) + } + creds ++ csrExtraCredentials.value + } +} diff --git a/main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala b/main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala new file mode 100644 index 000000000..bccf63fe6 --- /dev/null +++ b/main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala @@ -0,0 +1,111 @@ +/* + * sbt + * Copyright 2011 - 2018, Lightbend, Inc. + * Copyright 2008 - 2010, Mark Harrah + * Licensed under Apache License 2.0 (see LICENSE) + */ + +package sbt +package internal +package librarymanagement + +import sbt.librarymanagement._ +import sbt.Keys._ +import sbt.ScopeFilter.Make._ + +private[sbt] object CoursierRepositoriesTasks { + private object CResolvers { + private val slowReposBase = Seq( + "https://repo.typesafe.com/", + "https://repo.scala-sbt.org/", + "http://repo.typesafe.com/", + "http://repo.scala-sbt.org/" + ) + + private val fastReposBase = Seq( + "http://repo1.maven.org/", + "https://repo1.maven.org/" + ) + + private def url(res: Resolver): Option[String] = + res match { + case m: sbt.librarymanagement.MavenRepository => + Some(m.root) + case u: URLRepository => + u.patterns.artifactPatterns.headOption + .orElse(u.patterns.ivyPatterns.headOption) + case _ => + None + } + + private def fastRepo(res: Resolver): Boolean = + url(res).exists(u => fastReposBase.exists(u.startsWith)) + + private def slowRepo(res: Resolver): Boolean = + url(res).exists(u => slowReposBase.exists(u.startsWith)) + + def reorderResolvers(resolvers: Seq[Resolver]): Seq[Resolver] = + if (resolvers.exists(fastRepo) && resolvers.exists(slowRepo)) { + val (slow, other) = resolvers.partition(slowRepo) + other ++ slow + } else + resolvers + } + + private def resultTask( + bootResOpt: Option[Seq[Resolver]], + overrideFlag: Boolean + ): Def.Initialize[sbt.Task[Seq[Resolver]]] = + bootResOpt.filter(_ => overrideFlag) match { + case Some(r) => Def.task(r) + case None => + Def.taskDyn { + val extRes = externalResolvers.value + val isSbtPlugin = sbtPlugin.value + if (isSbtPlugin) + Def.task { + Seq( + sbtResolver.value, + Classpaths.sbtPluginReleases + ) ++ extRes + } else + Def.task(extRes) + } + } + + def coursierResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = + Def.taskDyn { + + val bootResOpt = bootResolvers.value + val overrideFlag = overrideBuildResolvers.value + + Def.task { + val result = resultTask(bootResOpt, overrideFlag).value + val reorderResolvers = true // coursierReorderResolvers.value + val keepPreloaded = true // coursierKeepPreloaded.value + + val result0 = + if (reorderResolvers) + CResolvers.reorderResolvers(result) + else + result + + if (keepPreloaded) + result0 + else + result0.filter { r => + !r.name.startsWith("local-preloaded") + } + } + } + + def coursierRecursiveResolversTask: Def.Initialize[sbt.Task[Seq[Resolver]]] = + Def.taskDyn { + val state = sbt.Keys.state.value + val projectRef = sbt.Keys.thisProjectRef.value + val projects = Project.transitiveInterDependencies(state, projectRef) + Def.task { + csrResolvers.all(ScopeFilter(inProjects(projectRef +: projects: _*))).value.flatten + } + } +} diff --git a/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala index 7cb58451a..966d0fb6e 100644 --- a/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala +++ b/main/src/main/scala/sbt/internal/librarymanagement/IvyXml.scala @@ -12,7 +12,7 @@ package librarymanagement import java.nio.charset.StandardCharsets.UTF_8 import java.nio.file.Files -import coursier.core.{ Configuration, Project } +import lmcoursier.definitions.{ Configuration, Project } import org.apache.ivy.core.module.id.ModuleRevisionId import Def.Setting import sbt.Keys.{ @@ -29,7 +29,7 @@ import scala.xml.{ Node, PrefixedAttribute } object IvyXml { import sbt.Project._ - def rawContent( + private def rawContent( currentProject: Project, shadedConfigOpt: Option[Configuration] ): String = { @@ -47,7 +47,7 @@ object IvyXml { } // These are required for publish to be fine, later on. - def writeFiles( + private def writeFiles( currentProject: Project, shadedConfigOpt: Option[Configuration], ivySbt: IvySbt, @@ -77,12 +77,12 @@ object IvyXml { () } - def content(project0: Project, shadedConfigOpt: Option[Configuration]): Node = { + private def content(project0: Project, shadedConfigOpt: Option[Configuration]): Node = { val filterOutDependencies = shadedConfigOpt.toSet[Configuration].flatMap { shadedConfig => project0.dependencies - .collect { case (`shadedConfig`, dep) => dep } + .collect { case (conf, dep) if conf.value == shadedConfig.value => dep } } val project: Project = project0.copy( @@ -118,8 +118,8 @@ object IvyXml { } % infoAttrs val confElems = project.configurations.toVector.collect { - case (name, extends0) if !shadedConfigOpt.contains(name) => - val extends1 = shadedConfigOpt.fold(extends0)(c => extends0.filter(_ != c)) + case (name, extends0) if !shadedConfigOpt.exists(_.value == name.value) => + val extends1 = shadedConfigOpt.fold(extends0)(c => extends0.filter(_.value != c.value)) val n = if (extends1.nonEmpty) n % .attributes @@ -138,7 +138,7 @@ object IvyXml { configs.map(_.value).mkString(",") } /> - if (pub.classifier.nonEmpty) + if (pub.classifier.value.nonEmpty) n % .attributes else n @@ -174,7 +174,7 @@ object IvyXml { } - def makeIvyXmlBefore[T]( + private def makeIvyXmlBefore[T]( task: TaskKey[T], shadedConfigOpt: Option[Configuration] ): Setting[Task[T]] = @@ -220,6 +220,6 @@ object IvyXml { def generateIvyXmlSettings( shadedConfigOpt: Option[Configuration] = None ): Seq[Setting[_]] = - (needsIvyXml ++ needsIvyXmlLocal).map(IvyXml.makeIvyXmlBefore(_, shadedConfigOpt)) + (needsIvyXml ++ needsIvyXmlLocal).map(makeIvyXmlBefore(_, shadedConfigOpt)) } diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 64c9a8f26..ebc440cca 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -100,8 +100,8 @@ object Dependencies { def addSbtZincCompile(p: Project): Project = addSbtModule(p, sbtZincPath, "zincCompile", zincCompile) - val lmCousierVersion = "1.1.0-M14" - val lmCousier = "io.get-coursier" %% "lm-coursier" % lmCousierVersion + val lmCoursierVersion = "1.1.0-M14-1" + val lmCoursierShaded = "io.get-coursier" %% "lm-coursier-shaded" % lmCoursierVersion val sjsonNewScalaJson = Def.setting { "com.eed3si9n" %% "sjson-new-scalajson" % contrabandSjsonNewVersion.value From 8c0f13a24ae90c42ae8aed47bef42d68b160672f Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 26 Apr 2019 17:51:17 -0400 Subject: [PATCH 22/24] manually expand ivy.home Ref coursier/coursier#1124 --- .../CoursierRepositoriesTasks.scala | 35 ++++++++++++++----- 1 file changed, 27 insertions(+), 8 deletions(-) diff --git a/main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala b/main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala index bccf63fe6..4e6f535d7 100644 --- a/main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala +++ b/main/src/main/scala/sbt/internal/librarymanagement/CoursierRepositoriesTasks.scala @@ -12,6 +12,7 @@ package librarymanagement import sbt.librarymanagement._ import sbt.Keys._ import sbt.ScopeFilter.Make._ +import sbt.io.IO private[sbt] object CoursierRepositoriesTasks { private object CResolvers { @@ -80,20 +81,38 @@ private[sbt] object CoursierRepositoriesTasks { val overrideFlag = overrideBuildResolvers.value Def.task { - val result = resultTask(bootResOpt, overrideFlag).value + val result0 = resultTask(bootResOpt, overrideFlag).value val reorderResolvers = true // coursierReorderResolvers.value val keepPreloaded = true // coursierKeepPreloaded.value - val result0 = - if (reorderResolvers) - CResolvers.reorderResolvers(result) - else - result + val paths = ivyPaths.value + val result1 = + if (reorderResolvers) CResolvers.reorderResolvers(result0) + else result0 + val result2 = + paths.ivyHome match { + case Some(ivyHome) => + val ivyHomeUri = IO.toURI(ivyHome).getSchemeSpecificPart + result1 map { + case r: FileRepository => + val ivyPatterns = r.patterns.ivyPatterns map { + _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri) + } + val artifactPatterns = r.patterns.artifactPatterns map { + _.replaceAllLiterally("$" + "{ivy.home}", ivyHomeUri) + } + val p = + r.patterns.withIvyPatterns(ivyPatterns).withArtifactPatterns(artifactPatterns) + r.withPatterns(p) + case r => r + } + case _ => result1 + } if (keepPreloaded) - result0 + result2 else - result0.filter { r => + result2.filter { r => !r.name.startsWith("local-preloaded") } } From 96ad731e8cfb4b6f8ea9524c282a7ee9551feab0 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 26 Apr 2019 18:06:10 -0400 Subject: [PATCH 23/24] Use allExcludeDependencies --- main/src/main/scala/sbt/internal/LMCoursier.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/src/main/scala/sbt/internal/LMCoursier.scala b/main/src/main/scala/sbt/internal/LMCoursier.scala index 7dec70905..ab159b13e 100644 --- a/main/src/main/scala/sbt/internal/LMCoursier.scala +++ b/main/src/main/scala/sbt/internal/LMCoursier.scala @@ -41,7 +41,7 @@ private[sbt] object LMCoursier { val scalaVer = scalaVersion.value val interProjectDependencies = csrInterProjectDependencies.value val excludeDeps = Inputs.exclusions( - excludeDependencies.value, + allExcludeDependencies.value, scalaVer, scalaBinaryVersion.value, streams.value.log From f999f6a62ea89fc8292e4be20564652b3757a04e Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 27 Apr 2019 12:52:55 -0400 Subject: [PATCH 24/24] always reresolve sbt artifacts when using Coursier Ref #4589 This requires sbt server tests to resolve sbt off of local. --- .travis.yml | 2 +- main/src/main/scala/sbt/Defaults.scala | 26 +++++++++---------- .../test/scala/sbt/RunFromSourceMain.scala | 2 +- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/.travis.yml b/.travis.yml index 5f721d033..edc99e178 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,7 +10,7 @@ env: # WHITESOURCE_PASSWORD= - secure: d3bu2KNwsVHwfhbGgO+gmRfDKBJhfICdCJFGWKf2w3Gv86AJZX9nuTYRxz0KtdvEHO5Xw8WTBZLPb2thSJqhw9OCm4J8TBAVqCP0ruUj4+aqBUFy4bVexQ6WKE6nWHs4JPzPk8c6uC1LG3hMuzlC8RGETXtL/n81Ef1u7NjyXjs= matrix: - - SBT_CMD=";mimaReportBinaryIssues ;scalafmtCheckAll ;headerCheck ;test:headerCheck ;whitesourceOnPush ;test:compile ;mainSettingsProj/test ;safeUnitTests ;otherUnitTests; doc" + - SBT_CMD=";mimaReportBinaryIssues ;scalafmtCheckAll ;headerCheck ;test:headerCheck ;whitesourceOnPush ;test:compile; publishLocal ;mainSettingsProj/test ;safeUnitTests ;otherUnitTests; doc" - SBT_CMD="scripted actions/*" - SBT_CMD="scripted apiinfo/* compiler-project/* ivy-deps-management/*" - SBT_CMD="scripted dependency-management/*1of4" diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 4e0a41e65..cc72580f5 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -1916,6 +1916,7 @@ object Classpaths { managedClasspath := { val isMeta = isMetaBuild.value val force = reresolveSbtArtifacts.value + val csr = useCoursier.value val app = appConfiguration.value val sbtCp0 = app.provider.mainClasspath.toList val sbtCp = sbtCp0 map { Attributed.blank(_) } @@ -1924,7 +1925,7 @@ object Classpaths { classpathTypes.value, update.value ) - if (isMeta && !force) sbtCp ++ mjars + if (isMeta && !force && !csr) mjars ++ sbtCp else mjars }, exportedProducts := trackedExportedProducts(TrackLevel.TrackAlways).value, @@ -2448,19 +2449,18 @@ object Classpaths { val isMeta = isMetaBuild.value val force = reresolveSbtArtifacts.value val excludes = excludeDependencies.value - val sbtModules = Vector( - "sbt", - "zinc_2.12", - "librarymanagement-core_2.12", - "librarymanagement-ivy_2.12", - "util-logging_2.12", - "util-position_2.12", - "io_2.12" + val csr = useCoursier.value + val o = sbtdeps.organization + val sbtModulesExcludes = Vector[ExclusionRule]( + o % "sbt", + o %% "scripted-plugin", + o %% "librarymanagement-core", + o %% "librarymanagement-ivy", + o %% "util-logging", + o %% "util-position", + o %% "io" ) - val sbtModulesExcludes = sbtModules map { nm: String => - ExclusionRule(organization = sbtdeps.organization, name = nm) - } - if (isMeta && !force) excludes.toVector ++ sbtModulesExcludes + if (isMeta && !force && !csr) excludes.toVector ++ sbtModulesExcludes else excludes }, dependencyOverrides ++= { diff --git a/sbt/src/test/scala/sbt/RunFromSourceMain.scala b/sbt/src/test/scala/sbt/RunFromSourceMain.scala index b91e610ee..1753f6cf5 100644 --- a/sbt/src/test/scala/sbt/RunFromSourceMain.scala +++ b/sbt/src/test/scala/sbt/RunFromSourceMain.scala @@ -14,7 +14,7 @@ import xsbti._ import scala.sys.process.Process object RunFromSourceMain { - private val sbtVersion = "1.1.4" // TestBuildInfo.version + private val sbtVersion = TestBuildInfo.version private val scalaVersion = "2.12.6" def fork(workingDirectory: File): Process = {