Add option to run an application on either CLASSPATH or MODULEPATH

README.md

@@ -127,10 +127,20 @@ 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`: The default behaviour of the plugin is to place the dependencies either on 
+modulepath or classpath depending on various factors. For example, if a dependency contains module descriptor or Automatic-Module-Name
+it will be placed on the module-path. `runtimePathOption` configuration allows to run the application by placing all the dependencies on either classpath or modulepath.
 
-For instance, the following configuration adds some VM options and a command line argument:
+    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.
+
+### Example
+
+The following configuration adds some VM options, and a command line argument:
 
 ```
 <plugin>

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;
@@ -55,12 +60,17 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Properties;
 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(createMainClassString(mainClass, moduleDescriptor, runtimePathOption))) {
+                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,22 @@ static Path getParent(Path path, int depth) {
         return path.getRoot().resolve(path.subpath(0, path.getNameCount() - depth));
     }
 
+    String createMainClassString(String mainClass, JavaModuleDescriptor moduleDescriptor, RuntimePathOption runtimePathOption) {
+        Objects.requireNonNull(mainClass, "Main class cannot be null");
+        if (runtimePathOption == CLASSPATH) {
+            if (mainClass.contains("/")) {
+                getLog().warn("Module name found in <mainClass> with runtimePathOption set as CLASSPATH. Module name will be ignored.");
+                return mainClass.substring(mainClass.indexOf("/") + 1);
+            }
+            return mainClass;
+        }
+        if (moduleDescriptor != null && !mainClass.contains("/")) {
+            getLog().warn("Module name not found in <mainClass>. Module name will be assumed from module-info.java");
+            return moduleDescriptor.name() + "/" + mainClass;
+        }
+        return mainClass;
+    }
+
     private static String findExecutable(final String executable, final List<String> paths) {
         File f = null;
         search: for (final String path : paths) {
@@ -519,4 +573,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;
+    }
 }