From c62cf43786dbf209410a71939c8441894a7edc68 Mon Sep 17 00:00:00 2001 From: marc Date: Mon, 21 Nov 2022 12:43:32 +0100 Subject: [PATCH 1/2] Ability to pack test scoped jars #110 --- .../scala/xerial/sbt/pack/PackArchive.scala | 40 ++-- .../scala/xerial/sbt/pack/PackPlugin.scala | 173 ++++++++++-------- 2 files changed, 122 insertions(+), 91 deletions(-) diff --git a/src/main/scala/xerial/sbt/pack/PackArchive.scala b/src/main/scala/xerial/sbt/pack/PackArchive.scala index 74ef65a8..07a9caec 100644 --- a/src/main/scala/xerial/sbt/pack/PackArchive.scala +++ b/src/main/scala/xerial/sbt/pack/PackArchive.scala @@ -87,23 +87,29 @@ trait PackArchive { packArchiveTbzArtifact := Artifact(packArchivePrefix.value, "arch", "tar.bz2"), packArchiveTxzArtifact := Artifact(packArchivePrefix.value, "arch", "tar.xz"), packArchiveZipArtifact := Artifact(packArchivePrefix.value, "arch", "zip"), - packArchiveTgz := createArchive( - "tar.gz", - (fos) => createTarArchiveOutputStream(new GzipCompressorOutputStream(fos)), - createTarEntry - ).value, - packArchiveTbz := createArchive( - "tar.bz2", - (fos) => createTarArchiveOutputStream(new BZip2CompressorOutputStream(fos)), - createTarEntry - ).value, - packArchiveTxz := createArchive( - "tar.xz", - (fos) => createTarArchiveOutputStream(new XZCompressorOutputStream(fos)), - createTarEntry - ).value, - packArchiveZip := createArchive("zip", new ZipArchiveOutputStream(_), createZipEntry).value, - packArchive := Seq(packArchiveTgz.value, packArchiveZip.value) + Def.derive( + packArchiveTgz := createArchive( + "tar.gz", + (fos) => createTarArchiveOutputStream(new GzipCompressorOutputStream(fos)), + createTarEntry + ).value + ), + Def.derive( + packArchiveTbz := createArchive( + "tar.bz2", + (fos) => createTarArchiveOutputStream(new BZip2CompressorOutputStream(fos)), + createTarEntry + ).value + ), + Def.derive( + packArchiveTxz := createArchive( + "tar.xz", + (fos) => createTarArchiveOutputStream(new XZCompressorOutputStream(fos)), + createTarEntry + ).value + ), + Def.derive(packArchiveZip := createArchive("zip", new ZipArchiveOutputStream(_), createZipEntry).value), + Def.derive(packArchive := Seq(packArchiveTgz.value, packArchiveZip.value)) ) def publishPackArchiveTgz: SettingsDefinition = Seq( diff --git a/src/main/scala/xerial/sbt/pack/PackPlugin.scala b/src/main/scala/xerial/sbt/pack/PackPlugin.scala index 1ab6af1e..574517d4 100755 --- a/src/main/scala/xerial/sbt/pack/PackPlugin.scala +++ b/src/main/scala/xerial/sbt/pack/PackPlugin.scala @@ -154,84 +154,109 @@ object PackPlugin extends AutoPlugin with PackArchive { getFromSelectedProjects(thisProjectRef.value, unmanagedJars in Runtime, state.value, packExclude.value) Def.task { allUnmanagedJars.value } }.value, - packLibJars := Def.taskDyn { - val libJars = - getFromSelectedProjects(thisProjectRef.value, packageBin in Runtime, state.value, packExcludeLibJars.value) - Def.task { libJars.value } - }.value, - (mappings in pack) := Seq.empty, - packModuleEntries := { - val out = streams.value - val jarExcludeFilter: Seq[Regex] = packExcludeJars.value.map(_.r) - def isExcludeJar(name: String): Boolean = { - val toExclude = jarExcludeFilter.exists(pattern => pattern.findFirstIn(name).isDefined) - if (toExclude) { - out.log.info(s"Exclude $name from the package") + Def.derive( + packLibJars := Def.taskDyn { + def libJarsFromConfiguration(c: Configuration): Seq[Task[Seq[(File, ProjectRef)]]] = + Seq( + getFromSelectedProjects( + thisProjectRef.value, + c / packageBin, + state.value, + packExcludeLibJars.value + ) + ) ++ c.extendsConfigs.flatMap(libJarsFromConfiguration) + + val libJars = libJarsFromConfiguration(configuration.value).join + Def.task { + libJars.value.flatten.distinct } - toExclude - } - - val df = configurationFilter(name = "runtime") // && - - val dependentJars = - for { - c <- update.value.filter(df).configurations - m <- c.modules if !m.evicted - (artifact, file) <- m.artifacts - if !packExcludeArtifactTypes.value.contains(artifact.`type`) && !isExcludeJar(file.name) - } yield { - val mid = m.module - ModuleEntry(mid.organization, mid.name, VersionString(mid.revision), artifact.name, artifact.classifier, file) + }.value + ), + mappings := Seq.empty, + Def.derive( + packModuleEntries := { + val out = streams.value + val jarExcludeFilter: Seq[Regex] = packExcludeJars.value.map(_.r) + def isExcludeJar(name: String): Boolean = { + val toExclude = jarExcludeFilter.exists(pattern => pattern.findFirstIn(name).isDefined) + if (toExclude) { + out.log.info(s"Exclude $name from the package") + } + toExclude } - implicit val versionStringOrdering = DefaultVersionStringOrdering - val distinctDpJars = dependentJars - .groupBy(_.noVersionModuleName) - .flatMap { - case (key, entries) if entries.groupBy(_.revision).size == 1 => entries - case (key, entries) => - val revisions = entries.groupBy(_.revision).map(_._1).toList.sorted - val latestRevision = revisions.last - packDuplicateJarStrategy.value match { - case "latest" => - out.log.debug(s"Version conflict on $key. Using ${latestRevision} (found ${revisions.mkString(", ")})") - entries.filter(_.revision == latestRevision) - case "exit" => - sys.error(s"Version conflict on $key (found ${revisions.mkString(", ")})") - case x => - sys.error("Unknown duplicate JAR strategy '%s'".format(x)) - } - } - distinctDpJars.toSeq.distinct.sortBy(_.noVersionModuleName) - }, + val df = configurationFilter(name = configuration.value.name) // && + + val dependentJars = + for { + c <- update.value.filter(df).configurations + m <- c.modules if !m.evicted + (artifact, file) <- m.artifacts + if !packExcludeArtifactTypes.value.contains(artifact.`type`) && !isExcludeJar(file.name) + } yield { + val mid = m.module + ModuleEntry( + mid.organization, + mid.name, + VersionString(mid.revision), + artifact.name, + artifact.classifier, + file + ) + } + + implicit val versionStringOrdering = DefaultVersionStringOrdering + val distinctDpJars = dependentJars + .groupBy(_.noVersionModuleName) + .flatMap { + case (key, entries) if entries.groupBy(_.revision).size == 1 => entries + case (key, entries) => + val revisions = entries.groupBy(_.revision).map(_._1).toList.sorted + val latestRevision = revisions.last + packDuplicateJarStrategy.value match { + case "latest" => + out.log + .debug(s"Version conflict on $key. Using ${latestRevision} (found ${revisions.mkString(", ")})") + entries.filter(_.revision == latestRevision) + case "exit" => + sys.error(s"Version conflict on $key (found ${revisions.mkString(", ")})") + case x => + sys.error("Unknown duplicate JAR strategy '%s'".format(x)) + } + } + distinctDpJars.toSeq.distinct.sortBy(_.noVersionModuleName) + } + ), packCopyDependenciesUseSymbolicLinks := true, packCopyDependenciesTarget := target.value / "lib", - packCopyDependencies := { - val log = streams.value.log - - val distinctDpJars = packModuleEntries.value.map(_.file) - val unmanaged = packAllUnmanagedJars.value.flatMap { _._1 }.map { _.data } - val copyDepTargetDir = packCopyDependenciesTarget.value - val useSymlink = packCopyDependenciesUseSymbolicLinks.value - - copyDepTargetDir.mkdirs() - IO.delete((copyDepTargetDir * "*.jar").get) - (distinctDpJars ++ unmanaged) foreach { d ⇒ - log debug s"Copying ${d.getName}" - val dest = copyDepTargetDir / d.getName - if (useSymlink) { - Files.createSymbolicLink(dest.toPath, d.toPath) - } else { - IO.copyFile(d, dest) + Def.derive( + packCopyDependencies := { + val log = streams.value.log + + val distinctDpJars = packModuleEntries.value.map(_.file) + val unmanaged = packAllUnmanagedJars.value.flatMap { _._1 }.map { _.data } + val copyDepTargetDir = packCopyDependenciesTarget.value + val useSymlink = packCopyDependenciesUseSymbolicLinks.value + + copyDepTargetDir.mkdirs() + IO.delete((copyDepTargetDir * "*.jar").get) + (distinctDpJars ++ unmanaged) foreach { d ⇒ + log debug s"Copying ${d.getName}" + val dest = copyDepTargetDir / d.getName + if (useSymlink) { + Files.createSymbolicLink(dest.toPath, d.toPath) + } else { + IO.copyFile(d, dest) + } } - } - val libs = packLibJars.value.map(_._1) - libs.foreach(l ⇒ IO.copyFile(l, copyDepTargetDir / l.getName)) + val libs = packLibJars.value.map(_._1) + libs.foreach(l ⇒ IO.copyFile(l, copyDepTargetDir / l.getName)) - log info s"Copied ${distinctDpJars.size + libs.size} jars to ${copyDepTargetDir}" - }, + log info s"Copied ${distinctDpJars.size + libs.size} jars to ${copyDepTargetDir}" + } + ), packEnvVars := Map.empty, - pack := { + Def.derive(pack := { val out = streams.value val logPrefix = "[" + name.value + "] " val base: File = new File(".") // Using the working directory as base for readability @@ -278,7 +303,7 @@ object PackPlugin extends AutoPlugin with PackArchive { } // Copy explicitly added dependencies - val mapped: Seq[(File, String)] = (mappings in pack).value + val mapped: Seq[(File, String)] = mappings.value out.log.info(logPrefix + "Copying explicit dependencies:") val explicitDepsJars = for ((file, path) <- mapped) yield { out.log.info(file.getPath) @@ -444,8 +469,8 @@ object PackPlugin extends AutoPlugin with PackArchive { out.log.info(logPrefix + "done.") distDir - }, - packInstall := { + }), + Def.derive(packInstall := { val arg: Option[String] = targetFolderParser.parsed val packDir = pack.value val cmd = arg match { @@ -455,7 +480,7 @@ object PackPlugin extends AutoPlugin with PackArchive { s"make install" } sys.process.Process(cmd, Some(packDir)).! - } + }) ) private def getFromAllProjects[T]( From 257e3d6cbc2a4bed3907fcdaeca0190a17a8f06d Mon Sep 17 00:00:00 2001 From: marc Date: Wed, 23 Nov 2022 10:57:51 +0100 Subject: [PATCH 2/2] Fix publish pack archives --- .../scala/xerial/sbt/pack/PackArchive.scala | 24 +++++++------------ src/sbt-test/sbt-pack/archive-modules/test | 1 + 2 files changed, 9 insertions(+), 16 deletions(-) diff --git a/src/main/scala/xerial/sbt/pack/PackArchive.scala b/src/main/scala/xerial/sbt/pack/PackArchive.scala index 07a9caec..d45b574a 100644 --- a/src/main/scala/xerial/sbt/pack/PackArchive.scala +++ b/src/main/scala/xerial/sbt/pack/PackArchive.scala @@ -112,25 +112,17 @@ trait PackArchive { Def.derive(packArchive := Seq(packArchiveTgz.value, packArchiveZip.value)) ) - def publishPackArchiveTgz: SettingsDefinition = Seq( - artifacts += packArchiveTgzArtifact.value, - packagedArtifacts += packArchiveTgzArtifact.value -> packArchiveTgz.value - ) + def publishPackArchiveTgz: SettingsDefinition = + addArtifact(Def.setting(packArchiveTgzArtifact.value), Runtime / packArchiveTgz) - def publishPackArchiveTbz: SettingsDefinition = Seq( - artifacts += packArchiveTbzArtifact.value, - packagedArtifacts += packArchiveTbzArtifact.value -> packArchiveTbz.value - ) + def publishPackArchiveTbz: SettingsDefinition = + addArtifact(Def.setting(packArchiveTbzArtifact.value), Runtime / packArchiveTbz) - def publishPackArchiveTxz: SettingsDefinition = Seq( - artifacts += packArchiveTxzArtifact.value, - packagedArtifacts += packArchiveTxzArtifact.value -> packArchiveTxz.value - ) + def publishPackArchiveTxz: SettingsDefinition = + addArtifact(Def.setting(packArchiveTxzArtifact.value), Runtime / packArchiveTxz) - def publishPackArchiveZip: SettingsDefinition = Seq( - artifacts += packArchiveZipArtifact.value, - packagedArtifacts += packArchiveZipArtifact.value -> packArchiveZip.value - ) + def publishPackArchiveZip: SettingsDefinition = + addArtifact(Def.setting(packArchiveZipArtifact.value), Runtime / packArchiveZip) def publishPackArchives: SettingsDefinition = publishPackArchiveTgz ++ publishPackArchiveZip diff --git a/src/sbt-test/sbt-pack/archive-modules/test b/src/sbt-test/sbt-pack/archive-modules/test index 4aa7534e..a24b2189 100644 --- a/src/sbt-test/sbt-pack/archive-modules/test +++ b/src/sbt-test/sbt-pack/archive-modules/test @@ -1,5 +1,6 @@ > 'set version := "0.1"' > packArchive +> packagedArtifacts $ exists target/archive-modules-0.1.tar.gz $ exists target/archive-modules-0.1.zip $ exists target/pack/bin/module1