migrate more plugins

Author: jtjeferreira

src/main/scala/com/typesafe/sbt/PackagerPlugin.scala

@@ -75,14 +75,14 @@ object SbtNativePackager extends AutoPlugin {
 
     @deprecated("Use enablePlugins(xxxDeployPlugin)", "1.x")
     def deploymentSettings =
-      makeDeploymentSettings(Debian, packageBin in Debian, "deb") ++
-        makeDeploymentSettings(Rpm, packageBin in Rpm, "rpm") ++
-        makeDeploymentSettings(Windows, packageBin in Windows, "msi") ++
-        makeDeploymentSettings(Universal, packageBin in Universal, "zip") ++
-        addPackage(Universal, packageZipTarball in Universal, "tgz") ++
-        makeDeploymentSettings(UniversalDocs, packageBin in UniversalDocs, "zip") ++
-        addPackage(UniversalDocs, packageXzTarball in UniversalDocs, "txz") ++
-        makeDeploymentSettings(Debian, genChanges in Debian, "changes")
+      makeDeploymentSettings(Debian, Debian / packageBin, "deb") ++
+        makeDeploymentSettings(Rpm, Rpm / packageBin, "rpm") ++
+        makeDeploymentSettings(Windows, Windows / packageBin, "msi") ++
+        makeDeploymentSettings(Universal, Universal / packageBin, "zip") ++
+        addPackage(Universal, Universal / packageZipTarball, "tgz") ++
+        makeDeploymentSettings(UniversalDocs, UniversalDocs / packageBin, "zip") ++
+        addPackage(UniversalDocs, UniversalDocs / packageXzTarball, "txz") ++
+        makeDeploymentSettings(Debian, Debian / genChanges, "changes")
   }
 
   import autoImport._

src/main/scala/com/typesafe/sbt/packager/graalvmnativeimage/GraalVMNativeImagePlugin.scala

