Support to convert cross-versioned ModuleID to ModuleCoordinate

src/main/contraband/AssemblyShadeRule.contra

@@ -0,0 +1,28 @@
+package sbtassembly
+@target(Scala)
+
+type AssemblyShadeRule {
+  rule: com.eed3si9n.jarjarabrams.ShadeRule!
+  moduleIds: [sbt.librarymanagement.ModuleID]
+
+  #x def inAll: AssemblyShadeRule = this.withRule(rule.inAll)
+  #x def inProject: AssemblyShadeRule = this.withRule(rule.inProject)
+  #x def inModuleCoordinates(modules: com.eed3si9n.jarjarabrams.ModuleCoordinate*): AssemblyShadeRule =
+  #x   this.withRule(rule.inModuleCoordinates(modules: _*))
+  #x def inLibrary(modules: sbt.librarymanagement.ModuleID*): AssemblyShadeRule = this.withModuleIds(moduleIds ++ modules)
+
+  #x def toShadeRule(scalaVersion: String, scalaBinaryVersion: String): com.eed3si9n.jarjarabrams.ShadeRule =
+  #x   rule.inModuleCoordinates(
+  #x     moduleIds
+  #x       .map(sbt.librarymanagement.CrossVersion(scalaVersion, scalaBinaryVersion))
+  #x       .map(m => com.eed3si9n.jarjarabrams.ModuleCoordinate(m.organization, m.name, m.revision)): _*
+  #x   )
+
+  #xcompanion trait implicits {
+  #xcompanion   implicit def assemblyShadeRuleFromShareRule(rule: com.eed3si9n.jarjarabrams.ShadeRule): AssemblyShadeRule = AssemblyShadeRule(rule)
+  #xcompanion   implicit def assemblyShadeRuleFromShadePattern(pattern: com.eed3si9n.jarjarabrams.ShadePattern): AssemblyShadeRule = AssemblyShadeRule(pattern)
+  #xcompanion }
+
+  #xcompanion def apply(rule: com.eed3si9n.jarjarabrams.ShadeRule): AssemblyShadeRule = AssemblyShadeRule(rule, Vector.empty)
+  #xcompanion def apply(pattern: com.eed3si9n.jarjarabrams.ShadePattern): AssemblyShadeRule = AssemblyShadeRule(com.eed3si9n.jarjarabrams.ShadeRule(pattern, Vector.empty))
+}

src/main/scala/sbtassembly/AssemblyKeys.scala

