Add more host system detection

Author: jjohannes

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

@@ -48,6 +48,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;
@@ -274,15 +275,21 @@ 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)) {
-            tasks.register(targetAssembleLifecycle, t -> {
+    private void maybeAddJpackageLifecycleTask(TaskContainer tasks, Target target, TaskProvider<Jpackage> jpackage) {
+        // if a task already exists, do nothing to avoid conflciting with other plugins
+        if (tasks.getNames().contains("jpackage")) {
+            return;
+        }
+        if (HostIdentification.isHostTarget(target)) {
+            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");
+                t.dependsOn(jpackage);
             });
         }
-        tasks.named(targetAssembleLifecycle, t -> t.dependsOn(jpackage));
     }
 
     private Configuration maybeCreateInternalConfiguration() {

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

@@ -24,6 +24,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;
 
@@ -50,14 +51,6 @@ public void apply(Project project) {
         javaModulePackaging.getJpackageResources().convention(project.provider(() ->
                 project.getLayout().getProjectDirectory().dir(mainResources.getSrcDirs().iterator().next().getParent() + "/resourcesPackage")));
         javaModulePackaging.getVerbose().convention(false);
-
-        configureConventionsForCurrentHost();
-    }
-
-    private void configureConventionsForCurrentHost() {
-        // A few conveniences for local development
-        
-
-
+        javaModulePackaging.primaryTarget(HostIdentification.hostTarget(project.getObjects()));
     }
 }

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

@@ -0,0 +1,85 @@
+/*
+ * 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().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);
+    }
+}

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

@@ -50,7 +50,7 @@
 
 import static java.util.Objects.requireNonNull;
 import static org.gradle.nativeplatform.OperatingSystemFamily.WINDOWS;
-import static org.gradlex.javamodule.packaging.internal.Validator.validateHostSystem;
+import static org.gradlex.javamodule.packaging.internal.HostIdentification.validateHostSystem;
 
 @CacheableTask
 abstract public class Jpackage extends DefaultTask {

src/main/java/org/gradlex/javamodule/packaging/tasks/Jpackage.java

@@ -21,7 +21,7 @@
 
 import java.util.Map;
 
-import static org.gradlex.javamodule.packaging.internal.Validator.validateHostSystem;
+import static org.gradlex.javamodule.packaging.internal.HostIdentification.validateHostSystem;
 
 public class ValidateHostSystemAction implements Action<Task> {
     @Override