@@ -35,12 +35,12 @@ object GraalVMNativeImagePlugin extends AutoPlugin {
   override def projectConfigurations: Seq[Configuration] = Seq(GraalVMNativeImage)
 
   override lazy val projectSettings: Seq[Setting[_]] = Seq(
-    target in GraalVMNativeImage := target.value / "graalvm-native-image",
+    GraalVMNativeImage / target := target.value / "graalvm-native-image",
     graalVMNativeImageOptions := Seq.empty,
     graalVMNativeImageGraalVersion := None,
     graalVMNativeImageCommand := (if (scala.util.Properties.isWin) "native-image.cmd" else "native-image"),
-    resourceDirectory in GraalVMNativeImage := sourceDirectory.value / "graal",
-    mainClass in GraalVMNativeImage := (mainClass in Compile).value
+    GraalVMNativeImage /resourceDirectory  := sourceDirectory.value / "graal",
+    GraalVMNativeImage / mainClass  := (Compile / mainClass).value
   ) ++ inConfig(GraalVMNativeImage)(scopedSettings)
 
   private lazy val scopedSettings = Seq[Setting[_]](
@@ -167,14 +167,14 @@ object GraalVMNativeImagePlugin extends AutoPlugin {
     * This can be used to build a custom build image starting from a custom base image. Can be used like so:
     *
     * ```
-    * (containerBuildImage in GraalVMNativeImage) := generateContainerBuildImage("my-docker-hub-username/my-graalvm").value
+    * (GraalVMNativeImage / containerBuildImage) := generateContainerBuildImage("my-docker-hub-username/my-graalvm").value
     * ```
     *
     * The passed in docker image must have GraalVM installed and on the PATH, including the gu utility.
     */
   def generateContainerBuildImage(baseImage: String): Def.Initialize[Task[Option[String]]] =
     Def.task {
-      val dockerCommand = (DockerPlugin.autoImport.dockerExecCommand in GraalVMNativeImage).value
+      val dockerCommand = (GraalVMNativeImage / DockerPlugin.autoImport.dockerExecCommand).value
       val streams = Keys.streams.value
 
       val (baseName, tag) = baseImage.split(":", 2) match {

src/main/scala/com/typesafe/sbt/packager/jar/ClasspathJarPlugin.scala

@@ -23,21 +23,21 @@ object ClasspathJarPlugin extends AutoPlugin {
   override def requires = JavaAppPackaging
 
   override lazy val projectSettings: Seq[Setting[_]] = Defaults
-    .packageTaskSettings(packageJavaClasspathJar, mappings in packageJavaClasspathJar) ++ Seq(
-    mappings in packageJavaClasspathJar := Nil,
-    artifactClassifier in packageJavaClasspathJar := Option("classpath"),
-    packageOptions in packageJavaClasspathJar := {
-      val classpath = (scriptClasspath in packageJavaClasspathJar).value
+    .packageTaskSettings(packageJavaClasspathJar, packageJavaClasspathJar / mappings ) ++ Seq(
+    packageJavaClasspathJar / mappings  := Nil,
+    packageJavaClasspathJar / artifactClassifier  := Option("classpath"),
+    packageJavaClasspathJar / packageOptions  := {
+      val classpath = (packageJavaClasspathJar / scriptClasspath ).value
       val manifestClasspath = Attributes.Name.CLASS_PATH -> classpath.mkString(" ")
       Seq(ManifestAttributes(manifestClasspath))
     },
-    artifactName in packageJavaClasspathJar := { (scalaVersion, moduleId, artifact) =>
+    packageJavaClasspathJar / artifactName  := { (scalaVersion, moduleId, artifact) =>
       moduleId.organization + "." + artifact.name + "-" + moduleId.revision +
         artifact.classifier.fold("")("-" + _) + "." + artifact.extension
     },
-    scriptClasspath in bashScriptDefines := Seq((artifactPath in packageJavaClasspathJar).value.getName),
-    scriptClasspath in batScriptReplacements := Seq((artifactPath in packageJavaClasspathJar).value.getName),
-    mappings in Universal += {
+    bashScriptDefines / scriptClasspath := Seq((packageJavaClasspathJar / artifactPath ).value.getName),
+    batScriptReplacements/ scriptClasspath   := Seq((packageJavaClasspathJar / artifactPath ).value.getName),
+    Universal / mappings += {
       val classpathJar = packageJavaClasspathJar.value
       classpathJar -> ("lib/" + classpathJar.getName)
     }

src/main/scala/com/typesafe/sbt/packager/jar/LauncherJarPlugin.scala

@@ -24,29 +24,29 @@ object LauncherJarPlugin extends AutoPlugin {
   override def requires = JavaAppPackaging
 
   override lazy val projectSettings: Seq[Setting[_]] = Defaults
-    .packageTaskSettings(packageJavaLauncherJar, mappings in packageJavaLauncherJar) ++ Seq(
-    mappings in packageJavaLauncherJar := Nil,
-    artifactClassifier in packageJavaLauncherJar := Option("launcher"),
-    packageOptions in packageJavaLauncherJar := {
-      val classpath = (scriptClasspath in packageJavaLauncherJar).value
+    .packageTaskSettings(packageJavaLauncherJar, packageJavaLauncherJar / mappings ) ++ Seq(
+    packageJavaLauncherJar / mappings  := Nil,
+    packageJavaLauncherJar / artifactClassifier  := Option("launcher"),
+    packageJavaLauncherJar / packageOptions  := {
+      val classpath = (packageJavaLauncherJar / scriptClasspath ).value
       val manifestClasspath = Attributes.Name.CLASS_PATH -> classpath.mkString(" ")
       val manifestMainClass =
-        (mainClass in (Compile, packageJavaLauncherJar)).value.map(Attributes.Name.MAIN_CLASS -> _)
+        (Compile / packageJavaLauncherJar / mainClass).value.map(Attributes.Name.MAIN_CLASS -> _)
       Seq(ManifestAttributes(manifestMainClass.toSeq :+ manifestClasspath: _*))
     },
-    artifactName in packageJavaLauncherJar := { (scalaVersion, moduleId, artifact) =>
+    packageJavaLauncherJar / artifactName  := { (scalaVersion, moduleId, artifact) =>
       moduleId.organization + "." + artifact.name + "-" + moduleId.revision +
         artifact.classifier.fold("")("-" + _) + "." + artifact.extension
     },
-    mainClass in (Compile, bashScriptDefines) := {
-      Some(s"""-jar "$$lib_dir/${(artifactPath in packageJavaLauncherJar).value.getName}"""")
+    Compile / bashScriptDefines / mainClass := {
+      Some(s"""-jar "$$lib_dir/${(packageJavaLauncherJar / artifactPath ).value.getName}"""")
     },
-    scriptClasspath in bashScriptDefines := Nil,
-    mainClass in (Compile, batScriptReplacements) := {
-      Some(s"""-jar "%APP_LIB_DIR%\\${(artifactPath in packageJavaLauncherJar).value.getName}"""")
+    bashScriptDefines / scriptClasspath  := Nil,
+    Compile / batScriptReplacements / mainClass := {
+      Some(s"""-jar "%APP_LIB_DIR%\\${(packageJavaLauncherJar / artifactPath ).value.getName}"""")
     },
-    scriptClasspath in batScriptReplacements := Nil,
-    mappings in Universal += {
+    batScriptReplacements / scriptClasspath := Nil,
+    Universal / mappings += {
       val javaLauncher = packageJavaLauncherJar.value
       javaLauncher -> ("lib/" + javaLauncher.getName)
     }

src/main/scala/com/typesafe/sbt/packager/jdkpackager/JDKPackagerPlugin.scala

@@ -46,27 +46,27 @@ object JDKPackagerPlugin extends AutoPlugin {
     Seq(
       sourceDirectory := sourceDirectory.value / "deploy",
       target := target.value / dirname,
-      mainClass := (mainClass in Runtime).value,
+      mainClass := (Runtime / mainClass).value,
       name := name.value,
       packageName := packageName.value,
       maintainer := maintainer.value,
       packageSummary := packageSummary.value,
       packageDescription := packageDescription.value,
-      mappings := (mappings in Universal).value,
+      mappings := (Universal / mappings).value,
       antPackagerTasks := locateAntTasks(javaHome.value, sLog.value),
       antExtraClasspath := Seq(sourceDirectory.value, target.value),
       antBuildDefn := makeAntBuild(
         antPackagerTasks.value,
         antExtraClasspath.value,
         name.value,
-        (stage in Universal).value,
+        (Universal / stage).value,
         mappings.value,
         platformDOM(jdkPackagerJVMArgs.value, jdkPackagerProperties.value),
         applicationDOM(name.value, version.value, mainClass.value, jdkPackagerToolkit.value, jdkPackagerAppArgs.value),
         deployDOM(
           jdkPackagerBasename.value,
           jdkPackagerType.value,
-          (artifactPath in LauncherJarPlugin.autoImport.packageJavaLauncherJar).value,
+          (LauncherJarPlugin.autoImport.packageJavaLauncherJar / artifactPath ).value,
           target.value,
           infoDOM(
             name.value,
@@ -90,5 +90,5 @@ object JDKPackagerDeployPlugin extends AutoPlugin {
   override def requires = JDKPackagerPlugin
 
   override def projectSettings: Seq[Setting[_]] =
-    SettingsHelper.makeDeploymentSettings(JDKPackager, packageBin in JDKPackager, "jdkPackager")
+    SettingsHelper.makeDeploymentSettings(JDKPackager, JDKPackager / packageBin, "jdkPackager")
 }