Add option to run an application on either CLASSPATH or MODULEPATH

README.md

@@ -127,10 +127,14 @@ Optionally, the configuration can be modified with:
 - `options`: A list of VM options passed to the executable.
 - `commandlineArgs`: Arguments separated by space for the executed program
 - `includePathExceptionsInClasspath`: When resolving the module-path, setting this value to true will include the 
-dependencies that generate path exceptions in the classpath. By default the value is false, and these dependencies 
+dependencies that generate path exceptions in the classpath. By default, the value is false, and these dependencies 
 won't be included.
+- `runtimePathOption`: Allows to run the application by adding all the dependencies on either classpath or modulepath.
+If set as CLASSPATH, a Launcher class ([like this one](https://github.com/openjfx/samples/blob/master/CommandLine/Non-modular/CLI/hellofx/src/hellofx/Launcher.java))
+is required to run a JavaFX application. Also, if a module-info descriptor is present, it will be ignored.
+Values: MODULEPATH or CLASSPATH.
 
-For instance, the following configuration adds some VM options and a command line argument:
+For instance, the following configuration adds some VM options, and a command line argument:
 
 ```
 <plugin>
@@ -184,6 +188,7 @@ The same command line options for `jlink` can be set:
 - `bindServices`: Adds the option to bind services. Values: false (default) or true
 - `ignoreSigningInformation`: Adds the option to ignore signing information. Values: false (default) or true
 - `jlinkVerbose`: Adds the verbose option. Values: false (default) or true
+- `jlinkOptions`: A list of options passed to the jlink executable.
 - `launcher`: Adds a launcher script with the given name. 
     - If `options` are defined, these will be passed to the launcher script as vm options. 
     - If `commandLineArgs` are defined, these will be passed to the launcher script as command line arguments.

src/main/java/org/openjfx/JavaFXBaseMojo.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Gluon
+ * Copyright 2019, 2020, Gluon
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,6 +25,7 @@
 import org.apache.commons.exec.PumpStreamHandler;
 import org.apache.commons.exec.ShutdownHookProcessDestroyer;
 import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.DependencyResolutionRequiredException;
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.BuildPluginManager;
@@ -39,12 +40,16 @@
 import org.codehaus.plexus.languages.java.jpms.ResolvePathsResult;
 import org.codehaus.plexus.util.StringUtils;
 import org.codehaus.plexus.util.cli.CommandLineUtils;
+import org.openjfx.model.RuntimePathOption;
 
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -56,11 +61,16 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static org.openjfx.model.RuntimePathOption.CLASSPATH;
+import static org.openjfx.model.RuntimePathOption.MODULEPATH;
+
 abstract class JavaFXBaseMojo extends AbstractMojo {
 
+    private static final String JAVAFX_APPLICATION_CLASS_NAME = "javafx.application.Application";
     static final String JAVAFX_PREFIX = "javafx";
 
     @Parameter(defaultValue = "${project}", readonly = true)
@@ -90,6 +100,12 @@ abstract class JavaFXBaseMojo extends AbstractMojo {
     @Parameter(readonly = true, required = true, defaultValue = "${project.build.directory}")
     File builddir;
 
+    /**
+     * Type of {@link RuntimePathOption} to run the application.
+     */
+    @Parameter(property = "javafx.runtimePathOption")
+    RuntimePathOption runtimePathOption;
+
     /**
      * The current working directory. Optional. If not specified, basedir will be used.
      */
@@ -201,69 +217,62 @@ void preparePaths(Path jdkHome) throws MojoExecutionException {
             getLog().debug("Total dependencyArtifacts: " + dependencyArtifacts.size());
             ResolvePathsRequest<File> fileResolvePathsRequest = ResolvePathsRequest.ofFiles(dependencyArtifacts);
 
-            ResolvePathsResult<File> resolvePathsResult;
+            getLog().debug("module descriptor path: " + moduleDescriptorPath);
             if (moduleDescriptorPath != null) {
-                getLog().debug("module descriptor: " + moduleDescriptorPath);
                 fileResolvePathsRequest.setMainModuleDescriptor(moduleDescriptorPath);
             }
             if (jdkHome != null) {
                 fileResolvePathsRequest.setJdkHome(jdkHome.toFile());
             }
-            resolvePathsResult = locationManager.resolvePaths(fileResolvePathsRequest);
-
-            if (!resolvePathsResult.getPathExceptions().isEmpty() && !isMavenUsingJava8()) {
-                // for each path exception, show a warning to plugin user...
-                for (Map.Entry<File, Exception> pathException : resolvePathsResult.getPathExceptions().entrySet()) {
-                    Throwable cause = pathException.getValue();
-                    while (cause.getCause() != null) {
-                        cause = cause.getCause();
-                    }
-                    String fileName = pathException.getKey().getName();
-                    getLog().warn("Can't extract module name from " + fileName + ": " + cause.getMessage());
-                }
-                // ...if includePathExceptionsInClasspath is NOT enabled; provide configuration hint to plugin user
-                if (!includePathExceptionsInClasspath) {
-                    getLog().warn("Some dependencies encountered issues while attempting to be resolved as modules" +
-                        " and will not be included in the classpath; you can change this behavior via the " +
-                        " 'includePathExceptionsInClasspath' configuration parameter.");
-                }
-            }
+            ResolvePathsResult<File> resolvePathsResult = locationManager.resolvePaths(fileResolvePathsRequest);
+            resolvePathsResult.getPathElements().forEach((key, value) -> pathElements.put(key.getPath(), value));
 
-            if (moduleDescriptorPath != null) {
-                moduleDescriptor = resolvePathsResult.getMainModuleDescriptor();
+            if (runtimePathOption == MODULEPATH && moduleDescriptorPath == null) {
+                throw new MojoExecutionException("module-info.java file is required for MODULEPATH runtimePathOption");
             }
 
-            for (Map.Entry<File, ModuleNameSource> entry : resolvePathsResult.getModulepathElements().entrySet()) {
-                if (ModuleNameSource.FILENAME.equals(entry.getValue())) {
-                    final String message = "Required filename-based automodules detected. "
-                            + "Please don't publish this project to a public artifact repository!";
-
-                    if (moduleDescriptor != null && moduleDescriptor.exports().isEmpty()) {
-                        // application
-                        getLog().info(message);
-                    } else {
-                        // library
-                        getLog().warn(message);
+            if (moduleDescriptorPath != null) {
+                if (!resolvePathsResult.getPathExceptions().isEmpty() && !isMavenUsingJava8()) {
+                    // for each path exception, show a warning to plugin user...
+                    for (Map.Entry<File, Exception> pathException : resolvePathsResult.getPathExceptions().entrySet()) {
+                        Throwable cause = pathException.getValue();
+                        while (cause.getCause() != null) {
+                            cause = cause.getCause();
+                        }
+                        String fileName = pathException.getKey().getName();
+                        getLog().warn("Can't extract module name from " + fileName + ": " + cause.getMessage());
+                    }
+                    // ...if includePathExceptionsInClasspath is NOT enabled; provide configuration hint to plugin user
+                    if (!includePathExceptionsInClasspath) {
+                        getLog().warn("Some dependencies encountered issues while attempting to be resolved as modules" +
+                                " and will not be included in the classpath; you can change this behavior via the " +
+                                " 'includePathExceptionsInClasspath' configuration parameter.");
                     }
-                    break;
                 }
-            }
-
-            getLog().debug("pathElements: " + resolvePathsResult.getPathElements().size());
-            resolvePathsResult.getPathElements().forEach((key, value) -> pathElements.put(key.getPath(), value));
-            getLog().debug("classpathElements: " + resolvePathsResult.getClasspathElements().size());
-            resolvePathsResult.getClasspathElements()
-                    .forEach(file -> classpathElements.add(file.getPath()));
-            getLog().debug("modulepathElements: " + resolvePathsResult.getModulepathElements().size());
-            resolvePathsResult.getModulepathElements().keySet()
-                    .forEach(file -> modulepathElements.add(file.getPath()));
-
-            if (includePathExceptionsInClasspath) {
-                resolvePathsResult.getPathExceptions().keySet()
-                    .forEach(file -> classpathElements.add(file.getPath()));
-            }
+                moduleDescriptor = createModuleDescriptor(resolvePathsResult);
+                for (Map.Entry<File, ModuleNameSource> entry : resolvePathsResult.getModulepathElements().entrySet()) {
+                    if (ModuleNameSource.FILENAME.equals(entry.getValue())) {
+                        final String message = "Required filename-based automodules detected. "
+                                + "Please don't publish this project to a public artifact repository!";
+
+                        if (moduleDescriptor != null && moduleDescriptor.exports().isEmpty()) {
+                            // application
+                            getLog().info(message);
+                        } else {
+                            // library
+                            getLog().warn(message);
+                        }
+                        break;
+                    }
+                }
+                resolvePathsResult.getClasspathElements().forEach(file -> classpathElements.add(file.getPath()));
+                resolvePathsResult.getModulepathElements().keySet().forEach(file -> modulepathElements.add(file.getPath()));
 
-            if (moduleDescriptorPath == null) {
+                if (includePathExceptionsInClasspath) {
+                    resolvePathsResult.getPathExceptions().keySet()
+                            .forEach(file -> classpathElements.add(file.getPath()));
+                }
+            } else {
                 // non-modular projects
                 pathElements.forEach((k, v) -> {
                     if (v != null && v.name() != null && v.name().startsWith(JAVAFX_PREFIX)) {
@@ -274,11 +283,32 @@ void preparePaths(Path jdkHome) throws MojoExecutionException {
                     }
                 });
             }
-
         } catch (Exception e) {
             getLog().warn(e.getMessage());
         }
 
+        if (runtimePathOption == MODULEPATH) {
+            getLog().debug(runtimePathOption + " runtimePathOption set by user. Moving all jars to modulepath.");
+            if (moduleDescriptor == null) {
+                // target/classes should still be on classpath
+                final List<String> classpathJars = classpathElements.stream()
+                        .filter(ce -> ce.endsWith(".jar"))
+                        .collect(Collectors.toList());
+                modulepathElements.addAll(classpathJars);
+                classpathElements.removeAll(classpathJars);
+            } else {
+                modulepathElements.addAll(classpathElements);
+                classpathElements.clear();
+            }
+        } else if (runtimePathOption == CLASSPATH) {
+            getLog().debug(runtimePathOption + " runtimePathOption set by user. Moving all jars to classpath.");
+            classpathElements.addAll(modulepathElements);
+            modulepathElements.clear();
+            if (doesExtendFXApplication(mainClass)) {
+                throw new MojoExecutionException("Launcher class is required. Main-class cannot extend Application when running JavaFX application on CLASSPATH");
+            }
+        }
+
         getLog().debug("Classpath:" + classpathElements.size());
         classpathElements.forEach(s -> getLog().debug(" " + s));
 
@@ -289,6 +319,14 @@ void preparePaths(Path jdkHome) throws MojoExecutionException {
         pathElements.forEach((k, v) -> getLog().debug(" " + k + " :: " + (v != null && v.name() != null ? v.name() : v)));
     }
 
+    private JavaModuleDescriptor createModuleDescriptor(ResolvePathsResult<File> resolvePathsResult) throws MojoExecutionException {
+        if (runtimePathOption == CLASSPATH) {
+            getLog().debug(CLASSPATH + " runtimePathOption set by user. module-info.java will be ignored.");
+            return null;
+        }
+        return resolvePathsResult.getMainModuleDescriptor();
+    }
+
     private List<File> getCompileClasspathElements(MavenProject project) {
         List<File> list = new ArrayList<>();
         list.add(new File(project.getBuild().getOutputDirectory()));
@@ -409,6 +447,42 @@ static Path getParent(Path path, int depth) {
         return path.getRoot().resolve(path.subpath(0, path.getNameCount() - depth));
     }
 
+    List<String> splitComplexArgumentString(String argumentString) {
+        char[] strArr = argumentString.trim().toCharArray();
+
+        List<String> splitedArgs = new ArrayList<>();
+        StringBuilder sb = new StringBuilder();
+
+        char expectedSeparator = ' ';
+        for (int i = 0; i < strArr.length; i++) {
+            char item = strArr[i];
+
+            if (item == expectedSeparator
+                    || (expectedSeparator == ' ' && Pattern.matches("\\s", String.valueOf(item))) ) {
+
+                if (expectedSeparator == '"' || expectedSeparator == '\'') {
+                    sb.append(item);
+                    expectedSeparator = ' ';
+                } else if (expectedSeparator == ' ' && sb.length() > 0) {
+                    splitedArgs.add(sb.toString());
+                    sb.delete(0, sb.length());
+                }
+            } else {
+                if (expectedSeparator == ' ' && (item == '"' || item == '\'')) {
+                    expectedSeparator = item;
+                }
+
+                sb.append(item);
+            }
+
+            if (i == strArr.length - 1 && sb.length() > 0) {
+                splitedArgs.add(sb.toString());
+            }
+        }
+
+        return splitedArgs;
+    }
+
     private static String findExecutable(final String executable, final List<String> paths) {
         File f = null;
         search: for (final String path : paths) {
@@ -519,4 +593,32 @@ private ProcessDestroyer getProcessDestroyer() {
         }
         return processDestroyer;
     }
+
+    private boolean doesExtendFXApplication(String mainClass) {
+        boolean fxApplication = false;
+        try {
+            List<URL> pathUrls = new ArrayList<>();
+            for (String path : project.getCompileClasspathElements()) {
+                pathUrls.add(new File(path).toURI().toURL());
+            }
+            URL[] urls = pathUrls.toArray(new URL[0]);
+            URLClassLoader classLoader = new URLClassLoader(urls, JavaFXBaseMojo.class.getClassLoader());
+            Class<?> clazz = Class.forName(mainClass, false, classLoader);
+            fxApplication = doesExtendFXApplication(clazz);
+            getLog().info("app for " + clazz.toString() + " extends Application: " + fxApplication);
+        } catch (NoClassDefFoundError | ClassNotFoundException | DependencyResolutionRequiredException | MalformedURLException e) {
+            getLog().debug(e);
+        }
+        return fxApplication;
+    }
+
+    private static boolean doesExtendFXApplication(Class<?> mainClass) {
+        for (Class<?> sc = mainClass.getSuperclass(); sc != null;
+             sc = sc.getSuperclass()) {
+            if (sc.getName().equals(JAVAFX_APPLICATION_CLASS_NAME)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }

src/main/java/org/openjfx/JavaFXJLinkMojo.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Gluon
+ * Copyright 2019, 2020, Gluon
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,6 +43,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
@@ -151,6 +152,12 @@ public class JavaFXJLinkMojo extends JavaFXBaseMojo {
     @Component(role = Archiver.class, hint = "zip")
     private ZipArchiver zipArchiver;
 
+    /**
+     * A list of options passed to the jlink {@code executable}.
+     */
+    @Parameter
+    List<?> jlinkOptions;
+
     public void execute() throws MojoExecutionException {
         if (skip) {
             getLog().info( "skipping execute as per configuration" );
@@ -166,7 +173,7 @@ public void execute() throws MojoExecutionException {
         }
 
         handleWorkingDirectory();
-        
+
         Map<String, String> enviro = handleSystemEnvVariables();
         CommandLine commandLine = getExecutablePath(jlinkExecutable, enviro, workingDirectory);
 
@@ -182,7 +189,6 @@ public void execute() throws MojoExecutionException {
         }
 
         try {
-
             List<String> commandArguments = createCommandArguments();
             String[] args = commandArguments.toArray(new String[commandArguments.size()]);
             commandLine.addArguments(args, false);
@@ -290,6 +296,17 @@ private void patchLauncherScript(String launcherFilename) throws IOException {
     private List<String> createCommandArguments() throws MojoExecutionException, MojoFailureException {
         List<String> commandArguments = new ArrayList<>();
         preparePaths(getParent(Paths.get(jlinkExecutable), 2));
+
+        if (jlinkOptions != null) {
+            jlinkOptions.stream()
+                    .filter(Objects::nonNull)
+                    .filter(String.class::isInstance)
+                    .map(String.class::cast)
+                    .map(this::splitComplexArgumentString)
+                    .flatMap(Collection::stream)
+                    .forEach(commandArguments::add);
+        }
+
         if (modulepathElements != null && !modulepathElements.isEmpty()) {
             commandArguments.add(" --module-path");
             String modulePath = StringUtils.join(modulepathElements.iterator(), File.pathSeparator);