diff --git a/core/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala b/core/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala index 49ef7ff34..ed282ac6e 100644 --- a/core/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala +++ b/core/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala @@ -17,22 +17,24 @@ final class ModuleID private ( val exclusions: Vector[sbt.librarymanagement.InclExclRule], val extraAttributes: Map[String, String], val crossVersion: sbt.librarymanagement.CrossVersion, - val branchName: Option[String]) extends sbt.librarymanagement.ModuleIDExtra with Serializable { + val branchName: Option[String], + val platformOpt: Option[String]) extends sbt.librarymanagement.ModuleIDExtra with Serializable { - private def this(organization: String, name: String, revision: String) = this(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None) + private def this(organization: String, name: String, revision: String) = this(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None, None) + private def this(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String]) = this(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, None) override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { - case x: ModuleID => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.configurations == x.configurations) && (this.isChanging == x.isChanging) && (this.isTransitive == x.isTransitive) && (this.isForce == x.isForce) && (this.explicitArtifacts == x.explicitArtifacts) && (this.inclusions == x.inclusions) && (this.exclusions == x.exclusions) && (this.extraAttributes == x.extraAttributes) && (this.crossVersion == x.crossVersion) && (this.branchName == x.branchName) + case x: ModuleID => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.configurations == x.configurations) && (this.isChanging == x.isChanging) && (this.isTransitive == x.isTransitive) && (this.isForce == x.isForce) && (this.explicitArtifacts == x.explicitArtifacts) && (this.inclusions == x.inclusions) && (this.exclusions == x.exclusions) && (this.extraAttributes == x.extraAttributes) && (this.crossVersion == x.crossVersion) && (this.branchName == x.branchName) && (this.platformOpt == x.platformOpt) case _ => false }) override def hashCode: Int = { - 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ModuleID".##) + organization.##) + name.##) + revision.##) + configurations.##) + isChanging.##) + isTransitive.##) + isForce.##) + explicitArtifacts.##) + inclusions.##) + exclusions.##) + extraAttributes.##) + crossVersion.##) + branchName.##) + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ModuleID".##) + organization.##) + name.##) + revision.##) + configurations.##) + isChanging.##) + isTransitive.##) + isForce.##) + explicitArtifacts.##) + inclusions.##) + exclusions.##) + extraAttributes.##) + crossVersion.##) + branchName.##) + platformOpt.##) } override def toString: String = { this.toStringImpl } - private[this] def copy(organization: String = organization, name: String = name, revision: String = revision, configurations: Option[String] = configurations, isChanging: Boolean = isChanging, isTransitive: Boolean = isTransitive, isForce: Boolean = isForce, explicitArtifacts: Vector[sbt.librarymanagement.Artifact] = explicitArtifacts, inclusions: Vector[sbt.librarymanagement.InclExclRule] = inclusions, exclusions: Vector[sbt.librarymanagement.InclExclRule] = exclusions, extraAttributes: Map[String, String] = extraAttributes, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion, branchName: Option[String] = branchName): ModuleID = { - new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName) + private[this] def copy(organization: String = organization, name: String = name, revision: String = revision, configurations: Option[String] = configurations, isChanging: Boolean = isChanging, isTransitive: Boolean = isTransitive, isForce: Boolean = isForce, explicitArtifacts: Vector[sbt.librarymanagement.Artifact] = explicitArtifacts, inclusions: Vector[sbt.librarymanagement.InclExclRule] = inclusions, exclusions: Vector[sbt.librarymanagement.InclExclRule] = exclusions, extraAttributes: Map[String, String] = extraAttributes, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion, branchName: Option[String] = branchName, platformOpt: Option[String] = platformOpt): ModuleID = { + new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, platformOpt) } def withOrganization(organization: String): ModuleID = { copy(organization = organization) @@ -73,9 +75,13 @@ final class ModuleID private ( def withBranchName(branchName: Option[String]): ModuleID = { copy(branchName = branchName) } + def withPlatformOpt(platformOpt: Option[String]): ModuleID = { + copy(platformOpt = platformOpt) + } } object ModuleID extends sbt.librarymanagement.ModuleIDFunctions { def apply(organization: String, name: String, revision: String): ModuleID = new ModuleID(organization, name, revision) def apply(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String]): ModuleID = new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName) + def apply(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String], platformOpt: Option[String]): ModuleID = new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, platformOpt) } diff --git a/core/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala b/core/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala index bb0df05a5..62e93e147 100644 --- a/core/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala +++ b/core/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala @@ -24,8 +24,9 @@ implicit lazy val ModuleIDFormat: JsonFormat[sbt.librarymanagement.ModuleID] = n val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes") val crossVersion = unbuilder.readField[sbt.librarymanagement.CrossVersion]("crossVersion") val branchName = unbuilder.readField[Option[String]]("branchName") + val platformOpt = unbuilder.readField[Option[String]]("platformOpt") unbuilder.endObject() - sbt.librarymanagement.ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName) + sbt.librarymanagement.ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName, platformOpt) case None => deserializationError("Expected JsObject but found None") } @@ -45,6 +46,7 @@ implicit lazy val ModuleIDFormat: JsonFormat[sbt.librarymanagement.ModuleID] = n builder.addField("extraAttributes", obj.extraAttributes) builder.addField("crossVersion", obj.crossVersion) builder.addField("branchName", obj.branchName) + builder.addField("platformOpt", obj.platformOpt) builder.endObject() } } diff --git a/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfo.scala b/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfo.scala index 772d7b9ee..0e4db8751 100644 --- a/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfo.scala +++ b/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfo.scala @@ -12,22 +12,24 @@ final class ScalaModuleInfo private ( val filterImplicit: Boolean, val overrideScalaVersion: Boolean, val scalaOrganization: String, - val scalaArtifacts: scala.Vector[String]) extends Serializable { + val scalaArtifacts: scala.Vector[String], + val platform: Option[String]) extends Serializable { - private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts) + private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts, None) + private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String]) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, None) override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { - case x: ScalaModuleInfo => (this.scalaFullVersion == x.scalaFullVersion) && (this.scalaBinaryVersion == x.scalaBinaryVersion) && (this.configurations == x.configurations) && (this.checkExplicit == x.checkExplicit) && (this.filterImplicit == x.filterImplicit) && (this.overrideScalaVersion == x.overrideScalaVersion) && (this.scalaOrganization == x.scalaOrganization) && (this.scalaArtifacts == x.scalaArtifacts) + case x: ScalaModuleInfo => (this.scalaFullVersion == x.scalaFullVersion) && (this.scalaBinaryVersion == x.scalaBinaryVersion) && (this.configurations == x.configurations) && (this.checkExplicit == x.checkExplicit) && (this.filterImplicit == x.filterImplicit) && (this.overrideScalaVersion == x.overrideScalaVersion) && (this.scalaOrganization == x.scalaOrganization) && (this.scalaArtifacts == x.scalaArtifacts) && (this.platform == x.platform) case _ => false }) override def hashCode: Int = { - 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ScalaModuleInfo".##) + scalaFullVersion.##) + scalaBinaryVersion.##) + configurations.##) + checkExplicit.##) + filterImplicit.##) + overrideScalaVersion.##) + scalaOrganization.##) + scalaArtifacts.##) + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ScalaModuleInfo".##) + scalaFullVersion.##) + scalaBinaryVersion.##) + configurations.##) + checkExplicit.##) + filterImplicit.##) + overrideScalaVersion.##) + scalaOrganization.##) + scalaArtifacts.##) + platform.##) } override def toString: String = { - "ScalaModuleInfo(" + scalaFullVersion + ", " + scalaBinaryVersion + ", " + configurations + ", " + checkExplicit + ", " + filterImplicit + ", " + overrideScalaVersion + ", " + scalaOrganization + ", " + scalaArtifacts + ")" + "ScalaModuleInfo(" + scalaFullVersion + ", " + scalaBinaryVersion + ", " + configurations + ", " + checkExplicit + ", " + filterImplicit + ", " + overrideScalaVersion + ", " + scalaOrganization + ", " + scalaArtifacts + ", " + platform + ")" } - private[this] def copy(scalaFullVersion: String = scalaFullVersion, scalaBinaryVersion: String = scalaBinaryVersion, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, checkExplicit: Boolean = checkExplicit, filterImplicit: Boolean = filterImplicit, overrideScalaVersion: Boolean = overrideScalaVersion, scalaOrganization: String = scalaOrganization, scalaArtifacts: scala.Vector[String] = scalaArtifacts): ScalaModuleInfo = { - new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts) + private[this] def copy(scalaFullVersion: String = scalaFullVersion, scalaBinaryVersion: String = scalaBinaryVersion, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, checkExplicit: Boolean = checkExplicit, filterImplicit: Boolean = filterImplicit, overrideScalaVersion: Boolean = overrideScalaVersion, scalaOrganization: String = scalaOrganization, scalaArtifacts: scala.Vector[String] = scalaArtifacts, platform: Option[String] = platform): ScalaModuleInfo = { + new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, platform) } def withScalaFullVersion(scalaFullVersion: String): ScalaModuleInfo = { copy(scalaFullVersion = scalaFullVersion) @@ -53,9 +55,13 @@ final class ScalaModuleInfo private ( def withScalaArtifacts(scalaArtifacts: scala.Vector[String]): ScalaModuleInfo = { copy(scalaArtifacts = scalaArtifacts) } + def withPlatform(platform: Option[String]): ScalaModuleInfo = { + copy(platform = platform) + } } object ScalaModuleInfo { def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean): ScalaModuleInfo = new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion) def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String]): ScalaModuleInfo = new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts) + def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String], platform: Option[String]): ScalaModuleInfo = new ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, platform) } diff --git a/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfoFormats.scala b/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfoFormats.scala index 8977be68d..2c2602605 100644 --- a/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfoFormats.scala +++ b/core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfoFormats.scala @@ -19,8 +19,9 @@ implicit lazy val ScalaModuleInfoFormat: JsonFormat[sbt.librarymanagement.ScalaM val overrideScalaVersion = unbuilder.readField[Boolean]("overrideScalaVersion") val scalaOrganization = unbuilder.readField[String]("scalaOrganization") val scalaArtifacts = unbuilder.readField[scala.Vector[String]]("scalaArtifacts") + val platform = unbuilder.readField[Option[String]]("platform") unbuilder.endObject() - sbt.librarymanagement.ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts) + sbt.librarymanagement.ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts, platform) case None => deserializationError("Expected JsObject but found None") } @@ -35,6 +36,7 @@ implicit lazy val ScalaModuleInfoFormat: JsonFormat[sbt.librarymanagement.ScalaM builder.addField("overrideScalaVersion", obj.overrideScalaVersion) builder.addField("scalaOrganization", obj.scalaOrganization) builder.addField("scalaArtifacts", obj.scalaArtifacts) + builder.addField("platform", obj.platform) builder.endObject() } } diff --git a/core/src/main/contraband/librarymanagement.json b/core/src/main/contraband/librarymanagement.json index 59767a820..6b210d34c 100644 --- a/core/src/main/contraband/librarymanagement.json +++ b/core/src/main/contraband/librarymanagement.json @@ -294,7 +294,13 @@ { "name": "filterImplicit", "type": "boolean" }, { "name": "overrideScalaVersion", "type": "boolean" }, { "name": "scalaOrganization", "type": "String", "default": "sbt.librarymanagement.ScalaArtifacts.Organization", "since": "0.0.1" }, - { "name": "scalaArtifacts", "type": "scala.Vector[String]", "default": "sbt.librarymanagement.ScalaArtifacts.Artifacts", "since": "0.0.1" } + { "name": "scalaArtifacts", "type": "scala.Vector[String]", "default": "sbt.librarymanagement.ScalaArtifacts.Artifacts", "since": "0.0.1" }, + { + "name": "platform", + "type": "Option[String]", + "default": "None", + "since": "2.0.0" + } ] }, { @@ -332,7 +338,8 @@ { "name": "exclusions", "type": "sbt.librarymanagement.InclExclRule*", "default": "Vector.empty", "since": "0.0.1" }, { "name": "extraAttributes", "type": "Map[String, String]", "default": "Map.empty", "since": "0.0.1" }, { "name": "crossVersion", "type": "sbt.librarymanagement.CrossVersion", "default": "sbt.librarymanagement.Disabled()", "since": "0.0.1" }, - { "name": "branchName", "type": "Option[String]", "default": "None", "since": "0.0.1" } + { "name": "branchName", "type": "Option[String]", "default": "None", "since": "0.0.1" }, + { "name": "platformOpt", "type": "Option[String]", "default": "None", "since": "2.0.0" } ], "toString": [ "this.toStringImpl" diff --git a/core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala b/core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala index 022d919de..94aeba123 100644 --- a/core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala +++ b/core/src/main/scala/sbt/librarymanagement/ModuleIDExtra.scala @@ -33,6 +33,7 @@ private[librarymanagement] abstract class ModuleIDExtra { def withExtraAttributes(extraAttributes: Map[String, String]): ModuleID def withCrossVersion(crossVersion: CrossVersion): ModuleID def withBranchName(branchName: Option[String]): ModuleID + def withPlatformOpt(platformOpt: Option[String]): ModuleID protected def toStringImpl: String = s"""$organization:$name:$revision""" + @@ -205,6 +206,8 @@ private[librarymanagement] abstract class ModuleIDExtra { def branch(branchName: String): ModuleID = withBranchName(Some(branchName)) def branch(branchName: Option[String]): ModuleID = withBranchName(branchName) + + def platform(platform: String): ModuleID = withPlatformOpt(Some(platform)) } private[librarymanagement] abstract class ModuleIDFunctions { diff --git a/core/src/main/scala/sbt/librarymanagement/Platform.scala b/core/src/main/scala/sbt/librarymanagement/Platform.scala new file mode 100644 index 000000000..3a9555686 --- /dev/null +++ b/core/src/main/scala/sbt/librarymanagement/Platform.scala @@ -0,0 +1,7 @@ +package sbt.librarymanagement + +object Platform: + val sjs1: String = "sjs1" + val jvm: String = "jvm" + val native0_4: String = "native0.4" +end Platform diff --git a/ivy/src/main/scala/sbt/internal/librarymanagement/Ivy.scala b/ivy/src/main/scala/sbt/internal/librarymanagement/Ivy.scala index 78b31d531..c8e4d3592 100644 --- a/ivy/src/main/scala/sbt/internal/librarymanagement/Ivy.scala +++ b/ivy/src/main/scala/sbt/internal/librarymanagement/Ivy.scala @@ -40,6 +40,7 @@ import scala.collection.mutable import scala.util.{ Success, Failure } import sbt.util._ import sbt.librarymanagement.{ ModuleDescriptorConfiguration => InlineConfiguration, _ } +import sbt.librarymanagement.Platform import sbt.librarymanagement.ivy._ import sbt.librarymanagement.syntax._ @@ -706,29 +707,45 @@ private[sbt] object IvySbt { private def substituteCross(m: ModuleSettings): ModuleSettings = { m.scalaModuleInfo match { case None => m - case Some(is) => substituteCross(m, is.scalaFullVersion, is.scalaBinaryVersion) + case Some(is) => substituteCross(m, is.scalaFullVersion, is.scalaBinaryVersion, is.platform) } } private def substituteCross( m: ModuleSettings, scalaFullVersion: String, - scalaBinaryVersion: String - ): ModuleSettings = { + scalaBinaryVersion: String, + platform: Option[String], + ): ModuleSettings = m match { case ic: InlineConfiguration => - val applyCross = CrossVersion(scalaFullVersion, scalaBinaryVersion) + val applyPlatform: ModuleID => ModuleID = substitutePlatform(platform) + val transform: ModuleID => ModuleID = (m: ModuleID) => + val applyCross = CrossVersion(scalaFullVersion, scalaBinaryVersion) + applyCross(applyPlatform(m)) def propagateCrossVersion(moduleID: ModuleID): ModuleID = { val crossExclusions: Vector[ExclusionRule] = - moduleID.exclusions.map(CrossVersion.substituteCross(_, ic.scalaModuleInfo)) - applyCross(moduleID) + moduleID.exclusions + .map(CrossVersion.substituteCross(_, ic.scalaModuleInfo)) + transform(moduleID) .withExclusions(crossExclusions) } - ic.withModule(applyCross(ic.module)) + ic.withModule(transform(ic.module)) .withDependencies(ic.dependencies.map(propagateCrossVersion)) - .withOverrides(ic.overrides map applyCross) + .withOverrides(ic.overrides map transform) case _ => m } + + private def substitutePlatform(platform: Option[String]): ModuleID => ModuleID = { + def addSuffix(m: ModuleID, platformName: String): ModuleID = + platformName match + case "" | Platform.jvm => m + case _ => m.withName(s"${m.name}_$platformName") + (m: ModuleID) => + (platform, m.platformOpt) match + case (Some(p), None) => addSuffix(m, p) + case (_, Some(p)) => addSuffix(m, p) + case _ => m } private def toIvyArtifact( diff --git a/ivy/src/test/scala/sbt/internal/librarymanagement/BaseIvySpecification.scala b/ivy/src/test/scala/sbt/internal/librarymanagement/BaseIvySpecification.scala index f6bcba917..c9de27b3a 100644 --- a/ivy/src/test/scala/sbt/internal/librarymanagement/BaseIvySpecification.scala +++ b/ivy/src/test/scala/sbt/internal/librarymanagement/BaseIvySpecification.scala @@ -18,6 +18,8 @@ trait BaseIvySpecification extends AbstractEngineSpec { def defaultModuleId: ModuleID = ModuleID("com.example", "foo", "0.1.0").withConfigurations(Some("compile")) + def scala2_13 = "2.13.10" + lazy val log = ConsoleLogger() def lmEngine(uo: UpdateOptions = UpdateOptions()): DependencyResolution = IvyDependencyResolution(mkIvyConfiguration(uo)) @@ -37,7 +39,8 @@ trait BaseIvySpecification extends AbstractEngineSpec { deps: Vector[ModuleID], scalaFullVersion: Option[String], uo: UpdateOptions = UpdateOptions(), - overrideScalaVersion: Boolean = true + overrideScalaVersion: Boolean = true, + platform: Option[String] = None, ): IvySbt#Module = { val scalaModuleInfo = scalaFullVersion map { fv => ScalaModuleInfo( @@ -48,6 +51,7 @@ trait BaseIvySpecification extends AbstractEngineSpec { filterImplicit = false, overrideScalaVersion = overrideScalaVersion ) + .withPlatform(platform) } val moduleSetting: ModuleSettings = ModuleDescriptorConfiguration(moduleId, ModuleInfo("foo")) diff --git a/ivy/src/test/scala/sbt/internal/librarymanagement/PlatformResolutionSpec.scala b/ivy/src/test/scala/sbt/internal/librarymanagement/PlatformResolutionSpec.scala new file mode 100644 index 000000000..2d40e0147 --- /dev/null +++ b/ivy/src/test/scala/sbt/internal/librarymanagement/PlatformResolutionSpec.scala @@ -0,0 +1,70 @@ +package sbt.internal.librarymanagement + +import sbt.util.ShowLines +import sbt.librarymanagement.* +import sbt.librarymanagement.syntax.* +import sbt.librarymanagement.Platform.* + +object PlatformResolutionSpec extends BaseIvySpecification { + + import TestShowLines.* + + test("None platform resolves %% as JVM") { + cleanCache() + val m = exampleAutoModule(platform = None) + assert( + update(m).configurations.head.modules.map(_.toString).mkString + contains "com.github.scopt:scopt_2.13:4.1.0" + ) + } + + test("sjs1 platform resolves %% as sjs1") { + cleanCache() + val m = exampleAutoModule(platform = Some("sjs1")) + assert( + update(m).configurations.head.modules.map(_.toString).mkString + contains "com.github.scopt:scopt_sjs1_2.13" + ) + } + + test("None platform can specify .platform(sjs1) depenency") { + cleanCache() + val m = module( + exampleModuleId("0.6.0"), + deps = Vector(scopt.platform(sjs1)), + Some(scala2_13), + platform = None, + ) + assert( + update(m).configurations.head.modules.map(_.toString).mkString + contains "com.github.scopt:scopt_sjs1_2.13" + ) + } + + test("sjs1 platform can specify .platform(jvm) depenency") { + cleanCache() + val m = module( + exampleModuleId("0.6.0"), + deps = Vector(scopt.platform(jvm)), + Some(scala2_13), + platform = None, + ) + assert( + update(m).configurations.head.modules.map(_.toString).mkString + contains "com.github.scopt:scopt_2.13:4.1.0" + ) + } + + def exampleAutoModule(platform: Option[String]): ModuleDescriptor = module( + exampleModuleId("0.6.0"), + deps = Vector(scopt), + Some(scala2_13), + platform = platform, + ) + + def exampleModuleId(v: String): ModuleID = ("com.example" % "foo" % v % Compile) + def scopt = ("com.github.scopt" %% "scopt" % "4.1.0" % Compile) + override val resolvers = Vector( + Resolver.mavenCentral, + ) +}