Implement new features for next release

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Java Module Packaging Gradle Plugin - Changelog
 
+## Version 1.1
+- Configuration option for `--jlink-options` 
+- Configuration option for `--verbose`
+- Configuration option to build packages in one step (interesting for MacOS signing)
+- More options to add custom resources to a package
+- Option to explicitly build the 'app-image' folder only (or in addition)
+- By convention, set default target to current operating system and architecture
+
 ## Version 1.0.1
 * Do not bind platform-specific assemble tasks to a lifecycle
 

README.md

@@ -50,7 +50,7 @@ Add this to the build file of your convention plugin's build
 
 ```
 dependencies {
-    implementation("org.gradlex:java-module-packaging:1.0.1")
+    implementation("org.gradlex:java-module-packaging:1.1")
 }
 ```
 
@@ -80,32 +80,56 @@ javaModulePackaging {
         operatingSystem = OperatingSystemFamily.WINDOWS
         architecture = MachineArchitecture.X86_64
     }
-
-    primaryTarget(target("macos-14"))
 }
 ```
 
 You can now run _target-specific_ builds:
 
-```
-./gradlew assembleWindows
+```shell
+./gradlew jpackageWindows
 ```
 
-```
+```shell
 ./gradlew runWindows
 ```
 
-There are some additional configuration options that can be used:
+Or, for convenience, let the plugin pick the target fitting the machine you run on:
 
+```shell
+./gradlew jpackage
 ```
+
+```shell
+./gradlew run
+```
+
+There are some additional configuration options that can be used if needed.
+All options have a default. Only configure what you need in addition.
+
+```kotlin
 javaModulePackaging {
-    applicationName();
-    applicationVersion();
-    applicationDescription = ""
-    vendor = "My Company" 
-    copyright = "(c) My Company" 
-    jpackageResources.setFrom(...);
-    resources.from(...)
+  // global options
+  applicationName = "app" // defaults to project name
+  applicationVersion = "1.0" // defaults to project version
+  applicationDescription = "Awesome App"
+  vendor = "My Company" 
+  copyright = "(c) My Company" 
+  jlinkOptions.addAll("--no-header-files", "--no-man-pages", "--bind-services")
+  addModules.addAll("additional.module.to.include")
+  jpackageResources = layout.projectDirectory.dir("res") // defaults to 'src/main/resourcesPackage'
+  resources.from(layout.projectDirectory.dir("extra-res"))
+  verbose = false
+
+  // target specific options
+  targetsWithOs("windows") {
+    options.addAll("--win-dir-chooser", "--win-shortcut", "--win-menu")
+    appImageOptions.addAll("--win-console")
+    targetResources.from("windows-res")
+  }
+  targetsWithOs("macos") {
+    options.addAll("--mac-sign", "--mac-signing-key-user-name", "gradlex")
+    singleStepPackaging = true
+  }
 }
 ```
 

build.gradle.kts

@@ -3,7 +3,7 @@ plugins {
 }
 
 group = "org.gradlex"
-version = "1.0.1"
+version = "1.1"
 
 java {
     toolchain.languageVersion = JavaLanguageVersion.of(17)

src/main/java/org/gradlex/javamodule/packaging/JavaModulePackagingExtension.java

@@ -18,6 +18,7 @@
 
 import org.gradle.api.Action;
 import org.gradle.api.NamedDomainObjectContainer;
+import org.gradle.api.NamedDomainObjectSet;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.artifacts.Configuration;
@@ -35,6 +36,7 @@
 import org.gradle.api.plugins.JavaApplication;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.plugins.jvm.JvmTestSuite;
+import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.JavaExec;
 import org.gradle.api.tasks.SourceSet;
@@ -45,6 +47,7 @@
 import org.gradle.nativeplatform.MachineArchitecture;
 import org.gradle.nativeplatform.OperatingSystemFamily;
 import org.gradle.testing.base.TestSuite;
+import org.gradlex.javamodule.packaging.internal.HostIdentification;
 import org.gradlex.javamodule.packaging.model.Target;
 import org.gradlex.javamodule.packaging.tasks.Jpackage;
 import org.gradlex.javamodule.packaging.tasks.ValidateHostSystemAction;
@@ -63,14 +66,18 @@
 abstract public class JavaModulePackagingExtension {
     private static final Attribute<Boolean> JAVA_MODULE_ATTRIBUTE = Attribute.of("javaModule", Boolean.class);
     private static final String INTERNAL = "internal";
+    private static final String JPACKAGE = "jpackage";
 
     abstract public Property<String> getApplicationName();
     abstract public Property<String> getApplicationVersion();
     abstract public Property<String> getApplicationDescription();
     abstract public Property<String> getVendor();
     abstract public Property<String> getCopyright();
+    abstract public ListProperty<String> getJlinkOptions();
+    abstract public ListProperty<String> getAddModules();
     abstract public DirectoryProperty getJpackageResources();
     abstract public ConfigurableFileCollection getResources();
+    abstract public Property<Boolean> getVerbose();
 
     private final NamedDomainObjectContainer<Target> targets = getObjects().domainObjectContainer(Target.class);
 
@@ -109,6 +116,16 @@ public Target target(String label, Action<? super Target> action) {
         return target;
     }
 
+    /**
+     * Configure all targets for the given OS.
+     */
+    @SuppressWarnings("unused")
+    public void targetsWithOs(String operatingSystem, Action<? super Target> action) {
+        NamedDomainObjectSet<Target> matches = targets.matching(t ->
+                t.getOperatingSystem().isPresent() && t.getOperatingSystem().get().equals(operatingSystem));
+        matches.all(action);
+    }
+
     /**
      * Set a 'primary target'. Standard Gradle tasks that are not bound to a specific target – like 'assemble' – use
      * this 'primary target'.
@@ -132,6 +149,7 @@ public Target primaryTarget(Target target) {
     /**
      * Set a test suite to be 'multi-target'. This registers an additional 'test' task for each target.
      */
+    @SuppressWarnings({"unused", "UnstableApiUsage"})
     public TestSuite multiTargetTestSuite(TestSuite testSuite) {
         if (!(testSuite instanceof JvmTestSuite)) {
             return testSuite;
@@ -220,7 +238,7 @@ private void registerTargetSpecificTasks(Target target, String applicationJarTas
         JavaPluginExtension java = getProject().getExtensions().getByType(JavaPluginExtension.class);
         JavaApplication application = getProject().getExtensions().getByType(JavaApplication.class);
 
-        TaskProvider<Jpackage> jpackage = tasks.register("jpackage" + capitalize(target.getName()), Jpackage.class, t -> {
+        TaskProvider<Jpackage> jpackage = tasks.register(JPACKAGE + capitalize(target.getName()), Jpackage.class, t -> {
             t.getJavaInstallation().convention(getJavaToolchains().compilerFor(java.getToolchain()).get().getMetadata());
             t.getOperatingSystem().convention(target.getOperatingSystem());
             t.getArchitecture().convention(target.getArchitecture());
@@ -230,14 +248,20 @@ private void registerTargetSpecificTasks(Target target, String applicationJarTas
             t.getModulePath().from(runtimeClasspath);
 
             t.getApplicationName().convention(getApplicationName());
-            t.getJpackageResources().convention(getJpackageResources().dir(target.getOperatingSystem()));
+            t.getJpackageResources().from(getJpackageResources().dir(target.getOperatingSystem()));
             t.getApplicationDescription().convention(getApplicationDescription());
             t.getVendor().convention(getVendor());
             t.getCopyright().convention(getCopyright());
             t.getJavaOptions().convention(application.getApplicationDefaultJvmArgs());
+            t.getJlinkOptions().convention(getJlinkOptions());
+            t.getAddModules().convention(getAddModules());
             t.getOptions().convention(target.getOptions());
+            t.getAppImageOptions().convention(target.getAppImageOptions());
             t.getPackageTypes().convention(target.getPackageTypes());
+            t.getSingleStepPackaging().convention(target.getSingleStepPackaging());
             t.getResources().from(getResources());
+            t.getTargetResources().from(target.getTargetResources());
+            t.getVerbose().convention(getVerbose());
 
             t.getDestination().convention(getProject().getLayout().getBuildDirectory().dir("packages/" + target.getName()));
             t.getTempDirectory().convention(getProject().getLayout().getBuildDirectory().dir("tmp/jpackage/" + target.getName()));
@@ -252,15 +276,25 @@ private void registerTargetSpecificTasks(Target target, String applicationJarTas
             t.setJvmArgs(application.getApplicationDefaultJvmArgs());
             t.classpath(tasks.named("jar"), runtimeClasspath);
         });
+        maybeAddJpackageLifecycleTask(tasks, target, jpackage);
+    }
 
-        String targetAssembleLifecycle = "assemble" + capitalize(target.getName());
-        if (!tasks.getNames().contains(targetAssembleLifecycle)) {
-            TaskProvider<Task> lifecycleTask = tasks.register(targetAssembleLifecycle, t -> {
+    private void maybeAddJpackageLifecycleTask(TaskContainer tasks, Target target, TaskProvider<Jpackage> targetJpackage) {
+        // if a task already exists, do nothing to avoid conflciting with other plugins
+        TaskProvider<Task> jpackage;
+        if (tasks.getNames().contains(JPACKAGE)) {
+            jpackage = tasks.named(JPACKAGE);
+        } else {
+            jpackage = tasks.register(JPACKAGE, t -> {
                 t.setGroup(BUILD_GROUP);
-                t.setDescription("Builds this project for " + target.getName());
+                t.setDescription("Build the package for the current host system");
             });
         }
-        tasks.named(targetAssembleLifecycle, t -> t.dependsOn(jpackage));
+        jpackage.configure(t -> {
+            if (HostIdentification.isHostTarget(target)) {
+                t.dependsOn(targetJpackage);
+            }
+        });
     }
 
     private Configuration maybeCreateInternalConfiguration() {

src/main/java/org/gradlex/javamodule/packaging/JavaModulePackagingPlugin.java

@@ -23,6 +23,7 @@
 import org.gradle.api.tasks.SourceSetContainer;
 import org.gradle.jvm.toolchain.JavaToolchainService;
 import org.gradle.util.GradleVersion;
+import org.gradlex.javamodule.packaging.internal.HostIdentification;
 
 import javax.inject.Inject;
 
@@ -47,5 +48,7 @@ public void apply(Project project) {
         javaModulePackaging.getApplicationVersion().convention(project.provider(() -> (String) project.getVersion()));
         javaModulePackaging.getJpackageResources().convention(project.provider(() ->
                 project.getLayout().getProjectDirectory().dir(mainResources.getSrcDirs().iterator().next().getParent() + "/resourcesPackage")));
+        javaModulePackaging.getVerbose().convention(false);
+        javaModulePackaging.primaryTarget(HostIdentification.hostTarget(project.getObjects()));
     }
 }

src/main/java/org/gradlex/javamodule/packaging/internal/HostIdentification.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright the GradleX team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.gradlex.javamodule.packaging.internal;
+
+import org.gradle.api.model.ObjectFactory;
+import org.gradle.nativeplatform.MachineArchitecture;
+import org.gradle.nativeplatform.OperatingSystemFamily;
+import org.gradlex.javamodule.packaging.model.Target;
+
+import java.util.Locale;
+
+public class HostIdentification {
+
+    public static void validateHostSystem(String arch, String os) {
+        String hostOs = hostOs();
+        String hostArch = hostArch();
+
+        if (!normalizeOs(hostOs).equals(normalizeOs(os))) {
+            wrongHostSystemError(hostOs, os);
+        }
+        if (!normalizeArch(hostArch).equals(normalizeArch(arch))) {
+            wrongHostSystemError(hostArch, arch);
+        }
+    }
+
+    public static Target hostTarget(ObjectFactory objects) {
+        Target host = objects.newInstance(Target.class, "host");
+        host.getOperatingSystem().convention(hostOs());
+        host.getArchitecture().convention(normalizeArch(System.getProperty("os.arch")));
+        return host;
+    }
+
+    public static boolean isHostTarget(Target target) {
+        return target.getOperatingSystem().isPresent()
+                && target.getArchitecture().isPresent()
+                && target.getOperatingSystem().get().equals(hostOs())
+                && target.getArchitecture().get().equals(normalizeArch(hostArch()));
+    }
+
+    private static String hostOs() {
+        return normalizeOs(System.getProperty("os.name"));
+    }
+
+    private static String hostArch() {
+        return System.getProperty("os.arch");
+    }
+
+    private static String normalizeOs(String name) {
+        String os = name.toLowerCase(Locale.ROOT).replace(" ", "");
+        if (os.contains("windows")) {
+            return OperatingSystemFamily.WINDOWS;
+        }
+        if (os.contains("macos") || os.contains("darwin") || os.contains("osx")) {
+            return OperatingSystemFamily.MACOS;
+        }
+        return OperatingSystemFamily.LINUX;
+    }
+
+    private static String normalizeArch(String name) {
+        String arch = name.toLowerCase(Locale.ROOT);
+        if (arch.contains("aarch")) {
+            return MachineArchitecture.ARM64;
+        }
+        if (arch.contains("64")) {
+            return MachineArchitecture.X86_64;
+        }
+        return MachineArchitecture.X86;
+    }
+
+    private static void wrongHostSystemError(String hostOs, String os) {
+        throw new RuntimeException("Running on " + hostOs + "; cannot build for " + os);
+    }
+}