feat: honor sbt resolvers in addition to scalafixResolvers (#404)

.jvmopts

@@ -3,4 +3,4 @@
 -Xmx4G
 -XX:ReservedCodeCacheSize=1024m
 -XX:+TieredCompilation
--Dfile.encoding=UTF-8
+-Dfile.encoding=UTF-8

src/main/scala/scalafix/internal/sbt/CoursierRepoResolvers.scala

@@ -0,0 +1,178 @@
+package scalafix.internal.sbt
+
+import coursierapi.{Credentials, IvyRepository, MavenRepository, Repository}
+import org.apache.ivy.plugins.resolver.IBiblioResolver
+import sbt.librarymanagement.{Configuration as _, MavenRepository as _, *}
+import sbt.util.Logger
+
+import java.net.MalformedURLException
+import java.nio.file.Paths
+import scala.collection.JavaConverters.*
+
+// vendor from sbt-coursier/lmcoursier.internal.Resolvers
+object CoursierRepoResolvers {
+
+ private def mavenCompatibleBaseOpt(patterns: Patterns): Option[String] =
+ if (patterns.isMavenCompatible) {
+ // input : /Users/user/custom/repo/[organisation]/[module](_[scalaVersion])(_[sbtVersion])/[revision]/[artifact]-[revision](-[classifier]).[ext]
+ // output : /Users/user/custom/repo/
+ def basePattern(pattern: String): String =
+ pattern.takeWhile(c => c != '[' && c != '(')
+
+ val baseIvyPattern = basePattern(patterns.ivyPatterns.head)
+ val baseArtifactPattern = basePattern(patterns.artifactPatterns.head)
+
+ if (baseIvyPattern == baseArtifactPattern)
+ Some(baseIvyPattern)
+ else
+ None
+ } else
+ None
+
+ private def mavenRepositoryOpt(
+ root: String,
+ log: Logger,
+ credentialsByHost: Map[String, Credentials]
+ ): Option[MavenRepository] =
+ try {
+ val rootURI = java.net.URI.create(
+ root
+ ) // ensure root is a URL whose protocol can be handled here
+ val root0 = if (root.endsWith("/")) root else root + "/"
+ val mavenRepository = MavenRepository.of(root0)
+
+ Some(
+ credentialsByHost
+ .get(rootURI.getHost)
+ .fold(mavenRepository)(mavenRepository.withCredentials)
+ )
+ } catch {
+ case e: MalformedURLException =>
+ log.warn(
+ "Error parsing Maven repository base " +
+ root +
+ Option(e.getMessage).fold("")(" (" + _ + ")") +
+ ", ignoring it"
+ )
+
+ None
+ }
+
+ // this handles whitespace in path
+ private def pathToUriString(path: String): String = {
+ val stopAtIdx = path.indexWhere(c => c == '[' || c == '$' || c == '(')
+ if (stopAtIdx > 0) {
+ val (pathPart, patternPart) = path.splitAt(stopAtIdx)
+ Paths.get(pathPart).toUri.toASCIIString + patternPart
+ } else if (stopAtIdx == 0)
+ "file://" + path
+ else
+ Paths.get(path).toUri.toASCIIString
+ }
+
+ def repository(
+ resolver: Resolver,
+ log: Logger,
+ credentialsByHost: Map[String, Credentials]
+ ): Option[Repository] =
+ resolver match {
+ case r: sbt.librarymanagement.MavenRepository =>
+ mavenRepositoryOpt(r.root, log, credentialsByHost)
+
+ case r: FileRepository
+ if r.patterns.ivyPatterns.lengthCompare(1) == 0 &&
+ r.patterns.artifactPatterns.lengthCompare(1) == 0 =>
+ val mavenCompatibleBaseOpt0 = mavenCompatibleBaseOpt(r.patterns)
+
+ mavenCompatibleBaseOpt0 match {
+ case None =>
+ val repo = IvyRepository
+ .of(pathToUriString(r.patterns.artifactPatterns.head))
+ .withMetadataPattern(pathToUriString(r.patterns.ivyPatterns.head))
+ .withDropInfoAttributes(true)
+
+ Some(repo)
+
+ case Some(mavenCompatibleBase) =>
+ mavenRepositoryOpt(
+ pathToUriString(mavenCompatibleBase),
+ log,
+ credentialsByHost
+ )
+ }
+
+ case r: URLRepository if patternMatchGuard(r.patterns) =>
+ parseMavenCompatResolver(log, r.patterns, credentialsByHost)
+
+ case raw: RawRepository
+ if raw.name == "inter-project" => // sbt.RawRepository.equals just compares names anyway
+ None
+
+ // Pattern Match resolver-type-specific RawRepositories
+ case IBiblioRepository(p) =>
+ parseMavenCompatResolver(
+ log,
+ p,
+ credentialsByHost
+ )
+
+ case other =>
+ log.warn(s"Unrecognized repository ${other.name}, ignoring it")
+ None
+ }
+
+ private object IBiblioRepository {
+
+ private def stringVector(v: java.util.List[_]): Vector[String] =
+ Option(v).map(_.asScala.toVector).getOrElse(Vector.empty).collect {
+ case s: String => s
+ }
+
+ private def patterns(resolver: IBiblioResolver): Patterns = Patterns(
+ ivyPatterns = stringVector(resolver.getIvyPatterns),
+ artifactPatterns = stringVector(resolver.getArtifactPatterns),
+ isMavenCompatible = resolver.isM2compatible,
+ descriptorOptional = !resolver.isUseMavenMetadata,
+ skipConsistencyCheck = !resolver.isCheckconsistency
+ )
+
+ def unapply(r: Resolver): Option[Patterns] =
+ r match {
+ case raw: RawRepository =>
+ raw.resolver match {
+ case b: IBiblioResolver =>
+ Some(patterns(b))
+ .filter(patternMatchGuard)
+ case _ =>
+ None
+ }
+ case _ =>
+ None
+ }
+ }
+
+ private def patternMatchGuard(patterns: Patterns): Boolean =
+ patterns.ivyPatterns.lengthCompare(1) == 0 &&
+ patterns.artifactPatterns.lengthCompare(1) == 0
+
+ private def parseMavenCompatResolver(
+ log: Logger,
+ patterns: Patterns,
+ credentialsByHost: Map[String, Credentials]
+ ): Option[Repository] = {
+ val mavenCompatibleBaseOpt0 = mavenCompatibleBaseOpt(patterns)
+
+ mavenCompatibleBaseOpt0 match {
+ case None =>
+ val repo = IvyRepository
+ .of(pathToUriString(patterns.artifactPatterns.head))
+ .withMetadataPattern(pathToUriString(patterns.ivyPatterns.head))
+ .withDropInfoAttributes(true)
+
+ Some(repo)
+
+ case Some(mavenCompatibleBase) =>
+ mavenRepositoryOpt(mavenCompatibleBase, log, credentialsByHost)
+ }
+ }
+}