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

Merge pull request #8196 from eed3si9n/wip/hide-ivy 

[2.x] refactor: Hide Ivy-related classes
This commit is contained in:
eugene yokota 2025-08-09 02:29:48 -04:00 committed by GitHub
parent a4ac406186 9e37218dcf
commit 09b9a97437
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
51 changed files with 281 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyPaths.scala → lm-core/src/main/contraband-scala/sbt/librarymanagement/IvyPaths.scala generated
View File

@ -3,7 +3,7 @@
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
package sbt.librarymanagement
final class IvyPaths private (
val baseDirectory: String,
val ivyHome: Option[String]) extends Serializable {
@ -15,7 +15,7 @@ final class IvyPaths private (
case _ => false
})
override def hashCode: Int = {
37 * (37 * (37 * (17 + "sbt.librarymanagement.ivy.IvyPaths".##) + baseDirectory.##) + ivyHome.##)
37 * (37 * (37 * (17 + "sbt.librarymanagement.IvyPaths".##) + baseDirectory.##) + ivyHome.##)
}
override def toString: String = {
"IvyPaths(" + baseDirectory + ", " + ivyHome + ")"

10
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyPathsFormats.scala → lm-core/src/main/contraband-scala/sbt/librarymanagement/IvyPathsFormats.scala generated
View File

@ -3,23 +3,23 @@
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
package sbt.librarymanagement
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait IvyPathsFormats { self: sjsonnew.BasicJsonProtocol =>
implicit lazy val IvyPathsFormat: JsonFormat[sbt.librarymanagement.ivy.IvyPaths] = new JsonFormat[sbt.librarymanagement.ivy.IvyPaths] {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ivy.IvyPaths = {
implicit lazy val IvyPathsFormat: JsonFormat[sbt.librarymanagement.IvyPaths] = new JsonFormat[sbt.librarymanagement.IvyPaths] {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.IvyPaths = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val baseDirectory = unbuilder.readField[String]("baseDirectory")
val ivyHome = unbuilder.readField[Option[String]]("ivyHome")
unbuilder.endObject()
sbt.librarymanagement.ivy.IvyPaths(baseDirectory, ivyHome)
sbt.librarymanagement.IvyPaths(baseDirectory, ivyHome)
case None =>
deserializationError("Expected JsObject but found None")
}
}
override def write[J](obj: sbt.librarymanagement.ivy.IvyPaths, builder: Builder[J]): Unit = {
override def write[J](obj: sbt.librarymanagement.IvyPaths, builder: Builder[J]): Unit = {
builder.beginObject()
builder.addField("baseDirectory", obj.baseDirectory)
builder.addField("ivyHome", obj.ivyHome)

1
lm-core/src/main/contraband-scala/sbt/librarymanagement/LibraryManagementCodec.scala generated
View File

@ -64,4 +64,5 @@ trait LibraryManagementCodec extends sbt.librarymanagement.ConfigRefFormats
with sbt.librarymanagement.UpdateReportFormats
with sbt.librarymanagement.ConfigurationReportLiteFormats
with sbt.librarymanagement.UpdateReportLiteFormats
with sbt.librarymanagement.IvyPathsFormats
object LibraryManagementCodec extends LibraryManagementCodec

10
lm-core/src/main/contraband/librarymanagement.json
View File

@ -864,6 +864,16 @@
"fields": [
{ "name": "configurations", "type": "sbt.internal.librarymanagement.ConfigurationReportLite*" }
]
},
{
"name": "IvyPaths",
"namespace": "sbt.librarymanagement",
"target": "Scala",
"type": "record",
"fields": [
{ "name": "baseDirectory", "type": "String" },
{ "name": "ivyHome", "type": "String?" }
]
}
]
}

40
lm-core/src/main/scala/sbt/librarymanagement/Credentials.scala Normal file
View File

@ -0,0 +1,40 @@
/*
* sbt
* Copyright 2023, Scala center
* Copyright 2011 - 2022, Lightbend, Inc.
* Copyright 2008 - 2010, Mark Harrah
* Licensed under Apache License 2.0 (see LICENSE)
*/
package sbt
package librarymanagement
import java.io.File
sealed trait Credentials
object Credentials:
def apply(realm: String, host: String, userName: String, passwd: String): Credentials =
new DirectCredentials(realm, host, userName, passwd)
def apply(file: File): Credentials =
new FileCredentials(file)
final class FileCredentials(val path: File) extends Credentials {
override def toString = s"""FileCredentials("$path")"""
}
final class DirectCredentials(
val realm: String,
val host: String,
val userName: String,
val passwd: String
) extends Credentials {
override def toString = {
val dq = '"'
val r =
if (realm == null) "null"
else s"$dq$realm$dq"
s"""DirectCredentials($r, "$host", "$userName", ****)"""
}
}
end Credentials

18
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/ExternalIvyConfiguration.scala → lm-ivy/src/main/contraband-scala/sbt/internal/librarymanagement/ivy/ExternalIvyConfiguration.scala generated
View File

@ -3,28 +3,28 @@
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
package sbt.internal.librarymanagement.ivy
final class ExternalIvyConfiguration private (
lock: Option[xsbti.GlobalLock],
log: Option[xsbti.Logger],
updateOptions: sbt.librarymanagement.ivy.UpdateOptions,
updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions,
val baseDirectory: Option[java.io.File],
val uri: Option[java.net.URI],
val extraResolvers: Vector[sbt.librarymanagement.Resolver]) extends sbt.librarymanagement.ivy.IvyConfiguration(lock, log, updateOptions) with Serializable {
val extraResolvers: Vector[sbt.librarymanagement.Resolver]) extends sbt.internal.librarymanagement.ivy.IvyConfiguration(lock, log, updateOptions) with Serializable {
private def this() = this(None, None, sbt.librarymanagement.ivy.UpdateOptions(), None, None, Vector())
private def this() = this(None, None, sbt.internal.librarymanagement.ivy.UpdateOptions(), None, None, Vector())
override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
case x: ExternalIvyConfiguration => (this.lock == x.lock) && (this.log == x.log) && (this.updateOptions == x.updateOptions) && (this.baseDirectory == x.baseDirectory) && (this.uri == x.uri) && (this.extraResolvers == x.extraResolvers)
case _ => false
})
override def hashCode: Int = {
37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ivy.ExternalIvyConfiguration".##) + lock.##) + log.##) + updateOptions.##) + baseDirectory.##) + uri.##) + extraResolvers.##)
37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.librarymanagement.ivy.ExternalIvyConfiguration".##) + lock.##) + log.##) + updateOptions.##) + baseDirectory.##) + uri.##) + extraResolvers.##)
}
override def toString: String = {
"ExternalIvyConfiguration(" + lock + ", " + log + ", " + updateOptions + ", " + baseDirectory + ", " + uri + ", " + extraResolvers + ")"
}
private def copy(lock: Option[xsbti.GlobalLock] = lock, log: Option[xsbti.Logger] = log, updateOptions: sbt.librarymanagement.ivy.UpdateOptions = updateOptions, baseDirectory: Option[java.io.File] = baseDirectory, uri: Option[java.net.URI] = uri, extraResolvers: Vector[sbt.librarymanagement.Resolver] = extraResolvers): ExternalIvyConfiguration = {
private def copy(lock: Option[xsbti.GlobalLock] = lock, log: Option[xsbti.Logger] = log, updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions = updateOptions, baseDirectory: Option[java.io.File] = baseDirectory, uri: Option[java.net.URI] = uri, extraResolvers: Vector[sbt.librarymanagement.Resolver] = extraResolvers): ExternalIvyConfiguration = {
new ExternalIvyConfiguration(lock, log, updateOptions, baseDirectory, uri, extraResolvers)
}
def withLock(lock: Option[xsbti.GlobalLock]): ExternalIvyConfiguration = {
@ -39,7 +39,7 @@ final class ExternalIvyConfiguration private (
def withLog(log: xsbti.Logger): ExternalIvyConfiguration = {
copy(log = Option(log))
}
def withUpdateOptions(updateOptions: sbt.librarymanagement.ivy.UpdateOptions): ExternalIvyConfiguration = {
def withUpdateOptions(updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions): ExternalIvyConfiguration = {
copy(updateOptions = updateOptions)
}
def withBaseDirectory(baseDirectory: Option[java.io.File]): ExternalIvyConfiguration = {
@ -61,6 +61,6 @@ final class ExternalIvyConfiguration private (
object ExternalIvyConfiguration {
def apply(): ExternalIvyConfiguration = new ExternalIvyConfiguration()
def apply(lock: Option[xsbti.GlobalLock], log: Option[xsbti.Logger], updateOptions: sbt.librarymanagement.ivy.UpdateOptions, baseDirectory: Option[java.io.File], uri: Option[java.net.URI], extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(lock, log, updateOptions, baseDirectory, uri, extraResolvers)
def apply(lock: xsbti.GlobalLock, log: xsbti.Logger, updateOptions: sbt.librarymanagement.ivy.UpdateOptions, baseDirectory: java.io.File, uri: java.net.URI, extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(Option(lock), Option(log), updateOptions, Option(baseDirectory), Option(uri), extraResolvers)
def apply(lock: Option[xsbti.GlobalLock], log: Option[xsbti.Logger], updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions, baseDirectory: Option[java.io.File], uri: Option[java.net.URI], extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(lock, log, updateOptions, baseDirectory, uri, extraResolvers)
def apply(lock: xsbti.GlobalLock, log: xsbti.Logger, updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions, baseDirectory: java.io.File, uri: java.net.URI, extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(Option(lock), Option(log), updateOptions, Option(baseDirectory), Option(uri), extraResolvers)
}

14
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/ExternalIvyConfigurationFormats.scala → lm-ivy/src/main/contraband-scala/sbt/internal/librarymanagement/ivy/ExternalIvyConfigurationFormats.scala generated
View File

@ -3,27 +3,27 @@
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
package sbt.internal.librarymanagement.ivy
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait ExternalIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat & sbt.internal.librarymanagement.formats.LoggerFormat & sbt.librarymanagement.ivy.formats.UpdateOptionsFormat & sbt.librarymanagement.ResolverFormats & sjsonnew.BasicJsonProtocol =>
implicit lazy val ExternalIvyConfigurationFormat: JsonFormat[sbt.librarymanagement.ivy.ExternalIvyConfiguration] = new JsonFormat[sbt.librarymanagement.ivy.ExternalIvyConfiguration] {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ivy.ExternalIvyConfiguration = {
trait ExternalIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat & sbt.internal.librarymanagement.formats.LoggerFormat & sbt.internal.librarymanagement.ivy.formats.UpdateOptionsFormat & sbt.librarymanagement.ResolverFormats & sjsonnew.BasicJsonProtocol =>
implicit lazy val ExternalIvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.ivy.ExternalIvyConfiguration] = new JsonFormat[sbt.internal.librarymanagement.ivy.ExternalIvyConfiguration] {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.ivy.ExternalIvyConfiguration = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val lock = unbuilder.readField[Option[xsbti.GlobalLock]]("lock")
val log = unbuilder.readField[Option[xsbti.Logger]]("log")
val updateOptions = unbuilder.readField[sbt.librarymanagement.ivy.UpdateOptions]("updateOptions")
val updateOptions = unbuilder.readField[sbt.internal.librarymanagement.ivy.UpdateOptions]("updateOptions")
val baseDirectory = unbuilder.readField[Option[java.io.File]]("baseDirectory")
val uri = unbuilder.readField[Option[java.net.URI]]("uri")
val extraResolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("extraResolvers")
unbuilder.endObject()
sbt.librarymanagement.ivy.ExternalIvyConfiguration(lock, log, updateOptions, baseDirectory, uri, extraResolvers)
sbt.internal.librarymanagement.ivy.ExternalIvyConfiguration(lock, log, updateOptions, baseDirectory, uri, extraResolvers)
case None =>
deserializationError("Expected JsObject but found None")
}
}
override def write[J](obj: sbt.librarymanagement.ivy.ExternalIvyConfiguration, builder: Builder[J]): Unit = {
override def write[J](obj: sbt.internal.librarymanagement.ivy.ExternalIvyConfiguration, builder: Builder[J]): Unit = {
builder.beginObject()
builder.addField("lock", obj.lock)
builder.addField("log", obj.log)

82
lm-ivy/src/main/contraband-scala/sbt/internal/librarymanagement/ivy/InlineIvyConfiguration.scala generated Normal file
View File

@ -0,0 +1,82 @@
/**
* This code is generated using [[https://www.scala-sbt.org/contraband]].
*/
// DO NOT EDIT MANUALLY
package sbt.internal.librarymanagement.ivy
final class InlineIvyConfiguration private (
lock: Option[xsbti.GlobalLock],
log: Option[xsbti.Logger],
updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions,
val paths: Option[sbt.librarymanagement.IvyPaths],
val resolvers: Vector[sbt.librarymanagement.Resolver],
val otherResolvers: Vector[sbt.librarymanagement.Resolver],
val moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration],
val checksums: Vector[String],
val managedChecksums: Boolean,
val resolutionCacheDir: Option[java.io.File]) extends sbt.internal.librarymanagement.ivy.IvyConfiguration(lock, log, updateOptions) with Serializable {
private def this() = this(None, None, sbt.internal.librarymanagement.ivy.UpdateOptions(), None, sbt.librarymanagement.Resolver.defaults, Vector.empty, Vector.empty, sbt.internal.librarymanagement.ivy.IvyDefaults.defaultChecksums, false, None)
override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
case x: InlineIvyConfiguration => (this.lock == x.lock) && (this.log == x.log) && (this.updateOptions == x.updateOptions) && (this.paths == x.paths) && (this.resolvers == x.resolvers) && (this.otherResolvers == x.otherResolvers) && (this.moduleConfigurations == x.moduleConfigurations) && (this.checksums == x.checksums) && (this.managedChecksums == x.managedChecksums) && (this.resolutionCacheDir == x.resolutionCacheDir)
case _ => false
})
override def hashCode: Int = {
37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.librarymanagement.ivy.InlineIvyConfiguration".##) + lock.##) + log.##) + updateOptions.##) + paths.##) + resolvers.##) + otherResolvers.##) + moduleConfigurations.##) + checksums.##) + managedChecksums.##) + resolutionCacheDir.##)
}
override def toString: String = {
"InlineIvyConfiguration(" + lock + ", " + log + ", " + updateOptions + ", " + paths + ", " + resolvers + ", " + otherResolvers + ", " + moduleConfigurations + ", " + checksums + ", " + managedChecksums + ", " + resolutionCacheDir + ")"
}
private def copy(lock: Option[xsbti.GlobalLock] = lock, log: Option[xsbti.Logger] = log, updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions = updateOptions, paths: Option[sbt.librarymanagement.IvyPaths] = paths, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers, otherResolvers: Vector[sbt.librarymanagement.Resolver] = otherResolvers, moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration] = moduleConfigurations, checksums: Vector[String] = checksums, managedChecksums: Boolean = managedChecksums, resolutionCacheDir: Option[java.io.File] = resolutionCacheDir): InlineIvyConfiguration = {
new InlineIvyConfiguration(lock, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
}
def withLock(lock: Option[xsbti.GlobalLock]): InlineIvyConfiguration = {
copy(lock = lock)
}
def withLock(lock: xsbti.GlobalLock): InlineIvyConfiguration = {
copy(lock = Option(lock))
}
def withLog(log: Option[xsbti.Logger]): InlineIvyConfiguration = {
copy(log = log)
}
def withLog(log: xsbti.Logger): InlineIvyConfiguration = {
copy(log = Option(log))
}
def withUpdateOptions(updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions): InlineIvyConfiguration = {
copy(updateOptions = updateOptions)
}
def withPaths(paths: Option[sbt.librarymanagement.IvyPaths]): InlineIvyConfiguration = {
copy(paths = paths)
}
def withPaths(paths: sbt.librarymanagement.IvyPaths): InlineIvyConfiguration = {
copy(paths = Option(paths))
}
def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = {
copy(resolvers = resolvers)
}
def withOtherResolvers(otherResolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = {
copy(otherResolvers = otherResolvers)
}
def withModuleConfigurations(moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration]): InlineIvyConfiguration = {
copy(moduleConfigurations = moduleConfigurations)
}
def withChecksums(checksums: Vector[String]): InlineIvyConfiguration = {
copy(checksums = checksums)
}
def withManagedChecksums(managedChecksums: Boolean): InlineIvyConfiguration = {
copy(managedChecksums = managedChecksums)
}
def withResolutionCacheDir(resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = {
copy(resolutionCacheDir = resolutionCacheDir)
}
def withResolutionCacheDir(resolutionCacheDir: java.io.File): InlineIvyConfiguration = {
copy(resolutionCacheDir = Option(resolutionCacheDir))
}
}
object InlineIvyConfiguration {
def apply(): InlineIvyConfiguration = new InlineIvyConfiguration()
def apply(lock: Option[xsbti.GlobalLock], log: Option[xsbti.Logger], updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions, paths: Option[sbt.librarymanagement.IvyPaths], resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = new InlineIvyConfiguration(lock, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
def apply(lock: xsbti.GlobalLock, log: xsbti.Logger, updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions, paths: sbt.librarymanagement.IvyPaths, resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: java.io.File): InlineIvyConfiguration = new InlineIvyConfiguration(Option(lock), Option(log), updateOptions, Option(paths), resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, Option(resolutionCacheDir))
}

16
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/InlineIvyConfigurationFormats.scala → lm-ivy/src/main/contraband-scala/sbt/internal/librarymanagement/ivy/InlineIvyConfigurationFormats.scala generated
View File

@ -3,18 +3,18 @@
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
package sbt.internal.librarymanagement.ivy
import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
trait InlineIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat & sbt.internal.librarymanagement.formats.LoggerFormat & sbt.librarymanagement.ivy.formats.UpdateOptionsFormat & sbt.librarymanagement.ivy.IvyPathsFormats & sjsonnew.BasicJsonProtocol & sbt.librarymanagement.ResolverFormats & sbt.librarymanagement.ModuleConfigurationFormats =>
implicit lazy val InlineIvyConfigurationFormat: JsonFormat[sbt.librarymanagement.ivy.InlineIvyConfiguration] = new JsonFormat[sbt.librarymanagement.ivy.InlineIvyConfiguration] {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ivy.InlineIvyConfiguration = {
trait InlineIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat & sbt.internal.librarymanagement.formats.LoggerFormat & sbt.internal.librarymanagement.ivy.formats.UpdateOptionsFormat & sbt.librarymanagement.IvyPathsFormats & sbt.librarymanagement.ResolverFormats & sbt.librarymanagement.ModuleConfigurationFormats & sjsonnew.BasicJsonProtocol =>
implicit lazy val InlineIvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.ivy.InlineIvyConfiguration] = new JsonFormat[sbt.internal.librarymanagement.ivy.InlineIvyConfiguration] {
override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.ivy.InlineIvyConfiguration = {
__jsOpt match {
case Some(__js) =>
unbuilder.beginObject(__js)
val lock = unbuilder.readField[Option[xsbti.GlobalLock]]("lock")
val log = unbuilder.readField[Option[xsbti.Logger]]("log")
val updateOptions = unbuilder.readField[sbt.librarymanagement.ivy.UpdateOptions]("updateOptions")
val paths = unbuilder.readField[Option[sbt.librarymanagement.ivy.IvyPaths]]("paths")
val updateOptions = unbuilder.readField[sbt.internal.librarymanagement.ivy.UpdateOptions]("updateOptions")
val paths = unbuilder.readField[Option[sbt.librarymanagement.IvyPaths]]("paths")
val resolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("resolvers")
val otherResolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("otherResolvers")
val moduleConfigurations = unbuilder.readField[Vector[sbt.librarymanagement.ModuleConfiguration]]("moduleConfigurations")
@ -22,12 +22,12 @@ implicit lazy val InlineIvyConfigurationFormat: JsonFormat[sbt.librarymanagement
val managedChecksums = unbuilder.readField[Boolean]("managedChecksums")
val resolutionCacheDir = unbuilder.readField[Option[java.io.File]]("resolutionCacheDir")
unbuilder.endObject()
sbt.librarymanagement.ivy.InlineIvyConfiguration(lock, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
sbt.internal.librarymanagement.ivy.InlineIvyConfiguration(lock, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
case None =>
deserializationError("Expected JsObject but found None")
}
}
override def write[J](obj: sbt.librarymanagement.ivy.InlineIvyConfiguration, builder: Builder[J]): Unit = {
override def write[J](obj: sbt.internal.librarymanagement.ivy.InlineIvyConfiguration, builder: Builder[J]): Unit = {
builder.beginObject()
builder.addField("lock", obj.lock)
builder.addField("log", obj.log)

8
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyConfiguration.scala → lm-ivy/src/main/contraband-scala/sbt/internal/librarymanagement/ivy/IvyConfiguration.scala generated
View File

@ -3,13 +3,13 @@
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
package sbt.internal.librarymanagement.ivy
abstract class IvyConfiguration(
val lock: Option[xsbti.GlobalLock],
val log: Option[xsbti.Logger],
val updateOptions: sbt.librarymanagement.ivy.UpdateOptions) extends Serializable {
val updateOptions: sbt.internal.librarymanagement.ivy.UpdateOptions) extends Serializable {
def this() = this(None, None, sbt.librarymanagement.ivy.UpdateOptions())
def this() = this(None, None, sbt.internal.librarymanagement.ivy.UpdateOptions())
override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
@ -17,7 +17,7 @@ abstract class IvyConfiguration(
case _ => false
})
override def hashCode: Int = {
37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ivy.IvyConfiguration".##) + lock.##) + log.##) + updateOptions.##)
37 * (37 * (37 * (37 * (17 + "sbt.internal.librarymanagement.ivy.IvyConfiguration".##) + lock.##) + log.##) + updateOptions.##)
}
override def toString: String = {
"IvyConfiguration(" + lock + ", " + log + ", " + updateOptions + ")"

11
lm-ivy/src/main/contraband-scala/sbt/internal/librarymanagement/ivy/IvyConfigurationFormats.scala generated Normal file
View File

@ -0,0 +1,11 @@
/**
* This code is generated using [[https://www.scala-sbt.org/contraband]].
*/
// DO NOT EDIT MANUALLY
package sbt.internal.librarymanagement.ivy
import _root_.sjsonnew.JsonFormat
trait IvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat & sbt.internal.librarymanagement.formats.LoggerFormat & sbt.internal.librarymanagement.ivy.formats.UpdateOptionsFormat & sbt.librarymanagement.IvyPathsFormats & sbt.librarymanagement.ResolverFormats & sbt.librarymanagement.ModuleConfigurationFormats & sjsonnew.BasicJsonProtocol & sbt.internal.librarymanagement.ivy.InlineIvyConfigurationFormats & sbt.internal.librarymanagement.ivy.ExternalIvyConfigurationFormats =>
implicit lazy val IvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.ivy.IvyConfiguration] = flatUnionFormat2[sbt.internal.librarymanagement.ivy.IvyConfiguration, sbt.internal.librarymanagement.ivy.InlineIvyConfiguration, sbt.internal.librarymanagement.ivy.ExternalIvyConfiguration]("type")
}

105
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/InlineIvyConfiguration.scala generated
View File

@ -1,105 +0,0 @@
/**
* This code is generated using [[https://www.scala-sbt.org/contraband]].
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
final class InlineIvyConfiguration private (
lock: Option[xsbti.GlobalLock],
log: Option[xsbti.Logger],
updateOptions: sbt.librarymanagement.ivy.UpdateOptions,
val paths: Option[sbt.librarymanagement.ivy.IvyPaths],
val resolvers: Vector[sbt.librarymanagement.Resolver],
val otherResolvers: Vector[sbt.librarymanagement.Resolver],
val moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration],
val checksums: Vector[String],
val managedChecksums: Boolean,
val resolutionCacheDir: Option[java.io.File]) extends sbt.librarymanagement.ivy.IvyConfiguration(lock, log, updateOptions) with Serializable {
private def this() = this(None, None, sbt.librarymanagement.ivy.UpdateOptions(), None, sbt.librarymanagement.Resolver.defaults, Vector.empty, Vector.empty, sbt.librarymanagement.ivy.IvyDefaults.defaultChecksums, false, None)
override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
case x: InlineIvyConfiguration => (this.lock == x.lock) && (this.log == x.log) && (this.updateOptions == x.updateOptions) && (this.paths == x.paths) && (this.resolvers == x.resolvers) && (this.otherResolvers == x.otherResolvers) && (this.moduleConfigurations == x.moduleConfigurations) && (this.checksums == x.checksums) && (this.managedChecksums == x.managedChecksums) && (this.resolutionCacheDir == x.resolutionCacheDir)
case _ => false
})
override def hashCode: Int = {
37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ivy.InlineIvyConfiguration".##) + lock.##) + log.##) + updateOptions.##) + paths.##) + resolvers.##) + otherResolvers.##) + moduleConfigurations.##) + checksums.##) + managedChecksums.##) + resolutionCacheDir.##)
}
override def toString: String = {
"InlineIvyConfiguration(" + lock + ", " + log + ", " + updateOptions + ", " + paths + ", " + resolvers + ", " + otherResolvers + ", " + moduleConfigurations + ", " + checksums + ", " + managedChecksums + ", " + resolutionCacheDir + ")"
}
private def copy(lock: Option[xsbti.GlobalLock] = lock, log: Option[xsbti.Logger] = log, updateOptions: sbt.librarymanagement.ivy.UpdateOptions = updateOptions, paths: Option[sbt.librarymanagement.ivy.IvyPaths] = paths, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers, otherResolvers: Vector[sbt.librarymanagement.Resolver] = otherResolvers, moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration] = moduleConfigurations, checksums: Vector[String] = checksums, managedChecksums: Boolean = managedChecksums, resolutionCacheDir: Option[java.io.File] = resolutionCacheDir): InlineIvyConfiguration = {
new InlineIvyConfiguration(lock, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
}
def withLock(lock: Option[xsbti.GlobalLock]): InlineIvyConfiguration = {
copy(lock = lock)
}
def withLock(lock: xsbti.GlobalLock): InlineIvyConfiguration = {
copy(lock = Option(lock))
}
def withLog(log: Option[xsbti.Logger]): InlineIvyConfiguration = {
copy(log = log)
}
def withLog(log: xsbti.Logger): InlineIvyConfiguration = {
copy(log = Option(log))
}
def withUpdateOptions(updateOptions: sbt.librarymanagement.ivy.UpdateOptions): InlineIvyConfiguration = {
copy(updateOptions = updateOptions)
}
def withPaths(paths: Option[sbt.librarymanagement.ivy.IvyPaths]): InlineIvyConfiguration = {
copy(paths = paths)
}
def withPaths(paths: sbt.librarymanagement.ivy.IvyPaths): InlineIvyConfiguration = {
copy(paths = Option(paths))
}
def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = {
copy(resolvers = resolvers)
}
def withOtherResolvers(otherResolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = {
copy(otherResolvers = otherResolvers)
}
def withModuleConfigurations(moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration]): InlineIvyConfiguration = {
copy(moduleConfigurations = moduleConfigurations)
}
def withChecksums(checksums: Vector[String]): InlineIvyConfiguration = {
copy(checksums = checksums)
}
def withManagedChecksums(managedChecksums: Boolean): InlineIvyConfiguration = {
copy(managedChecksums = managedChecksums)
}
def withResolutionCacheDir(resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = {
copy(resolutionCacheDir = resolutionCacheDir)
}
def withResolutionCacheDir(resolutionCacheDir: java.io.File): InlineIvyConfiguration = {
copy(resolutionCacheDir = Option(resolutionCacheDir))
}
}
object InlineIvyConfiguration {
/** Provided for backward compatibility. */
@deprecated("Use an alternative apply", "1.2.0")
def apply(
paths: sbt.librarymanagement.ivy.IvyPaths,
resolvers: Vector[sbt.librarymanagement.Resolver],
otherResolvers: Vector[sbt.librarymanagement.Resolver],
moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration],
lock: Option[xsbti.GlobalLock],
checksums: Vector[String],
managedChecksums: Boolean,
resolutionCacheDir: Option[java.io.File],
updateOptions: sbt.librarymanagement.ivy.UpdateOptions,
log: xsbti.Logger
): InlineIvyConfiguration = {
apply()
.withLock(lock)
.withResolvers(resolvers)
.withOtherResolvers(otherResolvers)
.withModuleConfigurations(moduleConfigurations)
.withChecksums(checksums)
.withManagedChecksums(managedChecksums)
.withResolutionCacheDir(resolutionCacheDir)
.withLog(log)
}
def apply(): InlineIvyConfiguration = new InlineIvyConfiguration()
def apply(lock: Option[xsbti.GlobalLock], log: Option[xsbti.Logger], updateOptions: sbt.librarymanagement.ivy.UpdateOptions, paths: Option[sbt.librarymanagement.ivy.IvyPaths], resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = new InlineIvyConfiguration(lock, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
def apply(lock: xsbti.GlobalLock, log: xsbti.Logger, updateOptions: sbt.librarymanagement.ivy.UpdateOptions, paths: sbt.librarymanagement.ivy.IvyPaths, resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: java.io.File): InlineIvyConfiguration = new InlineIvyConfiguration(Option(lock), Option(log), updateOptions, Option(paths), resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, Option(resolutionCacheDir))
}

11
lm-ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyConfigurationFormats.scala generated
View File

@ -1,11 +0,0 @@
/**
* This code is generated using [[https://www.scala-sbt.org/contraband]].
*/
// DO NOT EDIT MANUALLY
package sbt.librarymanagement.ivy
import _root_.sjsonnew.JsonFormat
trait IvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat & sbt.internal.librarymanagement.formats.LoggerFormat & sbt.librarymanagement.ivy.formats.UpdateOptionsFormat & sbt.librarymanagement.ivy.IvyPathsFormats & sjsonnew.BasicJsonProtocol & sbt.librarymanagement.ResolverFormats & sbt.librarymanagement.ModuleConfigurationFormats & sbt.librarymanagement.ivy.InlineIvyConfigurationFormats & sbt.librarymanagement.ivy.ExternalIvyConfigurationFormats =>
implicit lazy val IvyConfigurationFormat: JsonFormat[sbt.librarymanagement.ivy.IvyConfiguration] = flatUnionFormat2[sbt.librarymanagement.ivy.IvyConfiguration, sbt.librarymanagement.ivy.InlineIvyConfiguration, sbt.librarymanagement.ivy.ExternalIvyConfiguration]("type")
}

58
lm-ivy/src/main/contraband/lm-ivy.json
View File

@ -1,9 +1,9 @@
{
"codecNamespace": "sbt.librarymanagement.ivy",
"codecNamespace": "sbt.internal.librarymanagement.ivy",
"types": [
{
"name": "IvyConfiguration",
"namespace": "sbt.librarymanagement.ivy",
"namespace": "sbt.internal.librarymanagement.ivy",
"target": "Scala",
"type": "interface",
"fields": [
@ -13,7 +13,7 @@
"default": "None",
"since": "0.0.1"
},
{
{
"name": "log",
"type": "xsbti.Logger?",
"default": "None",
@ -21,25 +21,25 @@
},
{
"name": "updateOptions",
"type": "sbt.librarymanagement.ivy.UpdateOptions",
"default": "sbt.librarymanagement.ivy.UpdateOptions()",
"type": "sbt.internal.librarymanagement.ivy.UpdateOptions",
"default": "sbt.internal.librarymanagement.ivy.UpdateOptions()",
"since": "0.0.1"
}
],
"types": [
{
"name": "InlineIvyConfiguration",
"namespace": "sbt.librarymanagement.ivy",
"namespace": "sbt.internal.librarymanagement.ivy",
"target": "Scala",
"type": "record",
"fields": [
{
{
"name": "paths",
"type": "sbt.librarymanagement.ivy.IvyPaths?",
"type": "sbt.librarymanagement.IvyPaths?",
"default": "None",
"since": "0.0.1"
},
{
{
"name": "resolvers",
"type": "sbt.librarymanagement.Resolver*",
"default": "sbt.librarymanagement.Resolver.defaults",
@ -60,7 +60,7 @@
{
"name": "checksums",
"type": "String*",
"default": "sbt.librarymanagement.ivy.IvyDefaults.defaultChecksums",
"default": "sbt.internal.librarymanagement.ivy.IvyDefaults.defaultChecksums",
"since": "0.0.1"
},
{
@ -75,37 +75,11 @@
"default": "None",
"since": "0.0.1"
}
],
"extraCompanion": [
"/** Provided for backward compatibility. */",
"@deprecated(\"Use an alternative apply\", \"1.2.0\")",
"def apply(",
" paths: sbt.librarymanagement.ivy.IvyPaths,",
" resolvers: Vector[sbt.librarymanagement.Resolver],",
" otherResolvers: Vector[sbt.librarymanagement.Resolver],",
" moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration],",
" lock: Option[xsbti.GlobalLock],",
" checksums: Vector[String],",
" managedChecksums: Boolean,",
" resolutionCacheDir: Option[java.io.File],",
" updateOptions: sbt.librarymanagement.ivy.UpdateOptions,",
" log: xsbti.Logger",
"): InlineIvyConfiguration = {",
" apply()",
" .withLock(lock)",
" .withResolvers(resolvers)",
" .withOtherResolvers(otherResolvers)",
" .withModuleConfigurations(moduleConfigurations)",
" .withChecksums(checksums)",
" .withManagedChecksums(managedChecksums)",
" .withResolutionCacheDir(resolutionCacheDir)",
" .withLog(log)",
"}"
]
},
{
"name": "ExternalIvyConfiguration",
"namespace": "sbt.librarymanagement.ivy",
"namespace": "sbt.internal.librarymanagement.ivy",
"target": "Scala",
"type": "record",
"fields": [
@ -130,16 +104,6 @@
]
}
]
},
{
"name": "IvyPaths",
"namespace": "sbt.librarymanagement.ivy",
"target": "Scala",
"type": "record",
"fields": [
{ "name": "baseDirectory", "type": "String" },
{ "name": "ivyHome", "type": "String?" }
]
}
]
}

2
lm-ivy/src/main/scala/sbt/internal/librarymanagement/ConvertResolver.scala
View File

@ -36,11 +36,11 @@ import org.apache.ivy.core.report.DownloadReport
import org.apache.ivy.plugins.resolver.util.{ ResolvedResource, ResourceMDParser }
import org.apache.ivy.util.{ ChecksumHelper, FileUtil, Message }
import scala.jdk.CollectionConverters.*
import sbt.internal.librarymanagement.ivy.UpdateOptions
import sbt.internal.librarymanagement.mavenint.PomExtraDependencyAttributes
import sbt.io.IO
import sbt.util.Logger
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.UpdateOptions
private[sbt] object ConvertResolver {
import UpdateOptions.ResolverConverter

2
lm-ivy/src/main/scala/sbt/internal/librarymanagement/Ivy.scala
View File

@ -39,8 +39,8 @@ import scala.collection.mutable
import scala.collection.immutable.ArraySeq
import scala.util.{ Success, Failure }
import sbt.util.*
import sbt.internal.librarymanagement.ivy.*
import sbt.librarymanagement.{ ModuleDescriptorConfiguration as InlineConfiguration, * }
import sbt.librarymanagement.ivy.*
import sbt.librarymanagement.syntax.*
import IvyInternalDefaults.*

2
lm-ivy/src/main/scala/sbt/internal/librarymanagement/IvyCache.scala
View File

@ -16,8 +16,8 @@ import org.apache.ivy.plugins.repository.{ ArtifactResourceResolver, Resource, R
import org.apache.ivy.plugins.resolver.util.ResolvedResource
import org.apache.ivy.util.FileUtil
import sbt.io.Path
import sbt.internal.librarymanagement.ivy.InlineIvyConfiguration
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.{ InlineIvyConfiguration, IvyPaths }
import sbt.util.Logger
class NotInCache(val id: ModuleID, cause: Throwable)

2
lm-ivy/src/main/scala/sbt/internal/librarymanagement/IvyInternalDefaults.scala
View File

@ -2,7 +2,7 @@ package sbt
package internal.librarymanagement
import java.io.File
import sbt.librarymanagement.ivy.*
import sbt.librarymanagement.IvyPaths
import sbt.io.syntax.*
import xsbti.{ Logger as XLogger }
import sbt.util.Logger

2
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/CircularDependencyLevel.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/CircularDependencyLevel.scala
View File

@ -1,4 +1,4 @@
package sbt.librarymanagement
package sbt.internal.librarymanagement
package ivy
import org.apache.ivy.plugins.circular.{

51
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/Credentials.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/IvyCredentials.scala
View File

@ -1,20 +1,17 @@
/* sbt -- Simple Build Tool
* Copyright 2009 Mark Harrah
*/
package sbt.librarymanagement
package sbt.internal.librarymanagement
package ivy
import java.io.File
import org.apache.ivy.util.url.CredentialsStore
import sbt.io.IO
import sbt.util.Logger
import sbt.internal.librarymanagement.IvyUtil
import sbt.io.IO
import sbt.librarymanagement.Credentials
import sbt.util.Logger
object Credentials {
def apply(realm: String, host: String, userName: String, passwd: String): Credentials =
new DirectCredentials(realm, host, userName, passwd)
def apply(file: File): Credentials =
new FileCredentials(file)
object IvyCredentials {
/** Add the provided credentials to Ivy's credentials cache. */
def add(realm: String, host: String, userName: String, passwd: String): Unit =
@ -28,17 +25,17 @@ object Credentials {
}
def forHost(sc: Seq[Credentials], host: String) = allDirect(sc) find { _.host == host }
def allDirect(sc: Seq[Credentials]): Seq[DirectCredentials] = sc map toDirect
def toDirect(c: Credentials): DirectCredentials = c match {
case dc: DirectCredentials => dc
case fc: FileCredentials =>
def allDirect(sc: Seq[Credentials]): Seq[Credentials.DirectCredentials] = sc map toDirect
def toDirect(c: Credentials): Credentials.DirectCredentials = c match {
case dc: Credentials.DirectCredentials => dc
case fc: Credentials.FileCredentials =>
loadCredentials(fc.path) match {
case Left(err) => sys.error(err)
case Right(dc) => dc
}
}
def loadCredentials(path: File): Either[String, DirectCredentials] =
def loadCredentials(path: File): Either[String, Credentials.DirectCredentials] =
if (path.exists) {
val properties = read(path)
def get(keys: List[String]): Either[String, String] =
@ -50,16 +47,17 @@ object Credentials {
IvyUtil.separate(List(HostKeys, UserKeys, PasswordKeys).map(get)) match
case (Nil, List(host: String, user: String, pass: String)) =>
IvyUtil.separate(List(RealmKeys).map(get)) match
case (_, List(realm: String)) => Right(new DirectCredentials(realm, host, user, pass))
case _ => Right(new DirectCredentials(null, host, user, pass))
case (_, List(realm: String)) =>
Right(new Credentials.DirectCredentials(realm, host, user, pass))
case _ => Right(new Credentials.DirectCredentials(null, host, user, pass))
case (errors, _) => Left(errors.mkString("\n"))
} else Left("Credentials file " + path + " does not exist")
def register(cs: Seq[Credentials], log: Logger): Unit =
cs foreach {
case f: FileCredentials => add(f.path, log)
case d: DirectCredentials => add(d.realm, d.host, d.userName, d.passwd)
case f: Credentials.FileCredentials => add(f.path, log)
case d: Credentials.DirectCredentials => add(d.realm, d.host, d.userName, d.passwd)
}
private val RealmKeys = List("realm")
@ -74,22 +72,3 @@ object Credentials {
properties.asScala.map { (k, v) => (k.toString, v.toString.trim) }.toMap
}
}
sealed trait Credentials
final class FileCredentials(val path: File) extends Credentials {
override def toString = s"""FileCredentials("$path")"""
}
final class DirectCredentials(
val realm: String,
val host: String,
val userName: String,
val passwd: String
) extends Credentials {
override def toString = {
val dq = '"'
val r =
if (realm == null) "null"
else s"$dq$realm$dq"
s"""DirectCredentials($r, "$host", "$userName", ****)"""
}
}

1
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/IvyDefaults.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/IvyDefaults.scala
View File

@ -1,4 +1,5 @@
package sbt
package internal
package librarymanagement.ivy
/**

3
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/IvyDependencyResolution.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/IvyDependencyResolution.scala
View File

@ -1,8 +1,9 @@
package sbt
package internal
package librarymanagement
package ivy
import sbt.internal.librarymanagement.*
import sbt.librarymanagement.*
import sbt.util.Logger
class IvyDependencyResolution private[sbt] (val ivySbt: IvySbt)

12
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/IvyLibraryManagementCodec.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/IvyLibraryManagementCodec.scala
View File

@ -1,15 +1,15 @@
package sbt.librarymanagement
package sbt.internal.librarymanagement
package ivy
trait IvyLibraryManagementCodec
extends sjsonnew.BasicJsonProtocol
with LibraryManagementCodec
with sbt.librarymanagement.LibraryManagementCodec
with sbt.internal.librarymanagement.formats.GlobalLockFormat
with sbt.internal.librarymanagement.formats.LoggerFormat
with sbt.librarymanagement.ivy.formats.UpdateOptionsFormat
with IvyPathsFormats
with ResolverFormats
with ModuleConfigurationFormats
with sbt.internal.librarymanagement.ivy.formats.UpdateOptionsFormat
with sbt.librarymanagement.IvyPathsFormats
with sbt.librarymanagement.ResolverFormats
with sbt.librarymanagement.ModuleConfigurationFormats
with InlineIvyConfigurationFormats
with ExternalIvyConfigurationFormats
with IvyConfigurationFormats

3
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/IvyPublisher.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/IvyPublisher.scala
View File

@ -1,8 +1,9 @@
package sbt
package internal
package librarymanagement
package ivy
import sbt.internal.librarymanagement.*
import sbt.librarymanagement.*
import sbt.util.Logger
import java.io.File

4
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/UpdateOptions.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/UpdateOptions.scala
View File

@ -1,10 +1,10 @@
package sbt.librarymanagement
package sbt.internal.librarymanagement
package ivy
import org.apache.ivy.plugins.resolver.DependencyResolver
import org.apache.ivy.core.settings.IvySettings
import sbt.util.Logger
import sbt.internal.librarymanagement.LMSysProp
import sbt.librarymanagement.*
/**
* Represents configurable options for update task.

2
lm-ivy/src/main/scala/sbt/librarymanagement/ivy/formats/UpdateOptionsFormat.scala → lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivy/formats/UpdateOptionsFormat.scala
View File

@ -1,4 +1,4 @@
package sbt.librarymanagement.ivy
package sbt.internal.librarymanagement.ivy
package formats
import sjsonnew.*

2
lm-ivy/src/main/scala/sbt/internal/librarymanagement/ivyint/SbtChainResolver.scala
View File

@ -21,7 +21,7 @@ import org.apache.ivy.plugins.resolver.util.{ HasLatestStrategy, ResolvedResourc
import org.apache.ivy.util.{ Message, StringUtils as IvyStringUtils }
import sbt.util.Logger
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.UpdateOptions
import sbt.internal.librarymanagement.ivy.UpdateOptions
import scala.util.control.NonFatal

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/BaseCachedResolutionSpec.scala
View File

@ -1,7 +1,7 @@
package sbt.internal.librarymanagement
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.*
import sbt.internal.librarymanagement.ivy.*
trait BaseCachedResolutionSpec extends BaseIvySpecification {
override def module(

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/BaseIvySpecification.scala
View File

@ -3,9 +3,9 @@ package sbt.internal.librarymanagement
import sbt.io.IO
import sbt.io.syntax.*
import java.io.File
import sbt.internal.librarymanagement.ivy.*
import sbt.internal.util.ConsoleLogger
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.*
import cross.CrossVersionUtil
import Configurations.*

5
lm-ivy/src/test/scala/sbt/internal/librarymanagement/CredentialsSpec.scala
View File

@ -1,6 +1,7 @@
package sbt.internal.librarymanagement
import sbt.librarymanagement.ivy.Credentials
import sbt.internal.librarymanagement.ivy.IvyCredentials
import sbt.librarymanagement.Credentials
import java.io.File
import java.nio.file.Files
@ -19,7 +20,7 @@ class CredentialsSpec extends AnyFunSuite {
Files.write(credentialsFile.toPath(), content.getBytes())
val Right(credentials) = Credentials.loadCredentials(credentialsFile): @unchecked
val Right(credentials) = IvyCredentials.loadCredentials(credentialsFile): @unchecked
assert(credentials.realm == null)

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/CustomPomParserTest.scala
View File

@ -4,8 +4,8 @@ import java.io.File
import org.apache.ivy.core.module.descriptor.{ Artifact as IvyArtifact }
import org.apache.ivy.core.module.id.ModuleRevisionId
import org.apache.ivy.core.resolve.ResolveOptions
import sbt.internal.librarymanagement.ivy.InlineIvyConfiguration
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.{ InlineIvyConfiguration, IvyPaths }
import sbt.io.IO.withTemporaryDirectory
import sbt.internal.util.ConsoleLogger
import verify.BasicTestSuite

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/FrozenModeSpec.scala
View File

@ -1,7 +1,7 @@
package sbt.internal.librarymanagement
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.UpdateOptions
import sbt.internal.librarymanagement.ivy.UpdateOptions
import sbt.librarymanagement.syntax.*
object FrozenModeSpec extends BaseIvySpecification {

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/ManagedChecksumsSpec.scala
View File

@ -1,8 +1,8 @@
package sbt.internal.librarymanagement
import org.apache.ivy.util.Message
import sbt.internal.librarymanagement.ivy.*
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.*
import sbt.io.IO
object ManagedChecksumsSpec extends BaseIvySpecification {

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/MergeDescriptorSpec.scala
View File

@ -2,7 +2,7 @@ package sbt.internal.librarymanagement
import org.apache.ivy.core.module.descriptor.DependencyArtifactDescriptor
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.UpdateOptions
import sbt.internal.librarymanagement.ivy.UpdateOptions
import sbt.internal.librarymanagement.ivyint.*
object MergeDescriptorSpec extends BaseIvySpecification {

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/ModuleResolversTest.scala
View File

@ -2,7 +2,7 @@ package sbt.internal.librarymanagement
import sbt.librarymanagement.*
import sbt.librarymanagement.syntax.*
import sbt.librarymanagement.ivy.UpdateOptions
import sbt.internal.librarymanagement.ivy.UpdateOptions
object ModuleResolversTest extends BaseIvySpecification {
override final val resolvers = Vector(

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/OfflineModeSpec.scala
View File

@ -1,7 +1,7 @@
package sbt.internal.librarymanagement
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.UpdateOptions
import sbt.internal.librarymanagement.ivy.UpdateOptions
import sbt.io.IO
object OfflineModeSpec extends BaseIvySpecification {

2
lm-ivy/src/test/scala/sbt/internal/librarymanagement/UpdateOptionsSpec.scala
View File

@ -1,6 +1,6 @@
package sbt.internal.librarymanagement
import sbt.librarymanagement.ivy.*
import sbt.internal.librarymanagement.ivy.*
import verify.BasicTestSuite
class UpdateOptionsSpec extends BasicTestSuite {

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

@ -33,6 +33,7 @@ import sbt.internal.classpath.AlternativeZincUtil
import sbt.internal.inc.JavaInterfaceUtil.*
import sbt.internal.inc.classpath.{ ClasspathFilter, ClasspathUtil }
import sbt.internal.inc.{ CompileOutput, MappedFileConverter, Stamps, ZincLmUtil, ZincUtil }
import sbt.internal.librarymanagement.ivy.*
import sbt.internal.librarymanagement.mavenint.{
PomExtraDependencyAttributes,
SbtPomExtraProperties
@ -61,7 +62,6 @@ import sbt.librarymanagement.Artifact.{ DocClassifier, SourceClassifier }
import sbt.librarymanagement.Configurations.{ Compile, CompilerPlugin, Provided, Runtime, Test }
import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion }
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.*
import sbt.librarymanagement.syntax.*
import sbt.librarymanagement.LibraryManagementCodec.given
import sbt.nio.FileStamp
@ -2847,8 +2847,8 @@ object Classpaths {
publishM2 := publishOrSkip(publishM2Configuration, publishM2 / skip).value,
credentials ++= Def.uncached {
val alreadyContainsCentralCredentials: Boolean = credentials.value.exists {
case d: DirectCredentials => d.host == Sona.host
case _ => false
case d: Credentials.DirectCredentials => d.host == Sona.host
case _ => false
}
if (!alreadyContainsCentralCredentials) SysProp.sonatypeCredentalsEnv.toSeq
else Nil
@ -3413,7 +3413,7 @@ object Classpaths {
}
private[sbt] lazy val ivySbt0: Initialize[Task[IvySbt]] =
Def.task {
Credentials.register(credentials.value, streams.value.log)
IvyCredentials.register(credentials.value, streams.value.log)
new IvySbt(ivyConfiguration.value)
}
def moduleSettings0: Initialize[Task[ModuleSettings]] = Def.task {

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

@ -23,6 +23,7 @@ import sbt.internal.*
import sbt.internal.bsp.*
import sbt.internal.inc.ScalaInstance
import sbt.internal.librarymanagement.{ CompatibilityWarningOptions, IvySbt }
import sbt.internal.librarymanagement.ivy.{ IvyConfiguration, UpdateOptions }
import sbt.internal.remotecache.RemoteCacheArtifact
import sbt.internal.server.BuildServerProtocol.BspFullWorkspace
import sbt.internal.server.{ BspCompileTask, BuildServerReporter, ServerHandler }
@ -33,7 +34,6 @@ import sbt.io.*
import sbt.librarymanagement.Configurations.CompilerPlugin
import sbt.librarymanagement.LibraryManagementCodec.*
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.{ Credentials, IvyConfiguration, IvyPaths, UpdateOptions }
import sbt.nio.file.Glob
import sbt.protocol.testing.TestResult
import sbt.testing.Framework

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

@ -8,8 +8,7 @@
package sbt
import sbt.librarymanagement.Resolver
import sbt.librarymanagement.ivy.Credentials
import sbt.librarymanagement.{ Credentials, Resolver }
import java.io.File
import java.net.URI

4
main/src/main/scala/sbt/RemoteCache.scala
View File

@ -30,7 +30,7 @@ import sbt.internal.remotecache.*
import sbt.io.IO
import sbt.io.syntax.*
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.{ Credentials, IvyPaths, UpdateOptions }
import sbt.internal.librarymanagement.ivy.{ IvyCredentials, UpdateOptions }
import sbt.librarymanagement.syntax.*
import sbt.nio.FileStamp
import sbt.nio.Keys.{ inputFileStamps, outputFileStamps }
@ -181,7 +181,7 @@ object RemoteCache {
.withUpdateOptions(UpdateOptions().withGigahorse(true))
},
ivySbt := Def.uncached {
Credentials.register(credentials.value, streams.value.log)
IvyCredentials.register(credentials.value, streams.value.log)
val config0 = ivyConfiguration.value
new IvySbt(config0)
},

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

@ -14,11 +14,11 @@ import java.io.File
import sbt.io.*, syntax.*
import sbt.util.*
import sbt.internal.librarymanagement.ivy.{ IvyConfiguration, IvyDependencyResolution }
import sbt.internal.util.{ ConsoleAppender, Terminal as ITerminal }
import sbt.internal.util.complete.{ DefaultParsers, Parser }, DefaultParsers.*
import xsbti.AppConfiguration
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.{ IvyConfiguration, IvyDependencyResolution }
import sbt.internal.inc.classpath.ClasspathUtil
import BasicCommandStrings.*, BasicKeys.*
import sbt.internal.util.Terminal.hasConsole

13
main/src/main/scala/sbt/coursierint/CoursierInputsTasks.scala
View File

@ -10,7 +10,7 @@ package sbt
package coursierint
import java.net.URI
import sbt.librarymanagement.*
import sbt.librarymanagement.{ Credentials as IvyCredentials, * }
import sbt.util.Logger
import sbt.Keys.*
import lmcoursier.definitions.{
@ -30,11 +30,6 @@ import lmcoursier.definitions.{
import lmcoursier.credentials.DirectCredentials
import lmcoursier.{ FallbackDependency, FromSbt, Inputs }
import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties
import sbt.librarymanagement.ivy.{
FileCredentials,
Credentials,
DirectCredentials as IvyDirectCredentials
}
import sbt.ProjectExtra.transitiveInterDependencies
import sbt.ScopeFilter.Make.*
import scala.jdk.CollectionConverters.*
@ -233,9 +228,9 @@ object CoursierInputsTasks {
val log = streams.value.log
val creds = sbt.Keys.allCredentials.value
.flatMap {
case dc: IvyDirectCredentials => List(dc)
case fc: FileCredentials =>
Credentials.loadCredentials(fc.path) match {
case dc: IvyCredentials.DirectCredentials => List(dc)
case fc: IvyCredentials.FileCredentials =>
sbt.internal.librarymanagement.ivy.IvyCredentials.loadCredentials(fc.path) match {
case Left(err) =>
log.warn(s"$err, ignoring it")
Nil

12
main/src/main/scala/sbt/coursierint/LMCoursier.scala
View File

@ -24,13 +24,9 @@ import lmcoursier.*
import lmcoursier.syntax.*
import lmcoursier.credentials.Credentials
import Keys.*
import sbt.librarymanagement.{ Credentials as IvyCredentials }
import sbt.internal.util.Util
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.{
Credentials as IvyCredentials,
DirectCredentials,
FileCredentials
}
import sbt.util.Logger
import sbt.io.syntax.*
import xsbti.AppConfiguration
@ -267,8 +263,10 @@ object LMCoursier {
val st = streams.value
def registerCredentials(creds: IvyCredentials): Unit = {
(creds match {
case dc: DirectCredentials => Right[String, DirectCredentials](dc)
case fc: FileCredentials => IvyCredentials.loadCredentials(fc.path)
case dc: IvyCredentials.DirectCredentials =>
Right[String, IvyCredentials.DirectCredentials](dc)
case fc: IvyCredentials.FileCredentials =>
sbt.internal.librarymanagement.ivy.IvyCredentials.loadCredentials(fc.path)
}) match {
case Left(err) => st.log.warn(err)
case Right(d) =>

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

@ -20,14 +20,14 @@ import sbt.SlashSyntax0.*
import sbt.internal.BuildStreams.*
import sbt.internal.inc.classpath.ClasspathUtil
import sbt.internal.inc.{ MappedFileConverter, ScalaInstance, ZincLmUtil, ZincUtil }
import sbt.internal.librarymanagement.ivy.{ InlineIvyConfiguration, IvyDependencyResolution }
import sbt.internal.util.Attributed.data
import sbt.internal.util.Types.const
import sbt.internal.util.Attributed
import sbt.internal.util.appmacro.ContextUtil
import sbt.internal.server.BuildServerEvalReporter
import sbt.io.{ GlobFilter, IO }
import sbt.librarymanagement.ivy.{ InlineIvyConfiguration, IvyDependencyResolution, IvyPaths }
import sbt.librarymanagement.{ Configuration, Configurations, Resolver }
import sbt.librarymanagement.{ Configuration, Configurations, IvyPaths, Resolver }
import sbt.nio.Settings
import sbt.util.{ Logger, Show }
import xsbti.{ FileConverter, HashedVirtualFileRef, VirtualFile }

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

@ -19,8 +19,8 @@ import scala.concurrent.duration.*
import sbt.internal.inc.HashUtil
import sbt.internal.util.{ Terminal as ITerminal, Util }
import sbt.internal.util.complete.SizeParser
import sbt.librarymanagement.Credentials
import sbt.io.syntax.*
import sbt.librarymanagement.ivy.{ Credentials, FileCredentials }
import sbt.nio.Keys.*
// See also BuildPaths.scala
@ -239,7 +239,7 @@ object SysProp {
}
lazy val sbtCredentialsEnv: Option[Credentials] =
sys.env.get("SBT_CREDENTIALS").map(raw => new FileCredentials(new File(raw)))
sys.env.get("SBT_CREDENTIALS").map(raw => new Credentials.FileCredentials(new File(raw)))
def sonatypeCredentalsEnv: Option[Credentials] =
for {

5
main/src/main/scala/sbt/internal/librarymanagement/Publishing.scala
View File

@ -14,7 +14,8 @@ import java.nio.file.Path
import sbt.internal.util.MessageOnlyException
import sbt.io.IO
import sbt.io.Path.contentOf
import sbt.librarymanagement.ivy.Credentials
import sbt.librarymanagement.Credentials
import sbt.internal.librarymanagement.ivy.IvyCredentials
import sona.{ PublishingType, Sona }
import scala.concurrent.duration.FiniteDuration
@ -64,7 +65,7 @@ see https://www.scala-sbt.org/1.x/docs/Using-Sonatype.html for details.""")
}
private def fromCreds(creds: Seq[Credentials], uploadRequestTimeout: FiniteDuration): Sona = {
val cred = Credentials
val cred = IvyCredentials
.forHost(creds, Sona.host)
.getOrElse(throw new MessageOnlyException(s"no credentials are found for ${Sona.host}"))
Sona.oauthClient(cred.userName, cred.passwd, uploadRequestTimeout)

8
project/DatatypeConfig.scala
View File

@ -34,8 +34,12 @@ object DatatypeConfig {
"sbt.internal.librarymanagement.formats.LoggerFormat" :: Nil
}
case "sbt.librarymanagement.ivy.UpdateOptions" => { _ =>
"sbt.librarymanagement.ivy.formats.UpdateOptionsFormat" :: Nil
case "sbt.librarymanagement.IvyPaths" => { _ =>
"sbt.librarymanagement.IvyPathsFormats" :: Nil
}
case "sbt.internal.librarymanagement.ivy.UpdateOptions" => { _ =>
"sbt.internal.librarymanagement.ivy.formats.UpdateOptionsFormat" :: Nil
}
case "sbt.librarymanagement.LogicalClock" => { _ =>

22
sbt-app/src/main/scala/sbt/Import.scala
View File

@ -255,8 +255,8 @@ trait Import {
type Caller = sbt.librarymanagement.Caller
val ChainedResolver = sbt.librarymanagement.ChainedResolver
type ChainedResolver = sbt.librarymanagement.ChainedResolver
val CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
type CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
// val CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
// type CircularDependencyLevel = sbt.librarymanagement.ivy.CircularDependencyLevel
val ConfigRef = sbt.librarymanagement.ConfigRef
type ConfigRef = sbt.librarymanagement.ConfigRef
val Configuration = sbt.librarymanagement.Configuration
@ -268,8 +268,8 @@ trait Import {
type ConflictManager = sbt.librarymanagement.ConflictManager
val ConflictWarning = sbt.librarymanagement.ConflictWarning
type ConflictWarning = sbt.librarymanagement.ConflictWarning
val Credentials = sbt.librarymanagement.ivy.Credentials
type Credentials = sbt.librarymanagement.ivy.Credentials
val Credentials = sbt.librarymanagement.Credentials
type Credentials = sbt.librarymanagement.Credentials
val CrossVersion = sbt.librarymanagement.CrossVersion
type CrossVersion = sbt.librarymanagement.CrossVersion
val DefaultMavenRepository = sbt.librarymanagement.Resolver.DefaultMavenRepository
@ -277,7 +277,6 @@ trait Import {
type Developer = sbt.librarymanagement.Developer
val Disabled = sbt.librarymanagement.Disabled
type Disabled = sbt.librarymanagement.Disabled
type DirectCredentials = sbt.librarymanagement.ivy.DirectCredentials
val EvictionPair = sbt.librarymanagement.EvictionPair
type EvictionPair = sbt.librarymanagement.EvictionPair
val EvictionWarning = sbt.librarymanagement.EvictionWarning
@ -286,7 +285,6 @@ trait Import {
type EvictionWarningOptions = sbt.librarymanagement.EvictionWarningOptions
// val ExclusionRule = sbt.librarymanagement.InclExclRule
// type ExclusionRule = sbt.librarymanagement.InclExclRule
type FileCredentials = sbt.librarymanagement.ivy.FileCredentials
val FileRepository = sbt.librarymanagement.FileRepository
type FileRepository = sbt.librarymanagement.FileRepository
val Full = sbt.librarymanagement.Full
@ -295,6 +293,8 @@ trait Import {
type InlineConfiguration = sbt.librarymanagement.ModuleDescriptorConfiguration
val IvyScala = sbt.librarymanagement.ScalaModuleInfo
type IvyScala = sbt.librarymanagement.ScalaModuleInfo
type IvyPaths = sbt.librarymanagement.IvyPaths
val IvyPaths = sbt.librarymanagement.IvyPaths
val JavaNet2Repository = sbt.librarymanagement.Resolver.JavaNet2Repository
import sbt.librarymanagement.{ InclExclRule, DependencyBuilders }
given Conversion[String, InclExclRule] = InclExclRule.stringToExclusionRule
@ -355,8 +355,8 @@ trait Import {
val URLRepository = sbt.librarymanagement.URLRepository
type URLRepository = sbt.librarymanagement.URLRepository
val UpdateLogging = sbt.librarymanagement.UpdateLogging
val UpdateOptions = sbt.librarymanagement.ivy.UpdateOptions
type UpdateOptions = sbt.librarymanagement.ivy.UpdateOptions
val UpdateOptions = sbt.internal.librarymanagement.ivy.UpdateOptions
type UpdateOptions = sbt.internal.librarymanagement.ivy.UpdateOptions
val UpdateReport = sbt.librarymanagement.UpdateReport
type UpdateReport = sbt.librarymanagement.UpdateReport
val UpdateStats = sbt.librarymanagement.UpdateStats
@ -365,12 +365,6 @@ trait Import {
type VersionNumber = sbt.librarymanagement.VersionNumber
type VersionNumberCompatibility = sbt.librarymanagement.VersionNumberCompatibility
// sbt.librarymanagement.ivy
val InlineIvyConfiguration = sbt.librarymanagement.ivy.InlineIvyConfiguration
type InlineIvyConfiguration = sbt.librarymanagement.ivy.InlineIvyConfiguration
type IvyPaths = sbt.librarymanagement.ivy.IvyPaths
val IvyPaths = sbt.librarymanagement.ivy.IvyPaths
type FileConverter = xsbti.FileConverter
type HashedVirtualFileRef = xsbti.HashedVirtualFileRef
type IncOptions = xsbti.compile.IncOptions

5
sbt-app/src/test/scala/sbt/RunFromSourceMain.scala
View File

@ -146,7 +146,10 @@ object RunFromSourceMain {
log.info(s"""creating $scalaHome1 by downloading scala-compiler $scalaVersion""")
IO.createDirectories(List(scalaHome1Lib, scalaHome1Temp))
val lm = {
import sbt.librarymanagement.ivy.IvyDependencyResolution
import sbt.internal.librarymanagement.ivy.{
InlineIvyConfiguration,
IvyDependencyResolution
}
val ivyConfig = InlineIvyConfiguration().withLog(log)
IvyDependencyResolution(
ivyConfig.withResolvers(

2
zinc-lm-integration/src/test/scala/sbt/internal/inc/IvyBridgeProviderSpecification.scala
View File

@ -13,8 +13,8 @@ import java.net.URLClassLoader
import sbt.io.IO
import sbt.io.syntax.*
import sbt.internal.librarymanagement.ivy.*
import sbt.librarymanagement.*
import sbt.librarymanagement.ivy.*
import sbt.util.Logger
import xsbti.compile.CompilerBridgeProvider
import org.scalatest.*