fport: Add Resolver.sonatypeCentralRepo

lm-core/src/main/scala/sbt/librarymanagement/ResolverExtra.scala

@@ -98,43 +98,25 @@ private[sbt] class FakeRepository(resolver: AnyRef, name: String) extends xsbti.
 }
 
 private[librarymanagement] abstract class ResolverFunctions {
-  import sbt.internal.librarymanagement.LMSysProp.useSecureResolvers
+  val TypesafeRepositoryRoot = "https://repo.typesafe.com/typesafe"
-
+  val SbtRepositoryRoot = "https://repo.scala-sbt.org/scalasbt"
-  val TypesafeRepositoryRoot = typesafeRepositoryRoot(useSecureResolvers)
-  val SbtRepositoryRoot = sbtRepositoryRoot(useSecureResolvers)
   @deprecated("Renamed to SbtRepositoryRoot.", "1.0.0")
   val SbtPluginRepositoryRoot = SbtRepositoryRoot
   val SonatypeRepositoryRoot = "https://oss.sonatype.org/content/repositories"
   val SonatypeS01RepositoryRoot = "https://s01.oss.sonatype.org/content/repositories"
   val SonatypeReleasesRepository =
     "https://oss.sonatype.org/service/local/repositories/releases/content/"
+  val SonatypeCentralRepository = "https://central.sonatype.com/repository"
   val JavaNet2RepositoryName = "java.net Maven2 Repository"
-  val JavaNet2RepositoryRoot = javanet2RepositoryRoot(useSecureResolvers)
+  val JavaNet2RepositoryRoot = "https://maven.java.net/content/repositories/public/"
-  val JCenterRepositoryName = "jcenter"
-  val JCenterRepositoryRoot = "https://jcenter.bintray.com/"
   val DefaultMavenRepositoryRoot = "https://repo1.maven.org/maven2/"
   val DefaultMavenRepository =
-    MavenRepository("public", centralRepositoryRoot(useSecureResolvers))
+    MavenRepository("public", "https://repo1.maven.org/maven2/")
   val JavaNet2Repository = MavenRepository(JavaNet2RepositoryName, JavaNet2RepositoryRoot)
-  val JCenterRepository = MavenRepository(JCenterRepositoryName, JCenterRepositoryRoot)
 
   def mavenCentral: Resolver = DefaultMavenRepository
   def defaults: Vector[Resolver] = Vector(mavenCentral)
 
-  // TODO: This switch is only kept for backward compatibility. Hardcode to HTTPS in the future.
-  private[sbt] def centralRepositoryRoot(secure: Boolean) =
-    (if (secure) "https" else "http") + "://repo1.maven.org/maven2/"
-  // TODO: This switch is only kept for backward compatibility. Hardcode to HTTPS in the future.
-  private[sbt] def javanet2RepositoryRoot(secure: Boolean) =
-    if (secure) "https://maven.java.net/content/repositories/public/"
-    else "http://download.java.net/maven/2"
-  // TODO: This switch is only kept for backward compatibility. Hardcode to HTTPS in the future.
-  private[sbt] def typesafeRepositoryRoot(secure: Boolean) =
-    (if (secure) "https" else "http") + "://repo.typesafe.com/typesafe"
-  // TODO: This switch is only kept for backward compatibility. Hardcode to HTTPS in the future.
-  private[sbt] def sbtRepositoryRoot(secure: Boolean) =
-    (if (secure) "https" else "http") + "://repo.scala-sbt.org/scalasbt"
-
   // obsolete: kept only for launcher compatibility
   private[sbt] val ScalaToolsReleasesName = "Sonatype OSS Releases"
   private[sbt] val ScalaToolsSnapshotsName = "Sonatype OSS Snapshots"
@@ -159,8 +141,11 @@ private[librarymanagement] abstract class ResolverFunctions {
     url("sbt-plugin-" + status, new URI(SbtRepositoryRoot + "/sbt-plugin-" + status + "/").toURL)(
       using ivyStylePatterns
     )
+
   @deprecated(
-    """Use sonatypeOssRepos instead e.g. `resolvers ++= Resolver.sonatypeOssRepos("snapshots")`""",
+    """Sonatype OSS Repository Hosting (OSSRH) will be sunset on 2025-06-30; use the following instead:
+  resolvers += Resolver.sonatypeCentralSnapshots
+""",
     "1.7.0"
   )
   def sonatypeRepo(status: String) =
@@ -174,15 +159,23 @@ private[librarymanagement] abstract class ResolverFunctions {
       "sonatype-s01-" + status,
       SonatypeS01RepositoryRoot + "/" + status
     )
+
+  @deprecated(
+    """Sonatype OSS Repository Hosting (OSSRH) will be sunset on 2025-06-30; use the following instead:
+  resolvers += Resolver.sonatypeCentralSnapshots""",
+    "1.11.2"
+  )
   def sonatypeOssRepos(status: String) =
     Vector(sonatypeRepo(status): @nowarn("cat=deprecation"), sonatypeS01Repo(status))
-  def bintrayRepo(owner: String, repo: String) =
+
-    MavenRepository(s"bintray-$owner-$repo", s"https://dl.bintray.com/$owner/$repo/")
+  def sonatypeCentralSnapshots: MavenRepository =
-  def bintrayIvyRepo(owner: String, repo: String) =
+    sonatypeCentralRepo("maven-snapshots")
-    url(s"bintray-$owner-$repo", new URI(s"https://dl.bintray.com/$owner/$repo/").toURL)(using
+
-      Resolver.ivyStylePatterns
+  def sonatypeCentralRepo(status: String): MavenRepository =
+    MavenRepository(
+      "sonatype-central-" + status,
+      SonatypeCentralRepository + "/" + status
     )
-  def jcenterRepo = JCenterRepository
 
   val ApacheMavenSnapshotsRepo = MavenRepository(
     "apache-snapshots",
@@ -205,22 +198,8 @@ private[librarymanagement] abstract class ResolverFunctions {
   def combineDefaultResolvers(
       userResolvers: Vector[Resolver],
       mavenCentral: Boolean
-  ): Vector[Resolver] =
-    combineDefaultResolvers(userResolvers, jcenter = false, mavenCentral)
-
-  /**
-   * Add the local Ivy repository to the user repositories.
-   * If `jcenter` is true, add the JCenter.
-   * If `mavenCentral` is true, add the Maven Central repository.
-   */
-  def combineDefaultResolvers(
-      userResolvers: Vector[Resolver],
-      jcenter: Boolean,
-      mavenCentral: Boolean
   ): Vector[Resolver] =
     Vector(Resolver.defaultLocal) ++
-      userResolvers ++
-      single(JCenterRepository, jcenter) ++
       single(DefaultMavenRepository, mavenCentral)
 
   /**
@@ -230,22 +209,17 @@ private[librarymanagement] abstract class ResolverFunctions {
    */
   private[sbt] def reorganizeAppResolvers(
       appResolvers: Vector[Resolver],
-      jcenter: Boolean,
       mavenCentral: Boolean
   ): Vector[Resolver] =
     appResolvers.partition(_ == Resolver.defaultLocal) match {
       case (locals, xs) =>
         locals ++
-          (xs.partition(_ == JCenterRepository) match {
+          (xs.partition(_ == DefaultMavenRepository) match {
             case (_, xs) =>
-              single(JCenterRepository, jcenter) ++
+              single(
-                (xs.partition(_ == DefaultMavenRepository) match {
+                DefaultMavenRepository,
-                  case (_, xs) =>
+                mavenCentral
-                    single(
+              ) ++ xs // TODO - Do we need to filter out duplicates?
-                      DefaultMavenRepository,
-                      mavenCentral
-                    ) ++ xs // TODO - Do we need to filter out duplicates?
-                })
           })
     }
 

lm-coursier/src/test/scala/lmcoursier/ResolutionSpec.scala

@@ -6,11 +6,7 @@ import sbt.internal.librarymanagement.cross.CrossVersionUtil
 import sbt.internal.util.ConsoleLogger
 import sbt.librarymanagement.*
 import sbt.librarymanagement.Configurations.Component
-import sbt.librarymanagement.Resolver.{
+import sbt.librarymanagement.Resolver.{ DefaultMavenRepository, JavaNet2Repository }
-  DefaultMavenRepository,
-  JCenterRepository,
-  JavaNet2Repository
-}
 // import sbt.librarymanagement.{ Resolver, UnresolvedWarningConfiguration, UpdateConfiguration }
 import sbt.librarymanagement.syntax.*
 
@@ -47,7 +43,6 @@ final class ResolutionSpec extends AnyPropSpec with Matchers {
   def resolvers = Vector(
     DefaultMavenRepository,
     JavaNet2Repository,
-    JCenterRepository,
     Resolver.sbtPluginRepo("releases")
   )
 

lm-ivy/src/main/scala/sbt/internal/librarymanagement/MakePom.scala

@@ -384,9 +384,6 @@ class MakePom(val log: Logger) {
       if (includeAll) allResolvers(settings) else resolvers(settings.getDefaultResolver)
     val mavenRepositories =
       repositories.flatMap {
-        // TODO - Would it be ok if bintray were in the pom?   We should avoid it for now.
-        case m: CustomRemoteMavenResolver if m.repo.root == JCenterRepository.root         => Nil
-        case m: IBiblioResolver if m.isM2compatible && m.getRoot == JCenterRepository.root => Nil
         case m: CustomRemoteMavenResolver if m.repo.root != DefaultMavenRepository.root =>
           MavenRepository(m.repo.name, m.repo.root) :: Nil
         case m: IBiblioResolver if m.isM2compatible && m.getRoot != DefaultMavenRepository.root =>

main/src/main/scala/sbt/Defaults.scala

@@ -2939,13 +2939,13 @@ object Classpaths {
       case (Some(delegated), Seq(), _) => delegated
       case (_, rs, Some(ars))          => ars ++ rs
       case (_, rs, _) =>
-        Resolver.combineDefaultResolvers(rs.toVector, jcenter = false, mavenCentral = true)
+        Resolver.combineDefaultResolvers(rs.toVector, mavenCentral = true)
     }),
     appResolvers := {
       val ac = appConfiguration.value
       appRepositories(ac) map { ars =>
         val useMavenCentral = ars contains Resolver.DefaultMavenRepository
-        Resolver.reorganizeAppResolvers(ars, jcenter = false, useMavenCentral)
+        Resolver.reorganizeAppResolvers(ars, useMavenCentral)
       }
     },
     bootResolvers := {

main/src/main/scala/sbt/Opts.scala

@@ -60,8 +60,6 @@ object Opts {
     val mavenLocalFile = Resolver.file("Local Repository", userHome / ".m2" / "repository")(using
       Resolver.defaultPatterns
     )
-    val sbtSnapshots = Resolver.bintrayRepo("sbt", "maven-snapshots")
-    val sbtIvySnapshots = Resolver.bintrayIvyRepo("sbt", "ivy-snapshots")
   }
 }
 
@@ -80,10 +78,10 @@ object DefaultOptions {
     doc.title(name) ++ doc.version(version)
 
   def resolvers(snapshot: Boolean): Vector[Resolver] = {
-    if (snapshot) Vector(resolver.sbtSnapshots) else Vector.empty
+    Vector.empty
   }
   def pluginResolvers(plugin: Boolean, snapshot: Boolean): Vector[Resolver] = {
-    if (plugin && snapshot) Vector(resolver.sbtSnapshots, resolver.sbtIvySnapshots)
+    if (plugin && snapshot) Vector.empty
     else Vector.empty
   }
   def addResolvers: Setting[?] = Keys.resolvers ++= { resolvers(Keys.isSnapshot.value) }

sbt-app/src/main/scala/sbt/Import.scala

@@ -298,7 +298,6 @@ trait Import {
   type InlineConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
   val IvyScala = sbt.librarymanagement.ScalaModuleInfo
   type IvyScala = sbt.librarymanagement.ScalaModuleInfo
-  val JCenterRepository = sbt.librarymanagement.Resolver.JCenterRepository
   val JavaNet2Repository = sbt.librarymanagement.Resolver.JavaNet2Repository
   import sbt.librarymanagement.{ InclExclRule, DependencyBuilders }
   given Conversion[String, InclExclRule] = InclExclRule.stringToExclusionRule

sbt-app/src/sbt-test/dependency-management/default-resolvers/build.sbt

@@ -1,5 +1,4 @@
 lazy val check = taskKey[Unit]("")
-lazy val check2 = taskKey[Unit]("")
 
 lazy val root = (project in file(".")).
   settings(
@@ -8,9 +7,4 @@ lazy val root = (project in file(".")).
       assert(!(fr exists { _.name == "jcenter" }))
       assert(fr exists { _.name == "public" })
     },
-    check2 := {
-      val fr = fullResolvers.value
-      assert(fr exists { _.name == "jcenter" })
-      assert(fr exists { _.name == "public" })
-    }
   )

sbt-app/src/sbt-test/dependency-management/default-resolvers/test

@@ -2,10 +2,6 @@
 
 > reload
 
-> set resolvers += Resolver.jcenterRepo
-
-> check2
-
 ## HTTP
 > set resolvers += ("old_typesafe" at "http://repo.typesafe.com/typesafe/")
 -> update

sbt-app/src/sbt-test/dependency-management/resolvers-plugin/build.sbt

@@ -1,10 +0,0 @@
-lazy val check = taskKey[Unit]("")
-ThisBuild / includePluginResolvers := true
-
-check := {
-  val ivy = fullResolvers.value
-  assert(ivy exists (_.name == "bintray-eed3si9n-sbt-plugins"), s"$ivy does not include bintray")
-
-  val cs = csrResolvers.value
-  assert(cs exists (_.name == "bintray-eed3si9n-sbt-plugins"), s"$cs does not include bintray")
-}

sbt-app/src/sbt-test/dependency-management/resolvers-plugin/project/plugins.sbt

@@ -1 +0,0 @@
-resolvers += Resolver.bintrayRepo("eed3si9n", "sbt-plugins")

sbt-app/src/sbt-test/dependency-management/resolvers-plugin/test

@@ -1 +0,0 @@
-> check