@@ -15,7 +15,7 @@ trait AssemblyKeys {
   lazy val assemblyOutputPath        = taskKey[File]("output path of the über jar")
   lazy val assemblyExcludedJars      = taskKey[Classpath]("list of excluded jars")
   lazy val assemblyMergeStrategy     = settingKey[String => MergeStrategy]("mapping from archive member path to merge strategy")
-  lazy val assemblyShadeRules        = settingKey[Seq[jarjarabrams.ShadeRule]]("shading rules backed by jarjar")
+  lazy val assemblyShadeRules        = settingKey[Seq[AssemblyShadeRule]]("shading rules backed by jarjar")
   lazy val assemblyAppendContentHash = settingKey[Boolean]("Appends SHA-1 fingerprint to the assembly file name")
   lazy val assemblyMaxHashLength     = settingKey[Int]("Length of SHA-1 fingerprint used for the assembly file name")
   lazy val assemblyCacheOutput       = settingKey[Boolean]("Enables (true) or disables (false) cacheing the output if the content has not changed")

src/main/scala/sbtassembly/AssemblyPlugin.scala

@@ -1,28 +1,20 @@
 package sbtassembly
 
-import com.eed3si9n.jarjarabrams
 import sbt.Keys._
 import sbt._
 
 object AssemblyPlugin extends sbt.AutoPlugin {
   override def requires = plugins.JvmPlugin
   override def trigger = allRequirements
 
-  object autoImport extends AssemblyKeys {
+  object autoImport extends AssemblyKeys with AssemblyShadeRule.implicits {
     val Assembly = sbtassembly.Assembly
     val MergeStrategy = sbtassembly.MergeStrategy
     val JarEntry = sbtassembly.Assembly.JarEntry
     val CustomMergeStrategy = sbtassembly.CustomMergeStrategy
     val PathList = sbtassembly.PathList
     val baseAssemblySettings = AssemblyPlugin.baseAssemblySettings
     val ShadeRule = com.eed3si9n.jarjarabrams.ShadeRule
-    implicit class RichShadePattern(pattern: jarjarabrams.ShadePattern) {
-      def inLibrary(moduleId: ModuleID*): jarjarabrams.ShadeRule =
-        pattern.inModuleCoordinates(
-          moduleId.toVector
-            .map(m => jarjarabrams.ModuleCoordinate(m.organization, m.name, m.revision)): _*
-        )
-    }
   }
   import autoImport.{ baseAssemblySettings => _, Assembly => _, _ }
 
@@ -106,7 +98,6 @@ object AssemblyPlugin extends sbt.AutoPlugin {
 
   def assemblyOptionSettings: Seq[Setting[_]] = Seq(
     assemblyOption := {
-      val s = streams.value
       AssemblyOption()
         .withIncludeBin((assembleArtifact in packageBin).value)
         .withIncludeScala((assembleArtifact in assemblyPackageScala).value)
@@ -117,7 +108,7 @@ object AssemblyPlugin extends sbt.AutoPlugin {
         .withAppendContentHash(assemblyAppendContentHash.value)
         .withPrependShellScript(assemblyPrependShellScript.value)
         .withMaxHashLength(assemblyMaxHashLength.?.value)
-        .withShadeRules(assemblyShadeRules.value)
+        .withShadeRules(assemblyShadeRules.value.map(_.toShadeRule(scalaVersion.value, scalaBinaryVersion.value)))
         .withScalaVersion(scalaVersion.value)
         .withLevel(logLevel.?.value.getOrElse(Level.Info))
         .withRepeatableBuild(assemblyRepeatableBuild.value)

src/main/scala/sbtassembly/AssemblyShadeRule.scala

@@ -0,0 +1,51 @@
+/**
+ * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbtassembly
+final class AssemblyShadeRule private (
+  val rule: com.eed3si9n.jarjarabrams.ShadeRule,
+  val moduleIds: Vector[sbt.librarymanagement.ModuleID]) extends Serializable {
+  def inAll: AssemblyShadeRule = this.withRule(rule.inAll)
+  def inProject: AssemblyShadeRule = this.withRule(rule.inProject)
+  def inModuleCoordinates(modules: com.eed3si9n.jarjarabrams.ModuleCoordinate*): AssemblyShadeRule =
+  this.withRule(rule.inModuleCoordinates(modules: _*))
+  def inLibrary(modules: sbt.librarymanagement.ModuleID*): AssemblyShadeRule = this.withModuleIds(moduleIds ++ modules)
+  def toShadeRule(scalaVersion: String, scalaBinaryVersion: String): com.eed3si9n.jarjarabrams.ShadeRule =
+  rule.inModuleCoordinates(
+  moduleIds
+  .map(sbt.librarymanagement.CrossVersion(scalaVersion, scalaBinaryVersion))
+  .map(m => com.eed3si9n.jarjarabrams.ModuleCoordinate(m.organization, m.name, m.revision)): _*
+  )
+
+
+  override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match {
+    case x: AssemblyShadeRule => (this.rule == x.rule) && (this.moduleIds == x.moduleIds)
+    case _ => false
+  })
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "sbtassembly.AssemblyShadeRule".##) + rule.##) + moduleIds.##)
+  }
+  override def toString: String = {
+    "AssemblyShadeRule(" + rule + ", " + moduleIds + ")"
+  }
+  private[this] def copy(rule: com.eed3si9n.jarjarabrams.ShadeRule = rule, moduleIds: Vector[sbt.librarymanagement.ModuleID] = moduleIds): AssemblyShadeRule = {
+    new AssemblyShadeRule(rule, moduleIds)
+  }
+  def withRule(rule: com.eed3si9n.jarjarabrams.ShadeRule): AssemblyShadeRule = {
+    copy(rule = rule)
+  }
+  def withModuleIds(moduleIds: Vector[sbt.librarymanagement.ModuleID]): AssemblyShadeRule = {
+    copy(moduleIds = moduleIds)
+  }
+}
+object AssemblyShadeRule {
+  trait implicits {
+    implicit def assemblyShadeRuleFromShareRule(rule: com.eed3si9n.jarjarabrams.ShadeRule): AssemblyShadeRule = AssemblyShadeRule(rule)
+    implicit def assemblyShadeRuleFromShadePattern(pattern: com.eed3si9n.jarjarabrams.ShadePattern): AssemblyShadeRule = AssemblyShadeRule(pattern)
+  }
+  def apply(rule: com.eed3si9n.jarjarabrams.ShadeRule): AssemblyShadeRule = AssemblyShadeRule(rule, Vector.empty)
+  def apply(pattern: com.eed3si9n.jarjarabrams.ShadePattern): AssemblyShadeRule = AssemblyShadeRule(com.eed3si9n.jarjarabrams.ShadeRule(pattern, Vector.empty))
+  def apply(rule: com.eed3si9n.jarjarabrams.ShadeRule, moduleIds: Vector[sbt.librarymanagement.ModuleID]): AssemblyShadeRule = new AssemblyShadeRule(rule, moduleIds)
+}

src/sbt-test/shading/shading/build.sbt

@@ -3,22 +3,28 @@ lazy val testshade = (project in file(".")).
     version := "0.1",
     assembly / assemblyJarName := "foo.jar",
     scalaVersion := "2.12.18",
-    libraryDependencies += "commons-io" % "commons-io" % "2.4",
+    libraryDependencies ++= Seq(
+      "commons-io" % "commons-io" % "2.4",
+      "org.json4s" %% "json4s-ast" % "4.0.6"
+    ),
     assembly / assemblyShadeRules := Seq(
       ShadeRule.zap("remove.**").inProject,
       ShadeRule.rename("toshade.classes.ShadeClass" -> "toshade.classez.ShadedClass").inProject,
       ShadeRule.rename("toshade.ShadePackage" -> "shaded_package.ShadePackage").inProject,
-      ShadeRule.rename("org.apache.commons.io.**" -> "shadeio.@1").inLibrary("commons-io" % "commons-io" % "2.4").inProject
+      ShadeRule.rename("org.apache.commons.io.**" -> "shadeio.@1").inLibrary("commons-io" % "commons-io" % "2.4").inProject,
+      ShadeRule.rename("org.json4s.**" -> "shadejson4s.@1").inLibrary("org.json4s" %% "json4s-ast" % "4.0.6").inProject
     ),
     // logLevel in assembly := Level.Debug,
     TaskKey[Unit]("check") := {
       IO.withTemporaryDirectory { dir ⇒
         IO.unzip(crossTarget.value / "foo.jar", dir)
         mustNotExist(dir / "remove" / "Removed.class")
         mustNotExist(dir / "org" / "apache" / "commons" / "io" / "ByteOrderMark.class")
+        mustNotExist(dir / "org" / "json4s" / "BuildInfo.class")
         mustExist(dir / "shaded_package" / "ShadePackage.class")
         mustExist(dir / "toshade" / "classez" / "ShadedClass.class")
         mustExist(dir / "shadeio" / "ByteOrderMark.class")
+        mustExist(dir / "shadejson4s" / "BuildInfo.class")
       }
       val process = sys.process.Process("java", Seq("-jar", (crossTarget.value / "foo.jar").toString))
       val out = (process!!)