├── .ci
    ├── deploy-snapshot.sh
    ├── gpg_keys.tar.enc
    ├── release.sh
    ├── update-archetypes.sh
    ├── update-gluon-samples.sh
    └── update-openjfx-docs.sh
├── .gitignore
├── .travis.settings.xml
├── .travis.yml
├── LICENSE
├── README.md
├── pom.xml
└── src
    ├── main
        ├── java
        │   └── org
        │   │   └── openjfx
        │   │       ├── JavaFXBaseMojo.java
        │   │       ├── JavaFXJLinkMojo.java
        │   │       ├── JavaFXRunMojo.java
        │   │       └── model
        │   │           └── RuntimePathOption.java
        └── resources
        │   └── META-INF
        │       └── plexus
        │           └── components.xml
    └── test
        ├── java
            └── org
            │   └── openjfx
            │       ├── JavaFXBaseMojoTest.java
            │       ├── JavaFXRunMojoTestCase.java
            │       ├── MavenArtifactResolver.java
            │       ├── TestJavaFXRun0.java
            │       ├── TestJavaFXRun1.java
            │       └── TestLauncher.java
        └── resources
            └── unit
                ├── javafxrun-app-test
                    └── pom.xml
                ├── javafxrun-basic-test
                    └── pom.xml
                └── javafxrun-classpath-test
                    ├── classpath-launcher.xml
                    └── classpath-no-launcher.xml


/.ci/deploy-snapshot.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | # Find version
 4 | ver=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)
 5 | 
 6 | # deploy if snapshot found
 7 | if [[ $ver == *"SNAPSHOT"* ]] 
 8 | then
 9 |     cp .travis.settings.xml $HOME/.m2/settings.xml
10 |     mvn deploy -DskipTests=true -Dgpg.skip
11 | fi


--------------------------------------------------------------------------------
/.ci/gpg_keys.tar.enc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/openjfx/javafx-maven-plugin/3b0520e0d26ae6b11398f872b82088129eb4077a/.ci/gpg_keys.tar.enc


--------------------------------------------------------------------------------
/.ci/release.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | # Exit immediately if any command in the script fails
 4 | set -e
 5 | 
 6 | # Configure GIT
 7 | git config --global user.name "Gluon Bot"
 8 | git config --global user.email "githubbot@gluonhq.com"
 9 | 
10 | # Decrypt encrypted files
11 | openssl aes-256-cbc -K $encrypted_04317ab43744_key -iv $encrypted_04317ab43744_iv -in .ci/gpg_keys.tar.enc -out gpg_keys.tar -d
12 | if [[ ! -s gpg_keys.tar ]]
13 |    then echo "Decryption failed."
14 |    exit 1
15 | fi
16 | tar xvf gpg_keys.tar
17 | 
18 | # Release artifacts
19 | cp .travis.settings.xml $HOME/.m2/settings.xml && mvn deploy -DskipTests=true -B -U -Prelease
20 | 
21 | # Update version by 1
22 | newVersion=${TRAVIS_TAG%.*}.$((${TRAVIS_TAG##*.} + 1))
23 | 
24 | # Update README with the latest released version
25 | sed -i '/<plugin>/ {
26 |     :start
27 |     N
28 |     /<\/plugin>$/!b start
29 |     /<artifactId>javafx-maven-plugin<\/artifactId>/ {
30 |         /<version>.*<\/version>/s//<version>'"$TRAVIS_TAG"'<\/version>/
31 |     }
32 | }' README.md
33 | git commit README.md -m "Use latest release v$TRAVIS_TAG in README"
34 | 
35 | # Update project version to next snapshot version
36 | mvn versions:set -DnewVersion=$newVersion-SNAPSHOT -DgenerateBackupPoms=false
37 | 
38 | git commit pom.xml -m "Prepare development of $newVersion"
39 | git push https://gluon-bot:$GITHUB_PASSWORD@github.com/$TRAVIS_REPO_SLUG HEAD:master
40 | 
41 | # Update archetypes
42 | bash .ci/update-archetypes.sh "$TRAVIS_TAG"
43 | 
44 | # Update openjfx-docs
45 | bash .ci/update-openjfx-docs.sh "$TRAVIS_TAG"
46 | 
47 | # Update gluon-samples
48 | bash .ci/update-gluon-samples.sh "$TRAVIS_TAG"


--------------------------------------------------------------------------------
/.ci/update-archetypes.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | export REPO_NAME=javafx-maven-archetypes
 4 | export REPO_SLUG=openjfx/javafx-maven-archetypes
 5 | export XML_LOCATION=src/main/resources/META-INF/maven/archetype-metadata.xml
 6 | 
 7 | cd $TRAVIS_BUILD_DIR
 8 | git clone https://github.com/$REPO_SLUG
 9 | cd $REPO_NAME
10 | 
11 | # Traverse through all sub-directories starting with "javafx-archetype-"
12 | for f in ./javafx-archetype-* ; do
13 |   # f is directory and not a symlink
14 |   if [[  -d "$f" && ! -L "$f" ]]; then\
15 |     # Update <defaultValue> for parent node <requiredProperty> with key='javafx-maven-plugin-version'
16 |     xmlstarlet ed -P -L -u "//_:requiredProperty[@key='javafx-maven-plugin-version']/_:defaultValue" -v "$1" "$f"/$XML_LOCATION
17 |   fi
18 | done
19 | 
20 | git commit */$XML_LOCATION -m "Upgrade javafx-maven-plugin version to $1"
21 | git push https://gluon-bot:$GITHUB_PASSWORD@github.com/$REPO_SLUG HEAD:master


--------------------------------------------------------------------------------
/.ci/update-gluon-samples.sh:
--------------------------------------------------------------------------------
 1 | SAMPLES_REPO_SLUG=gluonhq/gluon-samples
 2 | 
 3 | cd $TRAVIS_BUILD_DIR
 4 | git clone https://github.com/$SAMPLES_REPO_SLUG
 5 | cd gluon-samples
 6 | 
 7 | # Update plugin version
 8 | mvn versions:set-property -Dproperty=javafx.maven.plugin.version -DnewVersion="$1" -DgenerateBackupPoms=false
 9 | 
10 | git commit pom.xml -m "Update javafx-maven-plugin version to $1"
11 | git push https://gluon-bot:$GITHUB_PASSWORD@github.com/$SAMPLES_REPO_SLUG HEAD:master
12 | 


--------------------------------------------------------------------------------
/.ci/update-openjfx-docs.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | export REPO_NAME=openjfx-docs
 4 | export REPO_SLUG=openjfx/openjfx-docs
 5 | export VERSION_FILE_LOCATION=js/gluon.js
 6 | 
 7 | cd $TRAVIS_BUILD_DIR
 8 | git clone https://github.com/$REPO_SLUG
 9 | cd $REPO_NAME
10 | 
11 | # Update javafx-maven-plugin version
12 | sed -i "0,/JFX_MVN_PLUGIN_VERSION = \".*\"/s//JFX_MVN_PLUGIN_VERSION = \"$1\"/" $VERSION_FILE_LOCATION
13 | 
14 | git commit $VERSION_FILE_LOCATION -m "Upgrade javafx-maven-plugin version to $1"
15 | git push https://gluon-bot:$GITHUB_PASSWORD@github.com/$REPO_SLUG HEAD:master


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Maven
 2 | target
 3 | 
 4 | #IntelliJ IDEA
 5 | *.iml
 6 | .idea
 7 | 
 8 | # BlueJ files
 9 | *.ctxt
10 | 
11 | # VM Crash Files
12 | hs_err_pid*
13 | 
14 | # Log file
15 | *.log
16 | /.settings
17 | /.project
18 | /.classpath
19 | 


--------------------------------------------------------------------------------
/.travis.settings.xml:
--------------------------------------------------------------------------------
 1 | <settings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/SETTINGS/1.0.0" xsi:schemalocation="http://maven.apache.org/SETTINGS/1.0.0
 2 |                       http://maven.apache.org/xsd/settings-1.0.0.xsd">
 3 |     <servers>
 4 |         <server>
 5 |             <id>ossrh</id>
 6 |             <username>${SONATYPE_USERNAME}</username>
 7 |             <password>${SONATYPE_PASSWORD}</password>
 8 |         </server>
 9 |     </servers>
10 | 
11 |     <profiles>
12 |         <profile>
13 |             <id>ossrh</id>
14 |             <activation>
15 |                 <activeByDefault>true</activeByDefault>
16 |             </activation>
17 |             <properties>
18 |                 <gpg.executable>${GPG_EXECUTABLE}</gpg.executable>
19 |                 <gpg.keyname>${GPG_KEYNAME}</gpg.keyname>
20 |                 <gpg.passphrase>${GPG_PASSPHRASE}</gpg.passphrase>
21 |                 <!-- Tell gpg to NOT use the default keyring from the current user's home -->
22 |                 <gpg.defaultKeyring>false</gpg.defaultKeyring>
23 |                 <!-- Tell gpg to use the keyrings -->
24 |                 <gpg.publicKeyring>${TRAVIS_BUILD_DIR}/pubring.gpg</gpg.publicKeyring>
25 |                 <gpg.secretKeyring>${TRAVIS_BUILD_DIR}/secring.gpg</gpg.secretKeyring>
26 |             </properties>
27 |         </profile>
28 |     </profiles>
29 | </settings>


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | # use java support
 2 | language: java
 3 | jdk: openjdk11
 4 | 
 5 | # run in container
 6 | sudo: false
 7 | 
 8 | # use linux as operating system
 9 | os: linux
10 | dist: xenial
11 | 
12 | # configure xvfb screen
13 | services:
14 |   - xvfb
15 | 
16 | # Install xmlstarlet
17 | addons:
18 |   apt:
19 |     packages:
20 |       - xmlstarlet
21 | 
22 | # Do not run travis install step
23 | install: true
24 | 
25 | # Assemble jars
26 | script:
27 |   - mvn clean compile verify
28 | 
29 | cache:
30 |   directories:
31 |     - $HOME/.m2
32 | 
33 | deploy:
34 |   # Deploy snapshots on every commit made to master
35 |   - provider: script
36 |     script: bash .ci/deploy-snapshot.sh
37 |     skip_cleanup: true
38 |     on:
39 |       branch: master
40 | 
41 |   # Deploy releases on every tag push
42 |   - provider: script
43 |     script: bash .ci/release.sh
44 |     skip_cleanup: true
45 |     on:
46 |       tags: true


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Maven plugin for JavaFX
  2 | 
  3 | [![Maven Central](https://img.shields.io/maven-central/v/org.openjfx/javafx-maven-plugin.svg?color=%234DC71F)](https://search.maven.org/#search|ga|1|org.openjfx.javafx-maven-plugin)
  4 | [![Travis CI](https://api.travis-ci.com/openjfx/javafx-maven-plugin.svg?branch=master)](https://travis-ci.com/openjfx/javafx-maven-plugin)
  5 | [![Apache License](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0)
  6 | 
  7 | Maven plugin to run JavaFX 11+ applications
  8 | 
  9 | ## Install
 10 | 
 11 | The plugin is available via Maven Central. 
 12 | 
 13 | In case you want to build and install the latest snapshot, you can
 14 | clone the project, set JDK 11 and run
 15 | 
 16 | ```
 17 | mvn install
 18 | ``` 
 19 | 
 20 | ## Usage
 21 | 
 22 | Create a new Maven project, use an existing one like [HelloFX](https://github.com/openjfx/samples/tree/master/CommandLine/Modular/Maven/hellofx), or use an [archetype](https://github.com/openjfx/javafx-maven-archetypes).
 23 | 
 24 | The project can be modular or non-modular.
 25 | 
 26 | JavaFX dependencies are added as usual:
 27 | 
 28 | ```
 29 | <dependency>
 30 |     <groupId>org.openjfx</groupId>
 31 |     <artifactId>javafx-controls</artifactId>
 32 |     <version>12.0.2</version>
 33 | </dependency>
 34 | ```
 35 | 
 36 | Add the plugin:
 37 | 
 38 | ```
 39 | <plugin>
 40 |     <groupId>org.openjfx</groupId>
 41 |     <artifactId>javafx-maven-plugin</artifactId>
 42 |     <version>0.0.8</version>
 43 |     <configuration>
 44 |         <mainClass>hellofx/org.openjfx.App</mainClass>
 45 |     </configuration>
 46 | </plugin>
 47 | ```
 48 | 
 49 | Compile the project:
 50 | 
 51 | ```
 52 | mvn compile
 53 | ```
 54 | 
 55 | This step is optional and can be configured using the [maven-compiler-plugin](https://maven.apache.org/plugins/maven-compiler-plugin/).
 56 | 
 57 | Run the project:
 58 | 
 59 | ```
 60 | mvn javafx:run
 61 | ```
 62 | 
 63 | For modular projects, create and run a custom image:
 64 | 
 65 | ```
 66 | mvn javafx:jlink
 67 | 
 68 | target/image/bin/java -m hellofx/org.openjfx.App
 69 | ```
 70 | 
 71 | ### javafx:run options
 72 | 
 73 | The plugin includes by default: `--module-path`, `--add-modules` and `-classpath` options. 
 74 | 
 75 | Optionally, the configuration can be modified with:
 76 | 
 77 | - `mainClass`: The main class, fully qualified name, with or without module name
 78 | - `workingDirectory`: The current working directory
 79 | - `skip`: Skip the execution. Values: false (default), true
 80 | - `outputFile`: File to redirect the process output
 81 | - `options`: A list of VM options passed to the executable.
 82 | - `commandlineArgs`: Arguments separated by space for the executed program
 83 | - `includePathExceptionsInClasspath`: When resolving the module-path, setting this value to true will include the 
 84 | dependencies that generate path exceptions in the classpath. By default, the value is false, and these dependencies 
 85 | won't be included.
 86 | - `runtimePathOption`: By default, the plugin will place *each* dependency either on modulepath or on classpath (based on certain factors).
 87 | When `runtimePathOption` configuration is set, the plugin will place *all* the dependencies on either modulepath or classpath.
 88 | 
 89 |     If set as `MODULEPATH`, a module descriptor is required. All dependencies need to be either modularized or contain an Automatic-Module-Name.
 90 | 
 91 |     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))
 92 | is required to run a JavaFX application. Also, if a module-info descriptor is present, it will be ignored.
 93 | 
 94 |     Values: MODULEPATH or CLASSPATH.
 95 | 
 96 | This plugin supports Maven toolchains using the "jdk" tool.
 97 | 
 98 | ### Example
 99 | 
100 | The following configuration adds some VM options, and a command line argument:
101 | 
102 | ```
103 | <plugin>
104 |     <groupId>org.openjfx</groupId>
105 |     <artifactId>javafx-maven-plugin</artifactId>
106 |     <version>0.0.8</version>
107 |     <configuration>
108 |         <mainClass>org.openjfx.hellofx/org.openjfx.App</mainClass>
109 |         <options>
110 |             <option>-Dbar=${bar}</option>
111 |             <option>--add-opens</option>
112 |             <option>java.base/java.lang=org.openjfx.hellofx</option>
113 |         </options>
114 |         <commandlineArgs>foo</commandlineArgs>
115 |     </configuration>
116 | </plugin>
117 | ```
118 | 
119 | When running maven with
120 | ```
121 | mvn -Dbar=myBar javafx:run
122 | ```
123 | it will be processed by the main method like:
124 | 
125 | ```java
126 | public static void main(String[] args) {
127 |     if (args.length > 0 && "foo".equals(args[0])) {
128 |         // do something
129 |     }
130 |     if ("myBar".equals(System.getProperty("bar"))) {
131 |         // do something
132 |     }
133 |     launch();
134 | }
135 | ```
136 | 
137 | Note that the evaluation of `System.getProperty("bar")` can happen in any other place in the code.
138 | 
139 | **Note**
140 | 
141 | It is possible to use a local SDK instead of Maven Central. 
142 | This is helpful for developers trying to test a local build of OpenJFX. 
143 | Since transitive dependencies are not resolved, 
144 | all the required jars needs to be added as a separate dependency, like:
145 | 
146 | ```
147 | <properties>
148 |     <sdk>/path/to/javafx-sdk</sdk>
149 | </properties>
150 | 
151 | <dependencies>
152 |     <dependency>
153 |         <groupId>org.openjfx</groupId>
154 |         <artifactId>javafx.base</artifactId>
155 |         <version>1.0</version>
156 |         <scope>system</scope>
157 |         <systemPath>${sdk}/lib/javafx.base.jar</systemPath>
158 |     </dependency>
159 |     ...
160 | </dependencies>
161 | ```
162 | 
163 | ### javafx:jlink options
164 | 
165 | The same command line options for `jlink` can be set:
166 | 
167 | - `stripDebug`: Strips debug information out. Values: false (default) or true
168 | - `stripJavaDebugAttributes`: Strip Java debug attributes out (since Java 13), Values: false (default) or true
169 | - `compress`: Compression level of the resources being used. Values: 0 (default), 1, 2. 
170 | - `noHeaderFiles`: Removes the `includes` directory in the resulting runtime image. Values: false (default) or true
171 | - `noManPages`: Removes the `man` directory in the resulting runtime image. Values: false (default) or true
172 | - `bindServices`: Adds the option to bind services. Values: false (default) or true
173 | - `ignoreSigningInformation`: Adds the option to ignore signing information. Values: false (default) or true
174 | - `jlinkVerbose`: Adds the verbose option. Values: false (default) or true
175 | - `launcher`: Adds a launcher script with the given name. 
176 |     - If `options` are defined, these will be passed to the launcher script as vm options. 
177 |     - If `commandLineArgs` are defined, these will be passed to the launcher script as command line arguments.
178 | - `jlinkImageName`: The name of the folder with the resulting runtime image
179 | - `jlinkZipName`: When set, creates a zip of the resulting runtime image
180 | - `jlinkExecutable`: The `jlink` executable. It can be a full path or the name of the executable, if it is in the PATH.
181 | - `jmodsPath`: When using a local JavaFX SDK, sets the path to the local JavaFX jmods
182 | 
183 | For instance, with the following configuration:
184 | 
185 | ```
186 | <plugin>
187 |     <groupId>org.openjfx</groupId>
188 |     <artifactId>javafx-maven-plugin</artifactId>
189 |     <version>0.0.8</version>
190 |     <configuration>
191 |         <stripDebug>true</stripDebug>
192 |         <compress>2</compress>
193 |         <noHeaderFiles>true</noHeaderFiles>
194 |         <noManPages>true</noManPages>
195 |         <launcher>hellofx</launcher>
196 |         <jlinkImageName>hello</jlinkImageName>
197 |         <jlinkZipName>hellozip</jlinkZipName>
198 |         <mainClass>hellofx/org.openjfx.MainApp</mainClass>
199 |     </configuration>
200 | </plugin>
201 | ```
202 | 
203 | A custom image can be created and run as:
204 | 
205 | ```
206 | mvn clean javafx:jlink
207 | 
208 | target/hello/bin/hellofx
209 | ```
210 | 
211 | ## Issues and Contributions ##
212 | 
213 | Issues can be reported to the [Issue tracker](https://github.com/openjfx/javafx-maven-plugin/issues/).
214 | 
215 | Contributions can be submitted via [Pull requests](https://github.com/openjfx/javafx-maven-plugin/pulls/), 
216 | providing you have signed the [Gluon Individual Contributor License Agreement (CLA)](https://docs.google.com/forms/d/16aoFTmzs8lZTfiyrEm8YgMqMYaGQl0J8wA0VJE2LCCY).
217 | 
218 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <!--
  2 |  ~ Copyright 2019 Gluon
  3 |  ~
  4 |  ~ Licensed under the Apache License, Version 2.0 (the "License");
  5 |  ~ you may not use this file except in compliance with the License.
  6 |  ~ You may obtain a copy of the License at
  7 |  ~
  8 |  ~   http://www.apache.org/licenses/LICENSE-2.0
  9 |  ~
 10 |  ~ Unless required by applicable law or agreed to in writing, software
 11 |  ~ distributed under the License is distributed on an "AS IS" BASIS,
 12 |  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  ~ See the License for the specific language governing permissions and
 14 |  ~ limitations under the License.
 15 |   -->
 16 | 
 17 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 18 |   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 19 |   <modelVersion>4.0.0</modelVersion>
 20 |   <groupId>org.openjfx</groupId>
 21 |   <artifactId>javafx-maven-plugin</artifactId>
 22 |   <packaging>maven-plugin</packaging>
 23 |   <version>0.0.9-SNAPSHOT</version>
 24 |   <name>javafx-maven-plugin Maven Mojo</name>
 25 |   <description>The JavaFX Plugin is used to run JavaFX 11+ projects</description>
 26 |   <inceptionYear>2019</inceptionYear>
 27 | 
 28 |   <url>https://openjfx.io</url>
 29 | 
 30 |   <properties>
 31 |     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 32 |     <maven.compiler.source>8</maven.compiler.source>
 33 |     <maven.compiler.target>8</maven.compiler.target>
 34 |     <javafx.version>12.0.1</javafx.version>
 35 |     <javadoc.plugin.version>3.1.0</javadoc.plugin.version>
 36 |     <gpg.plugin.version>1.6</gpg.plugin.version>
 37 |   </properties>
 38 | 
 39 |   <dependencies>
 40 |     <dependency>
 41 |       <groupId>org.apache.maven</groupId>
 42 |       <artifactId>maven-plugin-api</artifactId>
 43 |       <version>3.6.0</version>
 44 |     </dependency>
 45 |     <dependency>
 46 |       <groupId>org.apache.maven.plugin-tools</groupId>
 47 |       <artifactId>maven-plugin-annotations</artifactId>
 48 |       <version>3.6.0</version>
 49 |       <scope>provided</scope>
 50 |     </dependency>
 51 |     <dependency>
 52 |       <groupId>org.codehaus.plexus</groupId>
 53 |       <artifactId>plexus-java</artifactId>
 54 |       <version>0.9.11</version>
 55 |     </dependency>
 56 |     <dependency>
 57 |       <groupId>org.codehaus.plexus</groupId>
 58 |       <artifactId>plexus-archiver</artifactId>
 59 |       <version>3.6.0</version>
 60 |     </dependency>
 61 |     <dependency>
 62 |       <groupId>org.apache.commons</groupId>
 63 |       <artifactId>commons-exec</artifactId>
 64 |       <version>1.3</version>
 65 |     </dependency>
 66 | 
 67 |     <!--test-->
 68 |     <dependency>
 69 |       <groupId>org.openjfx</groupId>
 70 |       <artifactId>javafx-controls</artifactId>
 71 |       <version>${javafx.version}</version>
 72 |       <scope>test</scope>
 73 |     </dependency>
 74 |     <dependency>
 75 |       <groupId>org.apache.maven.plugin-testing</groupId>
 76 |       <artifactId>maven-plugin-testing-harness</artifactId>
 77 |       <version>3.3.0</version>
 78 |       <scope>test</scope>
 79 |     </dependency>
 80 |     <dependency>
 81 |       <groupId>org.apache.maven</groupId>
 82 |       <artifactId>maven-core</artifactId>
 83 |       <version>3.6.0</version>
 84 |     </dependency>
 85 |     <dependency>
 86 |       <groupId>org.apache.maven</groupId>
 87 |       <artifactId>maven-compat</artifactId>
 88 |       <version>3.6.0</version>
 89 |       <scope>test</scope>
 90 |     </dependency>
 91 |     <dependency>
 92 |       <groupId>org.apache.maven</groupId>
 93 |       <artifactId>maven-aether-provider</artifactId>
 94 |       <version>3.3.9</version>
 95 |       <scope>test</scope>
 96 |     </dependency>
 97 |       <dependency>
 98 |           <groupId>org.eclipse.aether</groupId>
 99 |           <artifactId>aether-transport-http</artifactId>
100 |           <version>1.1.0</version>
101 |           <scope>test</scope>
102 |       </dependency>
103 |       <dependency>
104 |           <groupId>org.eclipse.aether</groupId>
105 |           <artifactId>aether-transport-file</artifactId>
106 |           <version>1.1.0</version>
107 |           <scope>test</scope>
108 |       </dependency>
109 |       <dependency>
110 |           <groupId>org.eclipse.aether</groupId>
111 |           <artifactId>aether-connector-basic</artifactId>
112 |           <version>1.1.0</version>
113 |           <scope>test</scope>
114 |       </dependency>
115 |     <dependency>
116 |       <groupId>org.codehaus.plexus</groupId>
117 |       <artifactId>plexus-interpolation</artifactId>
118 |       <version>1.25</version>
119 |       <scope>test</scope>
120 |     </dependency>
121 |     <dependency>
122 |       <groupId>org.mockito</groupId>
123 |       <artifactId>mockito-core</artifactId>
124 |       <version>2.24.5</version>
125 |       <scope>test</scope>
126 |     </dependency>
127 |     <dependency>
128 |       <groupId>junit</groupId>
129 |       <artifactId>junit</artifactId>
130 |       <version>4.13.1</version>
131 |       <scope>test</scope>
132 |     </dependency>
133 |   </dependencies>
134 | 
135 |   <build>
136 |     <plugins>
137 |       <plugin>
138 |         <groupId>org.apache.maven.plugins</groupId>
139 |         <artifactId>maven-compiler-plugin</artifactId>
140 |         <version>3.8.0</version>
141 |         <configuration>
142 |           <source>${maven.compiler.source}</source>
143 |           <target>${maven.compiler.target}</target>
144 |         </configuration>
145 |       </plugin>
146 |       <plugin>
147 |         <groupId>org.apache.maven.plugins</groupId>
148 |         <artifactId>maven-plugin-plugin</artifactId>
149 |         <version>3.6.0</version>
150 |       </plugin>
151 |       <plugin>
152 |         <groupId>org.sonatype.plugins</groupId>
153 |         <artifactId>nexus-staging-maven-plugin</artifactId>
154 |         <version>1.6.7</version>
155 |         <extensions>true</extensions>
156 |         <configuration>
157 |           <serverId>ossrh</serverId>
158 |           <nexusUrl>https://oss.sonatype.org/</nexusUrl>
159 |           <autoReleaseAfterClose>true</autoReleaseAfterClose>
160 |         </configuration>
161 |       </plugin>
162 |     </plugins>
163 |   </build>
164 | 
165 |   <profiles>
166 |     <profile>
167 |       <id>release</id>
168 |       <build>
169 |         <plugins>
170 |           <plugin>
171 |             <groupId>org.apache.maven.plugins</groupId>
172 |             <artifactId>maven-source-plugin</artifactId>
173 |             <version>2.2.1</version>
174 |             <executions>
175 |               <execution>
176 |                 <id>attach-sources</id>
177 |                 <goals>
178 |                   <goal>jar-no-fork</goal>
179 |                 </goals>
180 |               </execution>
181 |             </executions>
182 |           </plugin>
183 |           <plugin>
184 |             <groupId>org.apache.maven.plugins</groupId>
185 |             <artifactId>maven-javadoc-plugin</artifactId>
186 |             <version>${javadoc.plugin.version}</version>
187 |             <executions>
188 |               <execution>
189 |                 <id>attach-javadocs</id>
190 |                 <goals>
191 |                   <goal>jar</goal>
192 |                 </goals>
193 |               </execution>
194 |             </executions>
195 |             <configuration>
196 |               <source>8</source>
197 |             </configuration>
198 |           </plugin>
199 |           <plugin>
200 |             <groupId>org.apache.maven.plugins</groupId>
201 |             <artifactId>maven-gpg-plugin</artifactId>
202 |             <version>${gpg.plugin.version}</version>
203 |             <executions>
204 |               <execution>
205 |                 <id>sign-artifacts</id>
206 |                 <phase>verify</phase>
207 |                 <goals>
208 |                   <goal>sign</goal>
209 |                 </goals>
210 |                 <configuration>
211 |                   <!-- This is necessary for gpg to not try to use the pinentry programs -->
212 |                   <!-- Only required for GPG >= 2.2 -->
213 |                   <!--
214 |                   <gpgArguments>
215 |                     <arg>&#45;&#45;pinentry-mode</arg>
216 |                     <arg>loopback</arg>
217 |                   </gpgArguments>
218 |                   -->
219 |                 </configuration>
220 |               </execution>
221 |             </executions>
222 |           </plugin>
223 |         </plugins>
224 |       </build>
225 |     </profile>
226 |   </profiles>
227 | 
228 |   <organization>
229 |     <name>Gluon</name>
230 |     <url>https://www.gluonhq.com</url>
231 |   </organization>
232 | 
233 |   <issueManagement>
234 |     <system>GitHub</system>
235 |     <url>https://github.com/openjfx/javafx-maven-plugin/issues</url>
236 |   </issueManagement>
237 | 
238 |   <licenses>
239 |     <license>
240 |       <name>The Apache Software License, Version 2.0</name>
241 |       <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
242 |       <distribution>repo</distribution>
243 |     </license>
244 |   </licenses>
245 | 
246 |   <developers>
247 |     <developer>
248 |       <name>Abhinay Agarwal</name>
249 |       <email>abhinay.agarwal@gluonhq.com</email>
250 |       <organization>Gluon</organization>
251 |       <organizationUrl>https://www.gluonhq.com</organizationUrl>
252 |     </developer>
253 |     <developer>
254 |       <name>José Pereda</name>
255 |       <email>jose.pereda@gluonhq.com</email>
256 |       <organization>Gluon</organization>
257 |       <organizationUrl>https://www.gluonhq.com</organizationUrl>
258 |     </developer>
259 |   </developers>
260 | 
261 |   <scm>
262 |     <url>https://github.com/openjfx/javafx-maven-plugin</url>
263 |     <connection>scm:git:git://github.com/openjfx/javafx-maven-plugin.git</connection>
264 |     <developerConnection>scm:git:ssh://git@github.com:openjfx/javafx-maven-plugin.git</developerConnection>
265 |   </scm>
266 | 
267 |   <distributionManagement>
268 |     <snapshotRepository>
269 |       <id>ossrh</id>
270 |       <url>https://oss.sonatype.org/content/repositories/snapshots</url>
271 |     </snapshotRepository>
272 |     <repository>
273 |       <id>ossrh</id>
274 |       <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
275 |     </repository>
276 |   </distributionManagement>
277 | </project>
278 | 


--------------------------------------------------------------------------------
/src/main/java/org/openjfx/JavaFXBaseMojo.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2019, 2020, Gluon
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *   http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.openjfx;
 18 | 
 19 | import static org.openjfx.model.RuntimePathOption.CLASSPATH;
 20 | import static org.openjfx.model.RuntimePathOption.MODULEPATH;
 21 | 
 22 | import java.io.BufferedOutputStream;
 23 | import java.io.File;
 24 | import java.io.FileOutputStream;
 25 | import java.io.IOException;
 26 | import java.io.OutputStream;
 27 | import java.net.MalformedURLException;
 28 | import java.net.URL;
 29 | import java.net.URLClassLoader;
 30 | import java.nio.file.Files;
 31 | import java.nio.file.Path;
 32 | import java.nio.file.Paths;
 33 | import java.util.ArrayList;
 34 | import java.util.Arrays;
 35 | import java.util.Collection;
 36 | import java.util.HashMap;
 37 | import java.util.LinkedHashMap;
 38 | import java.util.List;
 39 | import java.util.Map;
 40 | import java.util.Objects;
 41 | import java.util.Properties;
 42 | import java.util.stream.Collectors;
 43 | import java.util.stream.Stream;
 44 | 
 45 | import org.apache.commons.exec.CommandLine;
 46 | import org.apache.commons.exec.ExecuteException;
 47 | import org.apache.commons.exec.ExecuteResultHandler;
 48 | import org.apache.commons.exec.Executor;
 49 | import org.apache.commons.exec.OS;
 50 | import org.apache.commons.exec.ProcessDestroyer;
 51 | import org.apache.commons.exec.PumpStreamHandler;
 52 | import org.apache.commons.exec.ShutdownHookProcessDestroyer;
 53 | import org.apache.maven.artifact.Artifact;
 54 | import org.apache.maven.artifact.DependencyResolutionRequiredException;
 55 | import org.apache.maven.execution.MavenSession;
 56 | import org.apache.maven.plugin.AbstractMojo;
 57 | import org.apache.maven.plugin.BuildPluginManager;
 58 | import org.apache.maven.plugin.MojoExecutionException;
 59 | import org.apache.maven.plugins.annotations.Component;
 60 | import org.apache.maven.plugins.annotations.Parameter;
 61 | import org.apache.maven.project.MavenProject;
 62 | import org.apache.maven.toolchain.Toolchain;
 63 | import org.apache.maven.toolchain.ToolchainManager;
 64 | import org.codehaus.plexus.languages.java.jpms.JavaModuleDescriptor;
 65 | import org.codehaus.plexus.languages.java.jpms.LocationManager;
 66 | import org.codehaus.plexus.languages.java.jpms.ModuleNameSource;
 67 | import org.codehaus.plexus.languages.java.jpms.ResolvePathsRequest;
 68 | import org.codehaus.plexus.languages.java.jpms.ResolvePathsResult;
 69 | import org.codehaus.plexus.util.StringUtils;
 70 | import org.codehaus.plexus.util.cli.CommandLineUtils;
 71 | import org.openjfx.model.RuntimePathOption;
 72 | 
 73 | abstract class JavaFXBaseMojo extends AbstractMojo {
 74 | 
 75 |     private static final String JAVAFX_APPLICATION_CLASS_NAME = "javafx.application.Application";
 76 |     static final String JAVAFX_PREFIX = "javafx";
 77 | 
 78 |     @Parameter(defaultValue = "${project}", readonly = true)
 79 |     MavenProject project;
 80 | 
 81 |     @Parameter(defaultValue = "${session}", readonly = true)
 82 |     private MavenSession session;
 83 | 
 84 |     @Component
 85 |     private BuildPluginManager pluginManager;
 86 | 
 87 |     @Component
 88 |     private LocationManager locationManager;
 89 | 
 90 |     @Parameter(property = "javafx.mainClass", required = true)
 91 |     String mainClass;
 92 | 
 93 |     /**
 94 |      * Skip the execution.
 95 |      */
 96 |     @Parameter(property = "javafx.skip", defaultValue = "false")
 97 |     boolean skip;
 98 | 
 99 |     @Parameter(readonly = true, required = true, defaultValue = "${basedir}")
100 |     File basedir;
101 | 
102 |     @Parameter(readonly = true, required = true, defaultValue = "${project.build.directory}")
103 |     File builddir;
104 | 
105 |     /**
106 |      * Type of {@link RuntimePathOption} to run the application.
107 |      */
108 |     @Parameter(property = "javafx.runtimePathOption")
109 |     RuntimePathOption runtimePathOption;
110 | 
111 |     /**
112 |      * The current working directory. Optional. If not specified, basedir will be used.
113 |      */
114 |     @Parameter(property = "javafx.workingDirectory")
115 |     File workingDirectory;
116 | 
117 |     @Parameter(defaultValue = "${project.compileClasspathElements}", readonly = true, required = true)
118 |     private List<String> compilePath;
119 | 
120 |     @Parameter(property = "javafx.outputFile")
121 |     File outputFile;
122 | 
123 |     /**
124 |      * If set to true the child process executes asynchronously and build execution continues in parallel.
125 |      */
126 |     @Parameter(property = "javafx.async", defaultValue = "false")
127 |     private boolean async;
128 | 
129 |     /**
130 |      * If set to true, the asynchronous child process is destroyed upon JVM shutdown. If set to false, asynchronous
131 |      * child process continues execution after JVM shutdown. Applies only to asynchronous processes; ignored for
132 |      * synchronous processes.
133 |      */
134 |     @Parameter(property = "javafx.asyncDestroyOnShutdown", defaultValue = "true")
135 |     private boolean asyncDestroyOnShutdown;
136 | 
137 |     /**
138 |      * <p>
139 |      * A list of vm options passed to the {@code executable}.
140 |      * </p>
141 |      *
142 |      */
143 |     @Parameter
144 |     List<?> options;
145 | 
146 |     /**
147 |      * Arguments separated by space for the executed program. For example: "-j 20"
148 |      */
149 |     @Parameter(property = "javafx.args")
150 |     String commandlineArgs;
151 | 
152 |     /**
153 |      * If set to true, it will include the dependencies that
154 |      * generate path exceptions in the classpath. Default is false.
155 |      */
156 |     @Parameter(property = "javafx.includePathExceptionsInClasspath", defaultValue = "false")
157 |     private boolean includePathExceptionsInClasspath;
158 | 
159 |     /**
160 |     *
161 |     */
162 |     @Component
163 |     private ToolchainManager toolchainManager;
164 |    
165 |     List<String> classpathElements;
166 |     List<String> modulepathElements;
167 |     Map<String, JavaModuleDescriptor> pathElements;
168 |     JavaModuleDescriptor moduleDescriptor;
169 |     private ProcessDestroyer processDestroyer;
170 | 
171 |     static boolean isMavenUsingJava8() {
172 |         return System.getProperty("java.version").startsWith("1.8");
173 |     }
174 | 
175 |     static boolean isTargetUsingJava8(CommandLine commandLine) {
176 |         final String java = commandLine.getExecutable();
177 |         return java != null && Files.exists(Paths.get(java).resolve("../../jre/lib/rt.jar").normalize());
178 |     }
179 | 
180 |     void preparePaths(Path jdkHome) throws MojoExecutionException {
181 |         if (project == null) {
182 |             return;
183 |         }
184 | 
185 |         String outputDirectory = project.getBuild().getOutputDirectory();
186 |         if (outputDirectory == null || outputDirectory.isEmpty()) {
187 |             throw new MojoExecutionException("Error: Output directory doesn't exist");
188 |         }
189 | 
190 |         File[] classes = new File(outputDirectory).listFiles();
191 |         if (classes == null || classes.length == 0) {
192 |             throw new MojoExecutionException("Error: Output directory is empty");
193 |         }
194 | 
195 |         File moduleDescriptorPath = Stream
196 |                 .of(classes)
197 |                 .filter(file -> "module-info.class".equals(file.getName()))
198 |                 .findFirst()
199 |                 .orElse(null);
200 | 
201 |         modulepathElements = new ArrayList<>(compilePath.size());
202 |         classpathElements = new ArrayList<>(compilePath.size());
203 |         pathElements = new LinkedHashMap<>(compilePath.size());
204 | 
205 |         try {
206 |             Collection<File> dependencyArtifacts = getCompileClasspathElements(project);
207 |             getLog().debug("Total dependencyArtifacts: " + dependencyArtifacts.size());
208 |             ResolvePathsRequest<File> fileResolvePathsRequest = ResolvePathsRequest.ofFiles(dependencyArtifacts);
209 | 
210 |             getLog().debug("module descriptor path: " + moduleDescriptorPath);
211 |             if (moduleDescriptorPath != null) {
212 |                 fileResolvePathsRequest.setMainModuleDescriptor(moduleDescriptorPath);
213 |             }
214 |             if (jdkHome != null) {
215 |                 fileResolvePathsRequest.setJdkHome(jdkHome.toFile());
216 |             }
217 |             ResolvePathsResult<File> resolvePathsResult = locationManager.resolvePaths(fileResolvePathsRequest);
218 |             resolvePathsResult.getPathElements().forEach((key, value) -> pathElements.put(key.getPath(), value));
219 | 
220 |             if (!resolvePathsResult.getPathExceptions().isEmpty()) {
221 |                 getLog().warn("There are " + resolvePathsResult.getPathExceptions().size() + " pathException(s). The related dependencies will be ignored.");
222 |                 resolvePathsResult.getPathExceptions().forEach((key, value) -> {
223 |                     String message = "Dependency: " + key;
224 |                     if (value != null) {
225 |                         message += "\n   - exception: " + value.getMessage();
226 |                         Throwable t = value.getCause();
227 |                         if (t != null) {
228 |                             message += "\n   - cause: " + t.getMessage();
229 |                         }
230 |                     }
231 |                     getLog().warn(message);
232 |                 });
233 |             }
234 | 
235 |             if (runtimePathOption == MODULEPATH && moduleDescriptorPath == null) {
236 |                 throw new MojoExecutionException("module-info.java file is required for MODULEPATH runtimePathOption");
237 |             }
238 | 
239 |             if (moduleDescriptorPath != null) {
240 |                 if (!resolvePathsResult.getPathExceptions().isEmpty() && !isMavenUsingJava8()) {
241 |                     // for each path exception, show a warning to plugin user...
242 |                     for (Map.Entry<File, Exception> pathException : resolvePathsResult.getPathExceptions().entrySet()) {
243 |                         Throwable cause = pathException.getValue();
244 |                         while (cause.getCause() != null) {
245 |                             cause = cause.getCause();
246 |                         }
247 |                         String fileName = pathException.getKey().getName();
248 |                         getLog().warn("Can't extract module name from " + fileName + ": " + cause.getMessage());
249 |                     }
250 |                     // ...if includePathExceptionsInClasspath is NOT enabled; provide configuration hint to plugin user
251 |                     if (!includePathExceptionsInClasspath) {
252 |                         getLog().warn("Some dependencies encountered issues while attempting to be resolved as modules" +
253 |                                 " and will not be included in the classpath; you can change this behavior via the " +
254 |                                 " 'includePathExceptionsInClasspath' configuration parameter.");
255 |                     }
256 |                 }
257 |                 moduleDescriptor = createModuleDescriptor(resolvePathsResult);
258 |                 for (Map.Entry<File, ModuleNameSource> entry : resolvePathsResult.getModulepathElements().entrySet()) {
259 |                     if (ModuleNameSource.FILENAME.equals(entry.getValue())) {
260 |                         final String message = "Required filename-based automodules detected. "
261 |                                 + "Please don't publish this project to a public artifact repository!";
262 | 
263 |                         if (moduleDescriptor != null && moduleDescriptor.exports().isEmpty()) {
264 |                             // application
265 |                             getLog().info(message);
266 |                         } else {
267 |                             // library
268 |                             getLog().warn(message);
269 |                         }
270 |                         break;
271 |                     }
272 |                 }
273 |                 resolvePathsResult.getClasspathElements().forEach(file -> classpathElements.add(file.getPath()));
274 |                 resolvePathsResult.getModulepathElements().keySet().forEach(file -> modulepathElements.add(file.getPath()));
275 | 
276 |                 if (includePathExceptionsInClasspath) {
277 |                     resolvePathsResult.getPathExceptions().keySet()
278 |                             .forEach(file -> classpathElements.add(file.getPath()));
279 |                 }
280 |             } else {
281 |                 // non-modular projects
282 |                 pathElements.forEach((k, v) -> {
283 |                     if (v != null && v.name() != null && v.name().startsWith(JAVAFX_PREFIX)) {
284 |                         // only JavaFX jars are required in the module-path
285 |                         modulepathElements.add(k);
286 |                     } else {
287 |                         classpathElements.add(k);
288 |                     }
289 |                 });
290 |             }
291 |         } catch (Exception e) {
292 |             getLog().warn(e.getMessage());
293 |         }
294 | 
295 |         if (runtimePathOption == MODULEPATH) {
296 |             getLog().debug(runtimePathOption + " runtimePathOption set by user. Moving all jars to modulepath.");
297 |             modulepathElements.addAll(classpathElements);
298 |             classpathElements.clear();
299 |         } else if (runtimePathOption == CLASSPATH) {
300 |             getLog().debug(runtimePathOption + " runtimePathOption set by user. Moving all jars to classpath.");
301 |             classpathElements.addAll(modulepathElements);
302 |             modulepathElements.clear();
303 |             if (mainClass.contains("/")) {
304 |                 getLog().warn("Module name found in <mainClass> with runtimePathOption set as CLASSPATH. Module name will be ignored.");
305 |             }
306 |             if (doesExtendFXApplication(createMainClassString(mainClass, moduleDescriptor, runtimePathOption))) {
307 |                 throw new MojoExecutionException("Launcher class is required. Main-class cannot extend Application when running JavaFX application on CLASSPATH");
308 |             }
309 |         }
310 | 
311 |         getLog().debug("Classpath:" + classpathElements.size());
312 |         classpathElements.forEach(s -> getLog().debug(" " + s));
313 | 
314 |         getLog().debug("Modulepath: " + modulepathElements.size());
315 |         modulepathElements.forEach(s -> getLog().debug(" " + s));
316 | 
317 |         getLog().debug("pathElements: " + pathElements.size());
318 |         pathElements.forEach((k, v) -> getLog().debug(" " + k + " :: " + (v != null && v.name() != null ? v.name() : v)));
319 |     }
320 | 
321 |     private JavaModuleDescriptor createModuleDescriptor(ResolvePathsResult<File> resolvePathsResult) throws MojoExecutionException {
322 |         if (runtimePathOption == CLASSPATH) {
323 |             getLog().info(CLASSPATH + " runtimePathOption set by user. module-info.java will be ignored.");
324 |             return null;
325 |         }
326 |         return resolvePathsResult.getMainModuleDescriptor();
327 |     }
328 | 
329 |     private List<File> getCompileClasspathElements(MavenProject project) {
330 |         List<File> list = new ArrayList<>();
331 |         list.add(new File(project.getBuild().getOutputDirectory()));
332 | 
333 |         // include systemPath dependencies
334 |         list.addAll(project.getDependencies().stream()
335 |                 .filter(d -> d.getSystemPath() != null && ! d.getSystemPath().isEmpty())
336 |                 .map(d -> new File(d.getSystemPath()))
337 |                 .collect(Collectors.toList()));
338 | 
339 |         list.addAll(project.getArtifacts().stream()
340 |                 .sorted((a1, a2) -> {
341 |                     int compare = a1.compareTo(a2);
342 |                     if (compare == 0) {
343 |                         // give precedence to classifiers
344 |                         return a1.hasClassifier() ? 1 : (a2.hasClassifier() ? -1 : 0);
345 |                     }
346 |                     return compare;
347 |                 })
348 |                 .map(Artifact::getFile)
349 |                 .collect(Collectors.toList()));
350 |         return list.stream()
351 |                 .distinct()
352 |                 .collect(Collectors.toList());
353 |     }
354 | 
355 |     void handleWorkingDirectory() throws MojoExecutionException {
356 |         if (workingDirectory == null) {
357 |             workingDirectory = basedir;
358 |         }
359 | 
360 |         if (!workingDirectory.exists()) {
361 |             getLog().debug("Making working directory '" + workingDirectory.getAbsolutePath() + "'.");
362 |             if (!workingDirectory.mkdirs()) {
363 |                 throw new MojoExecutionException("Could not make working directory: '" + workingDirectory.getAbsolutePath() + "'");
364 |             }
365 |         }
366 |     }
367 | 
368 |     Map<String, String> handleSystemEnvVariables() {
369 |         Map<String, String> enviro = new HashMap<>();
370 |         try {
371 |             Properties systemEnvVars = CommandLineUtils.getSystemEnvVars();
372 |             for (Map.Entry<?, ?> entry : systemEnvVars.entrySet()) {
373 |                 enviro.put((String) entry.getKey(), (String) entry.getValue());
374 |             }
375 |         } catch (IOException x) {
376 |             getLog().error("Could not assign default system environment variables.", x);
377 |         }
378 | 
379 |         return enviro;
380 |     }
381 | 
382 |     CommandLine getExecutablePath(String executable, Map<String, String> enviro, File dir) {
383 |         File execFile = new File(executable);
384 |         String exec = null;
385 |         if (execFile.isFile()) {
386 |             getLog().debug("'executable' parameter is set to " + executable);
387 |             exec = execFile.getAbsolutePath();
388 |         }
389 | 
390 |         if (exec == null && toolchainManager != null) {
391 |         	Toolchain toolchain = toolchainManager.getToolchainFromBuildContext("jdk", session);
392 |             if (toolchain != null) {
393 |                 getLog().info("Toolchain in javafx-maven-plugin " + toolchain);
394 |                 exec = toolchain.findTool("java");
395 |                 getLog().debug("Tool in toolchain in javafx-maven-plugin " + exec);
396 |             }
397 |         }
398 | 
399 |         if (exec == null) {
400 |             String javaHomeFromEnv = getJavaHomeEnv(enviro);
401 |             if (javaHomeFromEnv != null && ! javaHomeFromEnv.isEmpty()) {
402 |                 exec = findExecutable(executable, Arrays.asList(javaHomeFromEnv.concat(File.separator).concat("bin")));
403 |             }
404 |         }
405 | 
406 |         if (exec == null && OS.isFamilyWindows()) {
407 |             List<String> paths = this.getExecutablePaths(enviro);
408 |             paths.add(0, dir.getAbsolutePath());
409 |             exec = findExecutable(executable, paths);
410 |         }
411 | 
412 |         if (exec == null) {
413 |             exec = executable;
414 |         }
415 | 
416 |         CommandLine toRet;
417 |         if (OS.isFamilyWindows() && !hasNativeExtension(exec) && hasExecutableExtension(exec) ) {
418 |             // run the windows batch script in isolation and exit at the end
419 |             final String comSpec = System.getenv( "ComSpec" );
420 |             toRet = new CommandLine( comSpec == null ? "cmd" : comSpec );
421 |             toRet.addArgument( "/c" );
422 |             toRet.addArgument( exec );
423 |         } else {
424 |             toRet = new CommandLine(exec);
425 |         }
426 |         getLog().debug("Executable " + toRet.toString());
427 |         return toRet;
428 |     }
429 | 
430 |     int executeCommandLine(Executor exec, CommandLine commandLine, Map<String, String> enviro,
431 |                            OutputStream out, OutputStream err) throws ExecuteException, IOException {
432 |         // note: don't use BufferedOutputStream here since it delays the outputs MEXEC-138
433 |         PumpStreamHandler psh = new PumpStreamHandler(out, err, System.in);
434 |         return executeCommandLine(exec, commandLine, enviro, psh);
435 |     }
436 | 
437 |     int executeCommandLine(Executor exec, CommandLine commandLine, Map<String, String> enviro,
438 |                            FileOutputStream outputFile) throws ExecuteException, IOException {
439 |         BufferedOutputStream bos = new BufferedOutputStream(outputFile);
440 |         PumpStreamHandler psh = new PumpStreamHandler(bos);
441 |         return executeCommandLine(exec, commandLine, enviro, psh);
442 |     }
443 | 
444 |     /**
445 |      * Returns the path of the parent directory.
446 |      * At the given depth if the path has no parent, the method returns null.
447 |      * @param path Path against which the parent needs to be evaluated
448 |      * @param depth Depth of the path relative to parent
449 |      * @return Path to the parent, if exists. Null, otherwise.
450 |      */
451 |     static Path getParent(Path path, int depth) {
452 |         if (path == null || !Files.exists(path) || depth > path.getNameCount()) {
453 |             return null;
454 |         }
455 |         return path.getRoot().resolve(path.subpath(0, path.getNameCount() - depth));
456 |     }
457 | 
458 |     String createMainClassString(String mainClass, JavaModuleDescriptor moduleDescriptor, RuntimePathOption runtimePathOption) {
459 |         Objects.requireNonNull(mainClass, "Main class cannot be null");
460 |         if (runtimePathOption == CLASSPATH) {
461 |             if (mainClass.contains("/")) {
462 |                 return mainClass.substring(mainClass.indexOf("/") + 1);
463 |             }
464 |             return mainClass;
465 |         }
466 |         if (moduleDescriptor != null && !mainClass.contains("/")) {
467 |             getLog().warn("Module name not found in <mainClass>. Module name will be assumed from module-info.java");
468 |             return moduleDescriptor.name() + "/" + mainClass;
469 |         }
470 |         return mainClass;
471 |     }
472 | 
473 |     private static String findExecutable(final String executable, final List<String> paths) {
474 |         File f = null;
475 |         search: for (final String path : paths) {
476 |             f = new File(path, executable);
477 |             if (!OS.isFamilyWindows() && f.isFile()) {
478 |                 break;
479 |             } else {
480 |                 for (final String extension : getExecutableExtensions()) {
481 |                     f = new File(path, executable + extension);
482 |                     if (f.isFile()) {
483 |                         break search;
484 |                     }
485 |                 }
486 |             }
487 |         }
488 | 
489 |         if (f == null || !f.exists()) {
490 |             return null;
491 |         }
492 |         return f.getAbsolutePath();
493 |     }
494 | 
495 |     private static boolean hasNativeExtension(final String exec) {
496 |         final String lowerCase = exec.toLowerCase();
497 |         return lowerCase.endsWith(".exe") || lowerCase.endsWith(".com");
498 |     }
499 | 
500 |     private static boolean hasExecutableExtension(final String exec) {
501 |         final String lowerCase = exec.toLowerCase();
502 |         for (final String ext : getExecutableExtensions()) {
503 |             if (lowerCase.endsWith(ext)) {
504 |                 return true;
505 |             }
506 |         }
507 |         return false;
508 |     }
509 | 
510 |     private static List<String> getExecutableExtensions() {
511 |         final String pathExt = System.getenv("PATHEXT");
512 |         return pathExt == null ? Arrays.asList(".bat", ".cmd")
513 |                 : Arrays.asList(StringUtils.split(pathExt.toLowerCase(), File.pathSeparator));
514 |     }
515 | 
516 |     private List<String> getExecutablePaths(Map<String, String> enviro) {
517 |         List<String> paths = new ArrayList<>();
518 |         paths.add("");
519 | 
520 |         String path = enviro.get("PATH");
521 |         if (path != null) {
522 |             paths.addAll(Arrays.asList(StringUtils.split(path, File.pathSeparator)));
523 |         }
524 |         return paths;
525 |     }
526 | 
527 |     private String getJavaHomeEnv(Map<String, String> enviro) {
528 |         String javahome = enviro.get("JAVA_HOME");
529 |         if (javahome == null || javahome.isEmpty()) {
530 |             return null;
531 |         }
532 | 
533 |         int pathStartIndex = javahome.charAt(0) == '"' ? 1 : 0;
534 |         int pathEndIndex = javahome.charAt(javahome.length() - 1) == '"' ? javahome.length() - 1 : javahome.length();
535 | 
536 |         return javahome.substring(pathStartIndex, pathEndIndex);
537 |     }
538 | 
539 |     private int executeCommandLine(Executor exec, final CommandLine commandLine, Map<String, String> enviro,
540 |                                    final PumpStreamHandler psh) throws ExecuteException, IOException {
541 |         exec.setStreamHandler(psh);
542 | 
543 |         int result;
544 |         try {
545 |             psh.start();
546 |             if (async) {
547 |                 if (asyncDestroyOnShutdown) {
548 |                     exec.setProcessDestroyer(getProcessDestroyer());
549 |                 }
550 | 
551 |                 exec.execute(commandLine, enviro, new ExecuteResultHandler() {
552 |                     public void onProcessFailed(ExecuteException e) {
553 |                         getLog().error("Async process failed for: " + commandLine, e);
554 |                     }
555 | 
556 |                     public void onProcessComplete(int exitValue) {
557 |                         getLog().debug("Async process complete, exit value = " + exitValue + " for: " + commandLine);
558 |                         try {
559 |                             psh.stop();
560 |                         } catch (IOException e) {
561 |                             getLog().error("Error stopping async process stream handler for: " + commandLine, e);
562 |                         }
563 |                     }
564 |                 });
565 |                 result = 0;
566 |             } else {
567 |                 result = exec.execute(commandLine, enviro);
568 |             }
569 |         } finally {
570 |             if (!async) {
571 |                 psh.stop();
572 |             }
573 |         }
574 |         return result;
575 |     }
576 | 
577 |     private ProcessDestroyer getProcessDestroyer() {
578 |         if (processDestroyer == null) {
579 |             processDestroyer = new ShutdownHookProcessDestroyer();
580 |         }
581 |         return processDestroyer;
582 |     }
583 | 
584 |     private boolean doesExtendFXApplication(String mainClass) {
585 |         boolean fxApplication = false;
586 |         try {
587 |             List<URL> pathUrls = new ArrayList<>();
588 |             for (String path : project.getCompileClasspathElements()) {
589 |                 pathUrls.add(new File(path).toURI().toURL());
590 |             }
591 |             URL[] urls = pathUrls.toArray(new URL[0]);
592 |             URLClassLoader classLoader = new URLClassLoader(urls, JavaFXBaseMojo.class.getClassLoader());
593 |             Class<?> clazz = Class.forName(mainClass, false, classLoader);
594 |             fxApplication = doesExtendFXApplication(clazz);
595 |             getLog().debug("Main Class " + clazz.toString() + " extends Application: " + fxApplication);
596 |         } catch (NoClassDefFoundError | ClassNotFoundException | DependencyResolutionRequiredException | MalformedURLException e) {
597 |             getLog().debug(e);
598 |         }
599 |         return fxApplication;
600 |     }
601 | 
602 |     private static boolean doesExtendFXApplication(Class<?> mainClass) {
603 |         for (Class<?> sc = mainClass.getSuperclass(); sc != null;
604 |              sc = sc.getSuperclass()) {
605 |             if (sc.getName().equals(JAVAFX_APPLICATION_CLASS_NAME)) {
606 |                 return true;
607 |             }
608 |         }
609 |         return false;
610 |     }
611 | }
612 | 


--------------------------------------------------------------------------------
/src/main/java/org/openjfx/JavaFXJLinkMojo.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2019 Gluon
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *   http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.openjfx;
 18 | 
 19 | import org.apache.commons.exec.CommandLine;
 20 | import org.apache.commons.exec.DefaultExecutor;
 21 | import org.apache.commons.exec.ExecuteException;
 22 | import org.apache.commons.exec.Executor;
 23 | import org.apache.commons.exec.OS;
 24 | import org.apache.maven.plugin.MojoExecutionException;
 25 | import org.apache.maven.plugin.MojoFailureException;
 26 | import org.apache.maven.plugins.annotations.Component;
 27 | import org.apache.maven.plugins.annotations.Execute;
 28 | import org.apache.maven.plugins.annotations.LifecyclePhase;
 29 | import org.apache.maven.plugins.annotations.Mojo;
 30 | import org.apache.maven.plugins.annotations.Parameter;
 31 | import org.apache.maven.plugins.annotations.ResolutionScope;
 32 | import org.codehaus.plexus.archiver.Archiver;
 33 | import org.codehaus.plexus.archiver.ArchiverException;
 34 | import org.codehaus.plexus.archiver.zip.ZipArchiver;
 35 | import org.codehaus.plexus.util.IOUtil;
 36 | import org.codehaus.plexus.util.StringUtils;
 37 | 
 38 | import java.io.ByteArrayOutputStream;
 39 | import java.io.File;
 40 | import java.io.FileOutputStream;
 41 | import java.io.IOException;
 42 | import java.nio.file.Files;
 43 | import java.nio.file.Path;
 44 | import java.nio.file.Paths;
 45 | import java.util.ArrayList;
 46 | import java.util.Comparator;
 47 | import java.util.List;
 48 | import java.util.Map;
 49 | import java.util.Objects;
 50 | import java.util.regex.Pattern;
 51 | import java.util.stream.Collectors;
 52 | 
 53 | @Mojo(name = "jlink", requiresDependencyResolution = ResolutionScope.RUNTIME)
 54 | @Execute(phase = LifecyclePhase.PROCESS_CLASSES)
 55 | public class JavaFXJLinkMojo extends JavaFXBaseMojo {
 56 | 
 57 |     private static final Pattern JLINK_VERSION_PATTERN = Pattern.compile("(1[3-9]|[2-9][0-9]|\\d{3,})");
 58 | 
 59 |     /**
 60 |      * Strips debug information out, equivalent to <code>-G, --strip-debug</code>,
 61 |      * default false
 62 |      */
 63 |     @Parameter(property = "javafx.stripDebug", defaultValue = "false")
 64 |     private boolean stripDebug;
 65 | 
 66 |     /**
 67 |      * Strip Java debug attributes out, equivalent to <code>--strip-java-debug-attributes</code>,
 68 |      * default false
 69 |      */
 70 |     @Parameter(property = "javafx.stripJavaDebugAttributes", defaultValue = "false")
 71 |     private boolean stripJavaDebugAttributes;
 72 | 
 73 |     /**
 74 |      * Compression level of the resources being used, equivalent to:
 75 |      * <code>-c, --compress=level</code>. Valid values: <code>0, 1, 2</code>,
 76 |      * default 0
 77 |      */
 78 |     @Parameter(property = "javafx.compress", defaultValue = "0")
 79 |     private Integer compress;
 80 | 
 81 |     /**
 82 |      * Remove the <code>includes</code> directory in the resulting runtime image,
 83 |      * equivalent to: <code>--no-header-files</code>, default false
 84 |      */
 85 |     @Parameter(property = "javafx.noHeaderFiles", defaultValue = "false")
 86 |     private boolean noHeaderFiles;
 87 | 
 88 |     /**
 89 |      * Remove the <code>man</code> directory in the resulting Java runtime image,
 90 |      * equivalent to: <code>--no-man-pages</code>, default false
 91 |      */
 92 |     @Parameter(property = "javafx.noManPages", defaultValue = "false")
 93 |     private boolean noManPages;
 94 | 
 95 |     /**
 96 |      * Add the option <code>--bind-services</code> or not, default false.
 97 |      */
 98 |     @Parameter(property = "javafx.bindServices", defaultValue = "false")
 99 |     private boolean bindServices;
100 | 
101 |     /**
102 |      * <code>--ignore-signing-information</code>, default false
103 |      */
104 |     @Parameter(property = "javafx.ignoreSigningInformation", defaultValue = "false")
105 |     private boolean ignoreSigningInformation;
106 | 
107 |     /**
108 |      * Turn on verbose mode, equivalent to: <code>--verbose</code>, default false
109 |      */
110 |     @Parameter(property = "javafx.jlinkVerbose", defaultValue = "false")
111 |     private boolean jlinkVerbose;
112 | 
113 |     /**
114 |      * Add a launcher script, equivalent to:
115 |      * <code>--launcher &lt;name&gt;=&lt;module&gt;[/&lt;mainclass&gt;]</code>.
116 |      */
117 |     @Parameter(property = "javafx.launcher")
118 |     private String launcher;
119 | 
120 |     /**
121 |      * The name of the folder with the resulting runtime image,
122 |      * equivalent to <code>--output &lt;path&gt;</code>
123 |      */
124 |     @Parameter(property = "javafx.jlinkImageName", defaultValue = "image")
125 |     private String jlinkImageName;
126 | 
127 |     /**
128 |      * When set, creates a zip of the resulting runtime image.
129 |      */
130 |     @Parameter(property = "javafx.jlinkZipName")
131 |     private String jlinkZipName;
132 | 
133 |     /**
134 |      * <p>
135 |      * The executable. Can be a full path or the name of the executable.
136 |      * In the latter case, the executable must be in the PATH for the execution to work.
137 |      * </p>
138 |      */
139 |     @Parameter(property = "javafx.jlinkExecutable", defaultValue = "jlink")
140 |     private String jlinkExecutable;
141 | 
142 |     /**
143 |      * Optional jmodsPath path for local builds.
144 |      */
145 |     @Parameter(property = "javafx.jmodsPath")
146 |     private String jmodsPath;
147 | 
148 |     /**
149 |      * The JAR archiver needed for archiving the environments.
150 |      */
151 |     @Component(role = Archiver.class, hint = "zip")
152 |     private ZipArchiver zipArchiver;
153 | 
154 |     public void execute() throws MojoExecutionException {
155 |         if (skip) {
156 |             getLog().info( "skipping execute as per configuration" );
157 |             return;
158 |         }
159 | 
160 |         if (jlinkExecutable == null) {
161 |             throw new MojoExecutionException("The parameter 'jlinkExecutable' is missing or invalid");
162 |         }
163 | 
164 |         if (basedir == null) {
165 |             throw new IllegalStateException( "basedir is null. Should not be possible." );
166 |         }
167 | 
168 |         handleWorkingDirectory();
169 |         
170 |         Map<String, String> enviro = handleSystemEnvVariables();
171 |         CommandLine commandLine = getExecutablePath(jlinkExecutable, enviro, workingDirectory);
172 | 
173 |         if (isTargetUsingJava8(commandLine)) {
174 |             getLog().info("Jlink not supported with Java 1.8");
175 |             return;
176 |         }
177 | 
178 |         if (stripJavaDebugAttributes && !isJLinkVersion13orHigher(commandLine.getExecutable())) {
179 |             stripJavaDebugAttributes = false;
180 |             getLog().warn("JLink parameter --strip-java-debug-attributes only supported for version 13 and higher");
181 |             getLog().warn("The option 'stripJavaDebugAttributes' was skipped");
182 |         }
183 | 
184 |         try {
185 | 
186 |             List<String> commandArguments = createCommandArguments();
187 |             String[] args = commandArguments.toArray(new String[commandArguments.size()]);
188 |             commandLine.addArguments(args, false);
189 |             getLog().debug("Executing command line: " + commandLine);
190 | 
191 |             Executor exec = new DefaultExecutor();
192 |             exec.setWorkingDirectory(workingDirectory);
193 | 
194 |             try {
195 |                 int resultCode;
196 |                 if (outputFile != null) {
197 |                     if ( !outputFile.getParentFile().exists() && !outputFile.getParentFile().mkdirs()) {
198 |                         getLog().warn( "Could not create non existing parent directories for log file: " + outputFile );
199 |                     }
200 | 
201 |                     FileOutputStream outputStream = null;
202 |                     try {
203 |                         outputStream = new FileOutputStream(outputFile);
204 |                         resultCode = executeCommandLine(exec, commandLine, enviro, outputStream);
205 |                     } finally {
206 |                         IOUtil.close(outputStream);
207 |                     }
208 |                 } else {
209 |                     resultCode = executeCommandLine(exec, commandLine, enviro, System.out, System.err);
210 |                 }
211 | 
212 |                 if (resultCode != 0) {
213 |                     String message = "Result of " + commandLine.toString() + " execution is: '" + resultCode + "'.";
214 |                     getLog().error(message);
215 |                     throw new MojoExecutionException(message);
216 |                 }
217 | 
218 |                 if (launcher != null && ! launcher.isEmpty()) {
219 |                     patchLauncherScript(launcher);
220 | 
221 |                     if (OS.isFamilyWindows()) {
222 |                         patchLauncherScript(launcher + ".bat");
223 |                     }
224 |                 }
225 | 
226 |                 if (jlinkZipName != null && ! jlinkZipName.isEmpty()) {
227 |                     getLog().debug("Creating zip of runtime image");
228 |                     File createZipArchiveFromImage = createZipArchiveFromImage();
229 |                     project.getArtifact().setFile(createZipArchiveFromImage);
230 |                 }
231 | 
232 |             } catch (ExecuteException e) {
233 |                 getLog().error("Command execution failed.", e);
234 |                 e.printStackTrace();
235 |                 throw new MojoExecutionException("Command execution failed.", e);
236 |             } catch (IOException e) {
237 |                 getLog().error("Command execution failed.", e);
238 |                 throw new MojoExecutionException("Command execution failed.", e);
239 |             }
240 |         } catch (Exception e) {
241 |             throw new MojoExecutionException("Error", e);
242 |         }
243 |     }
244 | 
245 |     private void patchLauncherScript(String launcherFilename) throws IOException {
246 |         Path launcherPath = Paths.get(builddir.getAbsolutePath(), jlinkImageName, "bin", launcherFilename);
247 | 
248 |         if (!Files.exists(launcherPath)) {
249 |             getLog().debug("Launcher file not exist: " + launcherPath);
250 |             return;
251 |         }
252 | 
253 |         if (options != null) {
254 |             String optionsString = options.stream()
255 |                     .filter(Objects::nonNull)
256 |                     .filter(String.class::isInstance)
257 |                     .map(String.class::cast)
258 |                     .collect(Collectors.joining(" "));
259 | 
260 |             // Add vm options to launcher script
261 |             List<String> lines = Files.lines(launcherPath)
262 |                     .map(line -> {
263 |                         boolean unixOptionsLine = "JLINK_VM_OPTIONS=".equals(line);
264 |                         boolean winOptionsLine = "set JLINK_VM_OPTIONS=".equals(line);
265 | 
266 |                         if (unixOptionsLine || winOptionsLine) {
267 |                             String lineWrapper = unixOptionsLine ? "\"" : "";
268 |                             return line + lineWrapper + optionsString + lineWrapper;
269 |                         }
270 |                         return line;
271 |                     })
272 |                     .collect(Collectors.toList());
273 |             Files.write(launcherPath, lines);
274 |         }
275 | 
276 |         if (commandlineArgs != null) {
277 |             // Add options to launcher script
278 |             List<String> lines = Files.lines(launcherPath)
279 |                     .map(line -> {
280 |                         if (line.endsWith("$@")) {
281 |                             return line.replace("$@", commandlineArgs + " $@");
282 |                         }
283 |                         return line;
284 |                     })
285 |                     .collect(Collectors.toList());
286 |             Files.write(launcherPath, lines);
287 |         }
288 |     }
289 | 
290 |     private List<String> createCommandArguments() throws MojoExecutionException, MojoFailureException {
291 |         List<String> commandArguments = new ArrayList<>();
292 |         preparePaths(getParent(Paths.get(jlinkExecutable), 2));
293 |         if (modulepathElements != null && !modulepathElements.isEmpty()) {
294 |             commandArguments.add(" --module-path");
295 |             String modulePath = StringUtils.join(modulepathElements.iterator(), File.pathSeparator);
296 |             if (jmodsPath != null && ! jmodsPath.isEmpty()) {
297 |                 getLog().debug("Including jmods from local path: " + jmodsPath);
298 |                 modulePath = jmodsPath + File.pathSeparator + modulePath;
299 |             }
300 |             commandArguments.add(modulePath);
301 | 
302 |             commandArguments.add(" --add-modules");
303 |             if (moduleDescriptor != null) {
304 |                 commandArguments.add(" " + moduleDescriptor.name());
305 |             } else {
306 |                 throw new MojoExecutionException("jlink requires a module descriptor");
307 |             }
308 |         }
309 | 
310 |         commandArguments.add(" --output");
311 |         File image = new File(builddir, jlinkImageName);
312 |         getLog().debug("image output: " + image.getAbsolutePath());
313 |         if (image.exists()) {
314 |             try {
315 |                 Files.walk(image.toPath())
316 |                         .sorted(Comparator.reverseOrder())
317 |                         .map(Path::toFile)
318 |                         .forEach(File::delete);
319 |             } catch (IOException e) {
320 |                 throw new MojoExecutionException("Image can't be removed " + image.getAbsolutePath(), e);
321 |             }
322 |         }
323 |         commandArguments.add(" " + image.getAbsolutePath());
324 | 
325 |         if (stripDebug) {
326 |             commandArguments.add(" --strip-debug");
327 |         }
328 |         if (stripJavaDebugAttributes) {
329 |             commandArguments.add(" --strip-java-debug-attributes");
330 |         }
331 |         if (bindServices) {
332 |             commandArguments.add(" --bind-services");
333 |         }
334 |         if (ignoreSigningInformation) {
335 |             commandArguments.add(" --ignore-signing-information");
336 |         }
337 |         if (compress != null) {
338 |             commandArguments.add(" --compress");
339 |             if (compress < 0 || compress > 2) {
340 |                 throw new MojoFailureException("The given compress parameters " + compress + " is not in the valid value range from 0..2");
341 |             }
342 |             commandArguments.add(" " + compress);
343 |         }
344 |         if (noHeaderFiles) {
345 |             commandArguments.add(" --no-header-files");
346 |         }
347 |         if (noManPages) {
348 |             commandArguments.add(" --no-man-pages");
349 |         }
350 |         if (jlinkVerbose) {
351 |             commandArguments.add(" --verbose");
352 |         }
353 | 
354 |         if (launcher != null && ! launcher.isEmpty()) {
355 |             commandArguments.add(" --launcher");
356 |             String moduleMainClass;
357 |             if (mainClass.contains("/")) {
358 |                 moduleMainClass = mainClass;
359 |             } else {
360 |                 moduleMainClass = moduleDescriptor.name() + "/" + mainClass;
361 |             }
362 |             commandArguments.add(" " + launcher + "=" + moduleMainClass);
363 |         }
364 |         return commandArguments;
365 |     }
366 | 
367 |     private File createZipArchiveFromImage() throws MojoExecutionException {
368 |         File imageArchive = new File(builddir, jlinkImageName);
369 |         zipArchiver.addDirectory(imageArchive);
370 | 
371 |         File resultArchive = new File(builddir, jlinkZipName + ".zip");
372 |         zipArchiver.setDestFile(resultArchive);
373 |         try {
374 |             zipArchiver.createArchive();
375 |         } catch (ArchiverException | IOException e) {
376 |             throw new MojoExecutionException(e.getMessage(), e);
377 |         }
378 |         return resultArchive;
379 |     }
380 | 
381 |     private boolean isJLinkVersion13orHigher(String jlinkExePath) {
382 |         CommandLine versionCommandLine = new CommandLine(jlinkExePath)
383 |                 .addArgument("--version");
384 | 
385 |         ByteArrayOutputStream baos = new ByteArrayOutputStream();
386 |         int resultCode = -1;
387 | 
388 |         try {
389 |             resultCode = executeCommandLine(new DefaultExecutor(), versionCommandLine, null, baos, System.err);
390 |         } catch (IOException e) {
391 |             if (getLog().isDebugEnabled()) {
392 |                 getLog().error("Error getting JLink version", e);
393 |             }
394 |         }
395 | 
396 |         if (resultCode != 0) {
397 |             getLog().error("Unable to get JLink version");
398 |             getLog().error("Result of " + versionCommandLine + " execution is: '" + resultCode + "'");
399 |             return false;
400 |         }
401 | 
402 |         String versionStr = new String(baos.toByteArray());
403 |         return JLINK_VERSION_PATTERN.matcher(versionStr).lookingAt();
404 |     }
405 | 
406 |     // for tests
407 | }
408 | 


--------------------------------------------------------------------------------
/src/main/java/org/openjfx/JavaFXRunMojo.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2019, 2020, Gluon
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *   http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package org.openjfx;
 17 | 
 18 | import org.apache.commons.exec.CommandLine;
 19 | import org.apache.commons.exec.DefaultExecutor;
 20 | import org.apache.commons.exec.ExecuteException;
 21 | import org.apache.commons.exec.Executor;
 22 | import org.apache.maven.plugin.MojoExecutionException;
 23 | import org.apache.maven.plugins.annotations.Execute;
 24 | import org.apache.maven.plugins.annotations.LifecyclePhase;
 25 | import org.apache.maven.plugins.annotations.Mojo;
 26 | import org.apache.maven.plugins.annotations.Parameter;
 27 | import org.apache.maven.plugins.annotations.ResolutionScope;
 28 | import org.codehaus.plexus.languages.java.jpms.JavaModuleDescriptor;
 29 | import org.codehaus.plexus.util.IOUtil;
 30 | import org.codehaus.plexus.util.StringUtils;
 31 | 
 32 | import java.io.File;
 33 | import java.io.FileOutputStream;
 34 | import java.io.IOException;
 35 | import java.nio.file.Paths;
 36 | import java.util.ArrayList;
 37 | import java.util.Collection;
 38 | import java.util.List;
 39 | import java.util.Map;
 40 | import java.util.Objects;
 41 | import java.util.regex.Pattern;
 42 | import java.util.stream.Collectors;
 43 | 
 44 | import static org.openjfx.model.RuntimePathOption.CLASSPATH;
 45 | import static org.openjfx.model.RuntimePathOption.MODULEPATH;
 46 | 
 47 | @Mojo(name = "run", requiresDependencyResolution = ResolutionScope.RUNTIME)
 48 | @Execute(phase = LifecyclePhase.PROCESS_CLASSES)
 49 | public class JavaFXRunMojo extends JavaFXBaseMojo {
 50 | 
 51 |     /**
 52 |      * <p>
 53 |      * The executable. Can be a full path or the name of the executable. In the latter case, the executable must be in
 54 |      * the PATH for the execution to work.
 55 |      * </p>
 56 |      */
 57 |     @Parameter(property = "javafx.executable", defaultValue = "java")
 58 |     private String executable;
 59 | 
 60 |     public void execute() throws MojoExecutionException {
 61 |         if (skip) {
 62 |             getLog().info( "skipping execute as per configuration" );
 63 |             return;
 64 |         }
 65 | 
 66 |         if (executable == null) {
 67 |             throw new MojoExecutionException("The parameter 'executable' is missing or invalid");
 68 |         }
 69 | 
 70 |         if (basedir == null) {
 71 |             throw new IllegalStateException( "basedir is null. Should not be possible." );
 72 |         }
 73 | 
 74 |         try {
 75 |             handleWorkingDirectory();
 76 | 
 77 |             Map<String, String> enviro = handleSystemEnvVariables();
 78 |             CommandLine commandLine = getExecutablePath(executable, enviro, workingDirectory);
 79 | 
 80 |             boolean usingOldJDK = isTargetUsingJava8(commandLine);
 81 | 
 82 |             List<String> commandArguments = createCommandArguments(usingOldJDK);
 83 |             String[] args = commandArguments.toArray(new String[commandArguments.size()]);
 84 |             commandLine.addArguments(args, false);
 85 |             getLog().debug("Executing command line: " + commandLine);
 86 | 
 87 |             Executor exec = new DefaultExecutor();
 88 |             exec.setWorkingDirectory(workingDirectory);
 89 | 
 90 |             try {
 91 |                 int resultCode;
 92 |                 if (outputFile != null) {
 93 |                     if ( !outputFile.getParentFile().exists() && !outputFile.getParentFile().mkdirs()) {
 94 |                         getLog().warn( "Could not create non existing parent directories for log file: " + outputFile );
 95 |                     }
 96 | 
 97 |                     FileOutputStream outputStream = null;
 98 |                     try {
 99 |                         outputStream = new FileOutputStream(outputFile);
100 |                         resultCode = executeCommandLine(exec, commandLine, enviro, outputStream);
101 |                     } finally {
102 |                         IOUtil.close(outputStream);
103 |                     }
104 |                 } else {
105 |                     resultCode = executeCommandLine(exec, commandLine, enviro, System.out, System.err);
106 |                 }
107 | 
108 |                 if (resultCode != 0) {
109 |                     String message = "Result of " + commandLine.toString() + " execution is: '" + resultCode + "'.";
110 |                     getLog().error(message);
111 |                     throw new MojoExecutionException(message);
112 |                 }
113 |             } catch (ExecuteException e) {
114 |                 getLog().error("Command execution failed.", e);
115 |                 e.printStackTrace();
116 |                 throw new MojoExecutionException("Command execution failed.", e);
117 |             } catch (IOException e) {
118 |                 getLog().error("Command execution failed.", e);
119 |                 throw new MojoExecutionException("Command execution failed.", e);
120 |             }
121 |         } catch (Exception e) {
122 |             throw new MojoExecutionException("Error", e);
123 |         }
124 |     }
125 | 
126 |     private List<String> createCommandArguments(boolean oldJDK) throws MojoExecutionException {
127 |         List<String> commandArguments = new ArrayList<>();
128 |         preparePaths(getParent(Paths.get(executable), 2));
129 | 
130 |         if (options != null) {
131 |             options.stream()
132 |                     .filter(Objects::nonNull)
133 |                     .filter(String.class::isInstance)
134 |                     .map(String.class::cast)
135 |                     .map(this::splitComplexArgumentString)
136 |                     .flatMap(Collection::stream)
137 |                     .forEach(commandArguments::add);
138 |         }
139 |         if (!oldJDK) {
140 |             if (runtimePathOption == MODULEPATH || modulepathElements != null && !modulepathElements.isEmpty()) {
141 |                 commandArguments.add("--module-path");
142 |                 commandArguments.add(StringUtils.join(modulepathElements.iterator(), File.pathSeparator));
143 |                 commandArguments.add("--add-modules");
144 |                 commandArguments.add(createAddModulesString(moduleDescriptor, pathElements));
145 |             }
146 |         }
147 | 
148 |         if (classpathElements != null && (oldJDK || !classpathElements.isEmpty())) {
149 |             commandArguments.add("-classpath");
150 |             String classpath = "";
151 |             if (oldJDK || runtimePathOption == CLASSPATH) {
152 |                 classpath = project.getBuild().getOutputDirectory() + File.pathSeparator;
153 |             }
154 |             classpath += StringUtils.join(classpathElements.iterator(), File.pathSeparator);
155 |             commandArguments.add(classpath);
156 |         }
157 | 
158 |         if (mainClass != null) {
159 |             if (moduleDescriptor != null) {
160 |                 commandArguments.add("--module");
161 |             }
162 |             commandArguments.add(createMainClassString(mainClass, moduleDescriptor, runtimePathOption));
163 |         }
164 | 
165 |         if (commandlineArgs != null) {
166 |             splitComplexArgumentString(commandlineArgs)
167 |                     .forEach(commandArguments::add);
168 |         }
169 |         return commandArguments;
170 |     }
171 | 
172 |     private String createAddModulesString(JavaModuleDescriptor moduleDescriptor, Map<String, JavaModuleDescriptor> pathElements) {
173 |         if (moduleDescriptor == null) {
174 |             return pathElements.values().stream()
175 |                     .filter(Objects::nonNull)
176 |                     .map(JavaModuleDescriptor::name)
177 |                     .filter(Objects::nonNull)
178 |                     .filter(module -> module.startsWith(JAVAFX_PREFIX) && !module.endsWith("Empty"))
179 |                     .collect(Collectors.joining(","));
180 |         }
181 |         return moduleDescriptor.name();
182 |     }
183 | 
184 |     private List<String> splitComplexArgumentString(String argumentString) {
185 |         char[] strArr = argumentString.trim().toCharArray();
186 | 
187 |         List<String> splitedArgs = new ArrayList<>();
188 |         StringBuilder sb = new StringBuilder();
189 | 
190 |         char expectedSeparator = ' ';
191 |         for (int i = 0; i < strArr.length; i++) {
192 |             char item = strArr[i];
193 | 
194 |             if (item == expectedSeparator
195 |                     || (expectedSeparator == ' ' && Pattern.matches("\\s", String.valueOf(item))) ) {
196 | 
197 |                 if (expectedSeparator == '"' || expectedSeparator == '\'') {
198 |                     sb.append(item);
199 |                     expectedSeparator = ' ';
200 |                 } else if (expectedSeparator == ' ' && sb.length() > 0) {
201 |                     splitedArgs.add(sb.toString());
202 |                     sb.delete(0, sb.length());
203 |                 }
204 |             } else {
205 |                 if (expectedSeparator == ' ' && (item == '"' || item == '\'')) {
206 |                     expectedSeparator = item;
207 |                 }
208 | 
209 |                 sb.append(item);
210 |             }
211 | 
212 |             if (i == strArr.length - 1 && sb.length() > 0) {
213 |                 splitedArgs.add(sb.toString());
214 |             }
215 |         }
216 | 
217 |         return splitedArgs;
218 |     }
219 | 
220 |     // for tests
221 | 
222 |     void setExecutable(String executable) {
223 |         this.executable = executable;
224 |     }
225 | 
226 |     void setBasedir(File basedir) {
227 |         this.basedir = basedir;
228 |     }
229 | 
230 |     void setCommandlineArgs(String commandlineArgs) {
231 |         this.commandlineArgs = commandlineArgs;
232 |     }
233 | 
234 |     List<String> splitComplexArgumentStringAdapter(String cliOptions) {
235 |         return splitComplexArgumentString(cliOptions);
236 |     }
237 | }
238 | 


--------------------------------------------------------------------------------
/src/main/java/org/openjfx/model/RuntimePathOption.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2020, Gluon
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *   http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package org.openjfx.model;
17 | 
18 | /**
19 |  * All the classes and dependencies are added to either the classpath or modulepath depending on the option set in the plugin configuration.
20 |  * If not set, the plugin chooses the suitable option for classes and dependencies based on a few parameters, like presence of module descriptor file. 
21 |  */
22 | public enum RuntimePathOption {
23 |     /**
24 |      * Puts all the dependencies on the classpath. If a module-info.java is present, it is ignored.
25 |      * A <a href="https://github.com/openjfx/samples/blob/master/CommandLine/Non-modular/CLI/hellofx/src/hellofx/Launcher.java">Launcher class</a> is
26 |      * required to run a JavaFX application from the classpath.
27 |      */
28 |     CLASSPATH,
29 |     /**
30 |      * Puts all the dependencies on the modulepath.
31 |      */
32 |     MODULEPATH
33 | }
34 | 


--------------------------------------------------------------------------------
/src/main/resources/META-INF/plexus/components.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <component-set>
 3 |   <components>
 4 |     <component>
 5 |       <role>org.apache.maven.lifecycle.Lifecycle</role>
 6 |       <implementation>org.apache.maven.lifecycle.Lifecycle</implementation>
 7 |       <role-hint>run</role-hint>
 8 |       <configuration>
 9 |         <id>run</id>
10 |         <phases>
11 |           <phase>run</phase>
12 |         </phases>
13 |         <default-phases>
14 |           <run>
15 |             org.openjfx:javafx-maven-plugin:run
16 |           </run>
17 |         </default-phases>
18 |       </configuration>
19 |     </component>
20 |   </components>
21 | </component-set>


--------------------------------------------------------------------------------
/src/test/java/org/openjfx/JavaFXBaseMojoTest.java:
--------------------------------------------------------------------------------
  1 | package org.openjfx;
  2 | 
  3 | import org.codehaus.plexus.languages.java.jpms.JavaModuleDescriptor;
  4 | import org.junit.AfterClass;
  5 | import org.junit.Assert;
  6 | import org.junit.Before;
  7 | import org.junit.BeforeClass;
  8 | import org.junit.Test;
  9 | 
 10 | import java.io.File;
 11 | import java.io.IOException;
 12 | import java.nio.file.Files;
 13 | import java.nio.file.Path;
 14 | import java.nio.file.Paths;
 15 | import java.util.Comparator;
 16 | 
 17 | import static org.openjfx.model.RuntimePathOption.CLASSPATH;
 18 | import static org.openjfx.model.RuntimePathOption.MODULEPATH;
 19 | 
 20 | public class JavaFXBaseMojoTest {
 21 | 
 22 |     private static Path path;
 23 |     private static String tempDirPath;
 24 |     
 25 |     private JavaFXBaseMojo mojo;
 26 |     private JavaModuleDescriptor moduleDescriptor;
 27 | 
 28 |     @BeforeClass
 29 |     public static void setup() throws IOException {
 30 |         tempDirPath = System.getProperty("java.io.tmpdir");
 31 |         path = Files.createDirectories(Paths.get(tempDirPath, "test", "test"));
 32 |     }
 33 |     
 34 |     @Before
 35 |     public void create() {
 36 |         mojo = new JavaFXBaseMojo() {
 37 |             @Override
 38 |             public void execute() {
 39 |                 //no-op
 40 |             }
 41 |         };
 42 |         moduleDescriptor = JavaModuleDescriptor.newModule("hellofx").build();
 43 |     }
 44 |     
 45 |     @Test
 46 |     public void parentTest() {
 47 |         Assert.assertEquals(Paths.get(tempDirPath), JavaFXBaseMojo.getParent(path, 2));
 48 |     }
 49 | 
 50 |     @Test
 51 |     public void mainClassStringWithModuleDescriptor() {
 52 |         Assert.assertEquals("hellofx/org.openjfx.Main", mojo.createMainClassString("org.openjfx.Main", moduleDescriptor, null));
 53 |     }
 54 | 
 55 |     @Test
 56 |     public void mainClassStringWithoutModuleDescriptor() {
 57 |         Assert.assertEquals("org.openjfx.Main", mojo.createMainClassString("org.openjfx.Main", null, null));
 58 |         Assert.assertEquals("hellofx/org.openjfx.Main", mojo.createMainClassString("hellofx/org.openjfx.Main", null, null));
 59 |     }
 60 | 
 61 |     @Test
 62 |     public void mainClassStringWithClasspathWithModuleDescriptor() {
 63 |         Assert.assertEquals("org.openjfx.Main", mojo.createMainClassString("org.openjfx.Main", moduleDescriptor, CLASSPATH));
 64 |         Assert.assertEquals("org.openjfx.Main", mojo.createMainClassString("hellofx/org.openjfx.Main", moduleDescriptor, CLASSPATH));
 65 |     }
 66 | 
 67 |     @Test
 68 |     public void mainClassStringWithClasspathWithoutModuleDescriptor() {
 69 |         Assert.assertEquals("org.openjfx.Main", mojo.createMainClassString("org.openjfx.Main", null, CLASSPATH));
 70 |         Assert.assertEquals("org.openjfx.Main", mojo.createMainClassString("hellofx/org.openjfx.Main", null, CLASSPATH));
 71 |     }
 72 | 
 73 |     @Test
 74 |     public void mainClassStringWithModulepathWithModuleDescriptor() {
 75 |         Assert.assertEquals("hellofx/org.openjfx.Main", mojo.createMainClassString("org.openjfx.Main", moduleDescriptor, MODULEPATH));
 76 |         Assert.assertEquals("hellofx/org.openjfx.Main", mojo.createMainClassString("hellofx/org.openjfx.Main", moduleDescriptor, MODULEPATH));
 77 |     }
 78 | 
 79 |     @Test
 80 |     public void mainClassStringWithModulepathWithoutModuleDescriptor() {
 81 |         Assert.assertEquals("org.openjfx.Main", mojo.createMainClassString("org.openjfx.Main", null, MODULEPATH));
 82 |         Assert.assertEquals("hellofx/org.openjfx.Main", mojo.createMainClassString("hellofx/org.openjfx.Main", null, MODULEPATH));
 83 |     }
 84 | 
 85 |     @Test
 86 |     public void invalidParentTest() {
 87 |         Assert.assertNull(JavaFXBaseMojo.getParent(path, 10));
 88 |     }
 89 | 
 90 |     @Test
 91 |     public void invalidPathTest() {
 92 |         Assert.assertNull(JavaFXBaseMojo.getParent(Paths.get("/some-invalid-path"), 0));
 93 |     }
 94 | 
 95 |     @Test
 96 |     public void invalidPathWithDepthTest() {
 97 |         Assert.assertNull(JavaFXBaseMojo.getParent(Paths.get("/some-invalid-path"), 2));
 98 |     }
 99 | 
100 |     @AfterClass
101 |     public static void destroy() throws IOException {
102 |         Files.walk(path.getParent())
103 |                 .sorted(Comparator.reverseOrder())
104 |                 .map(Path::toFile)
105 |                 .filter(f -> "test".equals(f.getName()))
106 |                 .forEach(File::delete);
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/src/test/java/org/openjfx/JavaFXRunMojoTestCase.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2019, 2020, Gluon
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *   http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.openjfx;
 18 | 
 19 | import org.apache.commons.exec.CommandLine;
 20 | import org.apache.commons.exec.ExecuteException;
 21 | import org.apache.commons.exec.Executor;
 22 | import org.apache.commons.exec.OS;
 23 | import org.apache.maven.artifact.Artifact;
 24 | import org.apache.maven.execution.MavenSession;
 25 | import org.apache.maven.monitor.logging.DefaultLog;
 26 | import org.apache.maven.plugin.AbstractMojo;
 27 | import org.apache.maven.plugin.MojoExecutionException;
 28 | import org.apache.maven.plugin.MojoFailureException;
 29 | import org.apache.maven.plugin.testing.AbstractMojoTestCase;
 30 | import org.apache.maven.project.MavenProject;
 31 | import org.apache.maven.project.ProjectBuilder;
 32 | import org.apache.maven.project.ProjectBuildingRequest;
 33 | import org.apache.maven.project.ProjectBuildingResult;
 34 | import org.apache.maven.repository.RepositorySystem;
 35 | import org.apache.maven.repository.internal.MavenRepositorySystemUtils;
 36 | import org.codehaus.plexus.logging.Logger;
 37 | import org.codehaus.plexus.logging.console.ConsoleLogger;
 38 | import org.codehaus.plexus.util.StringOutputStream;
 39 | import org.eclipse.aether.DefaultRepositorySystemSession;
 40 | import org.eclipse.aether.artifact.DefaultArtifact;
 41 | import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
 42 | import org.eclipse.aether.repository.LocalRepository;
 43 | import org.junit.Assert;
 44 | import org.junit.Test;
 45 | import org.mockito.Mock;
 46 | import org.mockito.MockitoAnnotations;
 47 | 
 48 | import java.io.File;
 49 | import java.io.IOException;
 50 | import java.io.OutputStream;
 51 | import java.io.PrintStream;
 52 | import java.util.*;
 53 | import java.util.stream.Collectors;
 54 | 
 55 | import static org.mockito.Mockito.mock;
 56 | import static org.mockito.Mockito.when;
 57 | 
 58 | public class JavaFXRunMojoTestCase extends AbstractMojoTestCase {
 59 | 
 60 |     private static final File LOCAL_REPO = new File( "src/test/repository" );
 61 |     private static final String SOME_EXECUTABLE = UUID.randomUUID().toString();
 62 | 
 63 |     @Mock
 64 |     private MavenSession session;
 65 | 
 66 |     private MockJavaFXRunMojo mojo;
 67 | 
 68 |     private class MockJavaFXRunMojo extends JavaFXRunMojo {
 69 | 
 70 |         public List<CommandLine> commandLines = new ArrayList<>();
 71 |         public String failureMsg;
 72 |         public int executeResult;
 73 | 
 74 |         @Override
 75 |         protected int executeCommandLine(Executor exec, CommandLine commandLine, Map enviro, OutputStream out,
 76 |                                          OutputStream err) throws IOException, ExecuteException {
 77 |             commandLines.add(commandLine);
 78 |             if (failureMsg != null) {
 79 |                 throw new ExecuteException(failureMsg, executeResult);
 80 |             }
 81 |             return executeResult;
 82 |         }
 83 | 
 84 |         int getAmountExecutedCommandLines() {
 85 |             return commandLines.size();
 86 |         }
 87 | 
 88 |         CommandLine getExecutedCommandline(int index) {
 89 |             return commandLines.get(index);
 90 |         }
 91 | 
 92 |     }
 93 | 
 94 |     public void setUp() throws Exception {
 95 |         super.setUp();
 96 |         mojo = new MockJavaFXRunMojo();
 97 |         mojo.executeResult = 0;
 98 |         mojo.setExecutable(SOME_EXECUTABLE);
 99 | //        mojo.setOptions(Arrays.asList("--version"));
100 |         mojo.setCommandlineArgs("--version");
101 |         mojo.setBasedir(File.createTempFile("mvn-temp", "txt").getParentFile());
102 |     }
103 | 
104 |     public void testRunOK() throws MojoExecutionException {
105 |         mojo.execute();
106 |         checkMojo(SOME_EXECUTABLE + " --version");
107 |     }
108 | 
109 |     public void testSimpleRun() throws Exception {
110 |         final File testPom = getTestFile("src/test/resources/unit/javafxrun-basic-test/pom.xml");
111 |         JavaFXRunMojo mojo = getJavaFXRunMojo(testPom);
112 |         String output = execute(mojo);
113 |         assertEquals("JavaFXRun0", output.trim());
114 |     }
115 | 
116 |     public void testApplicationRun() throws Exception {
117 |         final File testPom = getTestFile("src/test/resources/unit/javafxrun-app-test/pom.xml");
118 |         JavaFXRunMojo mojo = getJavaFXRunMojo(testPom);
119 |         String output = execute(mojo);
120 |         assertEquals("JavaFXRun1", output.trim());
121 |     }
122 | 
123 |     public void testClasspathLauncherRun() throws Exception {
124 |         final File testPom = getTestFile("src/test/resources/unit/javafxrun-classpath-test/classpath-launcher.xml");
125 |         JavaFXRunMojo mojo = getJavaFXRunMojo(testPom);
126 |         String output = execute(mojo);
127 |         assertEquals("JavaFXRun1", output.trim());
128 |     }
129 | 
130 |     public void testClasspathNoLauncherRun() throws Exception {
131 |         final File testPom = getTestFile("src/test/resources/unit/javafxrun-classpath-test/classpath-no-launcher.xml");
132 |         JavaFXRunMojo mojo = getJavaFXRunMojo(testPom);
133 |         Exception e = null;
134 |         try {
135 |             execute(mojo);
136 |         } catch (Exception e1) {
137 |             e = e1;
138 |         }
139 |         assertEquals (true, (e instanceof MojoExecutionException));
140 |     }
141 | 
142 |     protected JavaFXRunMojo getJavaFXRunMojo(File testPom) throws Exception {
143 |         JavaFXRunMojo mojo = (JavaFXRunMojo) lookupMojo("run", testPom);
144 |         assertNotNull(mojo);
145 | 
146 |         setUpProject(testPom, mojo);
147 |         MavenProject project = (MavenProject) getVariableValueFromObject( mojo, "project" );
148 |         assertNotNull(project);
149 | 
150 |         if (! project.getDependencies().isEmpty()) {
151 |             final MavenArtifactResolver resolver = new MavenArtifactResolver(project.getRepositories());
152 |             Set<Artifact> artifacts = project.getDependencies().stream()
153 |                     .map(d -> new DefaultArtifact(d.getGroupId(), d.getArtifactId(), d.getClassifier(), d.getType(), d.getVersion()))
154 |                     .flatMap(a -> resolver.resolve(a).stream())
155 |                     .collect(Collectors.toSet());
156 |             if (artifacts != null) {
157 |                 project.setArtifacts(artifacts);
158 |             }
159 |         }
160 |         setVariableValueToObject(mojo, "compilePath", project.getCompileClasspathElements());
161 |         setVariableValueToObject(mojo, "session", session);
162 |         setVariableValueToObject(mojo, "executable", "java");
163 |         setVariableValueToObject(mojo, "basedir", new File(getBasedir(), testPom.getParent()));
164 | 
165 |         return mojo;
166 |     }
167 | 
168 |     private String execute(AbstractMojo mojo) throws MojoFailureException, MojoExecutionException, InterruptedException {
169 |         PrintStream out = System.out;
170 |         StringOutputStream stringOutputStream = new StringOutputStream();
171 |         System.setOut(new PrintStream(stringOutputStream));
172 |         mojo.setLog(new DefaultLog(new ConsoleLogger(Logger.LEVEL_ERROR, "javafx:run")));
173 | 
174 |         try {
175 |             mojo.execute();
176 |         } finally {
177 |             Thread.sleep(300);
178 |             System.setOut(out);
179 |         }
180 | 
181 |         return stringOutputStream.toString();
182 |     }
183 | 
184 |     private void setUpProject(File pomFile, AbstractMojo mojo) throws Exception {
185 |         super.setUp();
186 | 
187 |         MockitoAnnotations.initMocks(this);
188 | 
189 |         ProjectBuildingRequest buildingRequest = mock(ProjectBuildingRequest.class);
190 |         buildingRequest.setResolveDependencies(true);
191 |         when(session.getProjectBuildingRequest()).thenReturn(buildingRequest);
192 |         DefaultRepositorySystemSession repositorySession = MavenRepositorySystemUtils.newSession();
193 |         repositorySession.setLocalRepositoryManager(new SimpleLocalRepositoryManagerFactory()
194 |                 .newInstance(repositorySession, new LocalRepository(RepositorySystem.defaultUserLocalRepository)));
195 |         when(buildingRequest.getRepositorySession()).thenReturn(repositorySession);
196 | 
197 |         ProjectBuilder builder = lookup(ProjectBuilder.class);
198 |         ProjectBuildingResult build = builder.build(pomFile, buildingRequest);
199 |         MavenProject project = build.getProject();
200 | 
201 |         project.getBuild().setOutputDirectory(new File( "target/test-classes").getAbsolutePath());
202 |         setVariableValueToObject(mojo, "project", project);
203 |     }
204 | 
205 |     private void checkMojo(String expectedCommandLine) {
206 |         assertEquals(1, mojo.getAmountExecutedCommandLines());
207 |         CommandLine commandline = mojo.getExecutedCommandline(0);
208 |         // do NOT depend on Commandline toString()
209 |         assertEquals(expectedCommandLine, getCommandLineAsString(commandline));
210 |     }
211 | 
212 |     private String getCommandLineAsString(CommandLine commandline) {
213 |         // for the sake of the test comparisons, cut out the eventual
214 |         // cmd /c *.bat conversion
215 |         String result = commandline.getExecutable();
216 |         boolean isCmd = false;
217 |         if (OS.isFamilyWindows() && result.equals("cmd")) {
218 |             result = "";
219 |             isCmd = true;
220 |         }
221 |         String[] arguments = commandline.getArguments();
222 |         for (int i = 0; i < arguments.length; i++) {
223 |             String arg = arguments[i];
224 |             if (isCmd && i == 0 && "/c".equals(arg)) {
225 |                 continue;
226 |             }
227 |             if (isCmd && i == 1 && arg.endsWith(".bat")) {
228 |                 arg = arg.substring(0, arg.length() - ".bat".length());
229 |             }
230 |             result += (result.length() == 0 ? "" : " ") + arg;
231 |         }
232 |         return result;
233 |     }
234 | 
235 |     @Test
236 |     public void testSplitComplexArgumentString() {
237 |         String option = "param1 " +
238 |                 "param2   \n   " +
239 |                 "param3\n" +
240 |                 "param4=\"/path/to/my file.log\"   " +
241 |                 "'var\"foo   var\"foo' " +
242 |                 "'var\"foo'   " +
243 |                 "'var\"foo' " +
244 |                 "\"foo'var foo'var\" " +
245 |                 "\"foo'var\" " +
246 |                 "\"foo'var\"";
247 | 
248 |         String expected = "START," +
249 |                 "param1," +
250 |                 "param2," +
251 |                 "param3," +
252 |                 "param4=\"/path/to/my file.log\"," +
253 |                 "'var\"foo   var\"foo'," +
254 |                 "'var\"foo'," +
255 |                 "'var\"foo'," +
256 |                 "\"foo'var foo'var\"," +
257 |                 "\"foo'var\"," +
258 |                 "\"foo'var\"";
259 | 
260 |         String splitedOption = new JavaFXRunMojo().splitComplexArgumentStringAdapter(option)
261 |                 .stream().reduce("START", (s1, s2) -> s1 + "," + s2);
262 | 
263 |         Assert.assertEquals(expected, splitedOption);
264 |     }
265 | }
266 | 


--------------------------------------------------------------------------------
/src/test/java/org/openjfx/MavenArtifactResolver.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2019 Gluon
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *   http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.openjfx;
 18 | 
 19 | import org.apache.maven.artifact.handler.DefaultArtifactHandler;
 20 | import org.apache.maven.model.Repository;
 21 | import org.apache.maven.repository.internal.MavenRepositorySystemUtils;
 22 | import org.eclipse.aether.DefaultRepositorySystemSession;
 23 | import org.eclipse.aether.RepositorySystem;
 24 | import org.eclipse.aether.RepositorySystemSession;
 25 | import org.eclipse.aether.artifact.Artifact;
 26 | import org.eclipse.aether.artifact.DefaultArtifact;
 27 | import org.eclipse.aether.collection.CollectRequest;
 28 | import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
 29 | import org.eclipse.aether.graph.Dependency;
 30 | import org.eclipse.aether.graph.DependencyFilter;
 31 | import org.eclipse.aether.impl.DefaultServiceLocator;
 32 | import org.eclipse.aether.repository.LocalRepository;
 33 | import org.eclipse.aether.repository.RemoteRepository;
 34 | import org.eclipse.aether.resolution.ArtifactRequest;
 35 | import org.eclipse.aether.resolution.ArtifactResolutionException;
 36 | import org.eclipse.aether.resolution.ArtifactResult;
 37 | import org.eclipse.aether.resolution.DependencyRequest;
 38 | import org.eclipse.aether.resolution.DependencyResolutionException;
 39 | import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
 40 | import org.eclipse.aether.spi.connector.transport.TransporterFactory;
 41 | import org.eclipse.aether.transport.file.FileTransporterFactory;
 42 | import org.eclipse.aether.transport.http.HttpTransporterFactory;
 43 | import org.eclipse.aether.util.artifact.JavaScopes;
 44 | import org.eclipse.aether.util.filter.DependencyFilterUtils;
 45 | 
 46 | import java.util.Arrays;
 47 | import java.util.LinkedList;
 48 | import java.util.List;
 49 | import java.util.Set;
 50 | import java.util.stream.Collectors;
 51 | 
 52 | /**
 53 |  * Resolve all transitive artifacts from a given dependency on a pom file
 54 |  * This is required because these are not resolved when running the tests
 55 |  */
 56 | class MavenArtifactResolver {
 57 | 
 58 |     private static String DEFAULT_LOCAL_REPO = org.apache.maven.repository.RepositorySystem.
 59 |             defaultUserLocalRepository.getAbsolutePath();
 60 | 
 61 |     private final RepositorySystem repositorySystem;
 62 |     private final List<RemoteRepository> remoteRepositories;
 63 | 
 64 |     MavenArtifactResolver(List<Repository> repositories) {
 65 |         this.repositorySystem = createRepositorySystem();
 66 |         this.remoteRepositories = new LinkedList<>();
 67 |         repositories.forEach(r -> {
 68 |             RemoteRepository repository = new RemoteRepository
 69 |                     .Builder(r.getId(), "default", r.getUrl())
 70 |                     .build();
 71 |             remoteRepositories.add(repository);
 72 |         });
 73 |     }
 74 | 
 75 |     private RepositorySystem createRepositorySystem() {
 76 |         DefaultServiceLocator serviceLocator = MavenRepositorySystemUtils.newServiceLocator();
 77 |         serviceLocator.addService(RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class);
 78 |         serviceLocator.addService(TransporterFactory.class, FileTransporterFactory.class);
 79 |         serviceLocator.addService(TransporterFactory.class, HttpTransporterFactory.class);
 80 |         serviceLocator.setErrorHandler(new DefaultServiceLocator.ErrorHandler() {
 81 |             @Override
 82 |             public void serviceCreationFailed(Class<?> type, Class<?> impl, Throwable exception) {
 83 |                 throw new RuntimeException(exception);
 84 |             }
 85 |         });
 86 |         return serviceLocator.getService(RepositorySystem.class);
 87 |     }
 88 | 
 89 |     private DefaultRepositorySystemSession createRepositorySystemSession(RepositorySystem system, String localRepoPath) {
 90 |         DefaultRepositorySystemSession systemSession = MavenRepositorySystemUtils.newSession();
 91 |         LocalRepository localRepo = new LocalRepository(localRepoPath);
 92 |         systemSession.setLocalRepositoryManager(system.newLocalRepositoryManager(systemSession, localRepo));
 93 |         return systemSession;
 94 |     }
 95 | 
 96 |     Set<org.apache.maven.artifact.Artifact> resolve(Artifact artifact) {
 97 |         RepositorySystemSession systemSession = createRepositorySystemSession(this.repositorySystem, DEFAULT_LOCAL_REPO);
 98 | 
 99 |         ArtifactResult resolvedArtifact;
100 |         try {
101 |             List<ArtifactRequest> artifactRequests = Arrays.asList(
102 |                     new ArtifactRequest(new DefaultArtifact(artifact.getGroupId(), artifact.getArtifactId(),
103 |                             artifact.getClassifier() != null ? artifact.getClassifier() : "",
104 |                             artifact.getExtension(), artifact.getVersion()),
105 |                     remoteRepositories, JavaScopes.RUNTIME));
106 |             List<ArtifactResult> results = repositorySystem.resolveArtifacts(systemSession, artifactRequests);
107 |             resolvedArtifact = results.get(results.size() - 1);
108 |         } catch (ArtifactResolutionException e) {
109 |             e.printStackTrace();
110 |             return null;
111 |         }
112 | 
113 |         CollectRequest collectRequest = new CollectRequest();
114 |         collectRequest.setRoot(new Dependency(resolvedArtifact.getArtifact(), JavaScopes.COMPILE));
115 |         collectRequest.setRepositories(remoteRepositories);
116 | 
117 |         DependencyFilter classpathFilter = DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE);
118 |         DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, classpathFilter);
119 | 
120 |         List<ArtifactResult> artifactResults;
121 |         try {
122 |             artifactResults = repositorySystem.resolveDependencies(systemSession, dependencyRequest)
123 |                     .getArtifactResults();
124 |         } catch (DependencyResolutionException e) {
125 |             e.printStackTrace();
126 |             return null;
127 |         }
128 | 
129 |         return artifactResults.stream()
130 |                 .map(ArtifactResult::getArtifact)
131 |                 .map(a -> {
132 |                     org.apache.maven.artifact.Artifact ar = new org.apache.maven.artifact.DefaultArtifact(
133 |                             a.getGroupId(), a.getArtifactId(), a.getVersion(),
134 |                             "compile", "jar", a.getClassifier(), new DefaultArtifactHandler("jar"));
135 |                     ar.setFile(a.getFile());
136 |                     return ar;
137 |                 })
138 |                 .collect(Collectors.toSet());
139 |     }
140 | 
141 | }


--------------------------------------------------------------------------------
/src/test/java/org/openjfx/TestJavaFXRun0.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2019 Gluon
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *   http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | package org.openjfx;
18 | 
19 | public class TestJavaFXRun0 {
20 | 
21 |     public TestJavaFXRun0() {
22 |         System.out.println("JavaFXRun0");
23 |     }
24 | 
25 |     public static void main(String[] args) {
26 |         new TestJavaFXRun0();
27 |     }
28 | 
29 | }


--------------------------------------------------------------------------------
/src/test/java/org/openjfx/TestJavaFXRun1.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2019 Gluon
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *   http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | package org.openjfx;
18 | 
19 | import javafx.application.Application;
20 | import javafx.application.Platform;
21 | import javafx.stage.Stage;
22 | 
23 | public class TestJavaFXRun1 extends Application {
24 | 
25 |     @Override
26 |     public void start(Stage stage) {
27 |         System.out.println("JavaFXRun1");
28 |         Platform.exit();
29 |     }
30 | 
31 |     public static void main(String[] args) {
32 |         launch(args);
33 |     }
34 | 
35 | }


--------------------------------------------------------------------------------
/src/test/java/org/openjfx/TestLauncher.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2020, Gluon
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *   http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package org.openjfx;
17 | 
18 | public class TestLauncher {
19 |     public static void main(String[] args) {
20 |         TestJavaFXRun1.main(args);
21 |     }
22 | }


--------------------------------------------------------------------------------
/src/test/resources/unit/javafxrun-app-test/pom.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |  ~ Copyright 2019 Gluon
 3 |  ~
 4 |  ~ Licensed under the Apache License, Version 2.0 (the "License");
 5 |  ~ you may not use this file except in compliance with the License.
 6 |  ~ You may obtain a copy of the License at
 7 |  ~
 8 |  ~   http://www.apache.org/licenses/LICENSE-2.0
 9 |  ~
10 |  ~ Unless required by applicable law or agreed to in writing, software
11 |  ~ distributed under the License is distributed on an "AS IS" BASIS,
12 |  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  ~ See the License for the specific language governing permissions and
14 |  ~ limitations under the License.
15 |   -->
16 | <project>
17 |   <modelVersion>4.0.0</modelVersion>
18 |   <groupId>org.openjfx</groupId>
19 |   <artifactId>javafxrun.basic.test</artifactId>
20 |   <version>1.0-SNAPSHOT</version>
21 |   <packaging>jar</packaging>
22 |   <properties>
23 |     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
24 |     <maven.compiler.source>11</maven.compiler.source>
25 |     <maven.compiler.target>11</maven.compiler.target>
26 |     <javafx.version>12.0.1</javafx.version>
27 |   </properties>
28 |   <dependencies>
29 |     <dependency>
30 |       <groupId>org.openjfx</groupId>
31 |       <artifactId>javafx-controls</artifactId>
32 |       <version>${javafx.version}</version>
33 |     </dependency>
34 |   </dependencies>
35 |   <build>
36 |     <plugins>
37 |       <plugin>
38 |         <groupId>org.openjfx</groupId>
39 |         <artifactId>javafx-maven-plugin</artifactId>
40 |         <version>1.0-SNAPSHOT</version>
41 |         <configuration>
42 |           <mainClass>org.openjfx.TestJavaFXRun1</mainClass>
43 |         </configuration>
44 |       </plugin>
45 |     </plugins>
46 |   </build>
47 | </project>
48 | 


--------------------------------------------------------------------------------
/src/test/resources/unit/javafxrun-basic-test/pom.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |  ~ Copyright 2019 Gluon
 3 |  ~
 4 |  ~ Licensed under the Apache License, Version 2.0 (the "License");
 5 |  ~ you may not use this file except in compliance with the License.
 6 |  ~ You may obtain a copy of the License at
 7 |  ~
 8 |  ~   http://www.apache.org/licenses/LICENSE-2.0
 9 |  ~
10 |  ~ Unless required by applicable law or agreed to in writing, software
11 |  ~ distributed under the License is distributed on an "AS IS" BASIS,
12 |  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  ~ See the License for the specific language governing permissions and
14 |  ~ limitations under the License.
15 |   -->
16 | <project>
17 |   <modelVersion>4.0.0</modelVersion>
18 |   <groupId>org.openjfx</groupId>
19 |   <artifactId>javafxrun.basic.test</artifactId>
20 |   <version>1.0-SNAPSHOT</version>
21 |   <packaging>jar</packaging>
22 |   <properties>
23 |     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
24 |     <maven.compiler.source>11</maven.compiler.source>
25 |     <maven.compiler.target>11</maven.compiler.target>
26 |     <javafx.version>12.0.1</javafx.version>
27 |   </properties>
28 |   <build>
29 |     <plugins>
30 |       <plugin>
31 |         <groupId>org.openjfx</groupId>
32 |         <artifactId>javafx-maven-plugin</artifactId>
33 |         <version>1.0-SNAPSHOT</version>
34 |         <configuration>
35 |           <mainClass>org.openjfx.TestJavaFXRun0</mainClass>
36 |         </configuration>
37 |       </plugin>
38 |     </plugins>
39 |   </build>
40 | </project>
41 | 


--------------------------------------------------------------------------------
/src/test/resources/unit/javafxrun-classpath-test/classpath-launcher.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |  ~ Copyright 2020, Gluon
 3 |  ~
 4 |  ~ Licensed under the Apache License, Version 2.0 (the "License");
 5 |  ~ you may not use this file except in compliance with the License.
 6 |  ~ You may obtain a copy of the License at
 7 |  ~
 8 |  ~   http://www.apache.org/licenses/LICENSE-2.0
 9 |  ~
10 |  ~ Unless required by applicable law or agreed to in writing, software
11 |  ~ distributed under the License is distributed on an "AS IS" BASIS,
12 |  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  ~ See the License for the specific language governing permissions and
14 |  ~ limitations under the License.
15 |   -->
16 | <project>
17 |   <modelVersion>4.0.0</modelVersion>
18 |   <groupId>org.openjfx</groupId>
19 |   <artifactId>javafxrun.classpath.launcher.test</artifactId>
20 |   <version>1.0-SNAPSHOT</version>
21 |   <packaging>jar</packaging>
22 |   <properties>
23 |     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
24 |     <maven.compiler.source>11</maven.compiler.source>
25 |     <maven.compiler.target>11</maven.compiler.target>
26 |     <javafx.version>15</javafx.version>
27 |   </properties>
28 |   <dependencies>
29 |     <dependency>
30 |       <groupId>org.openjfx</groupId>
31 |       <artifactId>javafx-controls</artifactId>
32 |       <version>${javafx.version}</version>
33 |     </dependency>
34 |   </dependencies>
35 |   <build>
36 |     <plugins>
37 |       <plugin>
38 |         <groupId>org.openjfx</groupId>
39 |         <artifactId>javafx-maven-plugin</artifactId>
40 |         <version>1.0-SNAPSHOT</version>
41 |         <configuration>
42 |           <mainClass>org.openjfx.TestLauncher</mainClass>
43 |           <runtimePathOption>CLASSPATH</runtimePathOption>
44 |         </configuration>
45 |       </plugin>
46 |     </plugins>
47 |   </build>
48 | </project>
49 | 


--------------------------------------------------------------------------------
/src/test/resources/unit/javafxrun-classpath-test/classpath-no-launcher.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |  ~ Copyright 2020, Gluon
 3 |  ~
 4 |  ~ Licensed under the Apache License, Version 2.0 (the "License");
 5 |  ~ you may not use this file except in compliance with the License.
 6 |  ~ You may obtain a copy of the License at
 7 |  ~
 8 |  ~   http://www.apache.org/licenses/LICENSE-2.0
 9 |  ~
10 |  ~ Unless required by applicable law or agreed to in writing, software
11 |  ~ distributed under the License is distributed on an "AS IS" BASIS,
12 |  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  ~ See the License for the specific language governing permissions and
14 |  ~ limitations under the License.
15 |   -->
16 | <project>
17 |   <modelVersion>4.0.0</modelVersion>
18 |   <groupId>org.openjfx</groupId>
19 |   <artifactId>javafxrun.classpath.launcher.test</artifactId>
20 |   <version>1.0-SNAPSHOT</version>
21 |   <packaging>jar</packaging>
22 |   <properties>
23 |     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
24 |     <maven.compiler.source>11</maven.compiler.source>
25 |     <maven.compiler.target>11</maven.compiler.target>
26 |     <javafx.version>15</javafx.version>
27 |   </properties>
28 |   <dependencies>
29 |     <dependency>
30 |       <groupId>org.openjfx</groupId>
31 |       <artifactId>javafx-controls</artifactId>
32 |       <version>${javafx.version}</version>
33 |     </dependency>
34 |   </dependencies>
35 |   <build>
36 |     <plugins>
37 |       <plugin>
38 |         <groupId>org.openjfx</groupId>
39 |         <artifactId>javafx-maven-plugin</artifactId>
40 |         <version>1.0-SNAPSHOT</version>
41 |         <configuration>
42 |           <mainClass>org.openjfx.TestJavaFXRun1</mainClass>
43 |           <runtimePathOption>CLASSPATH</runtimePathOption>
44 |         </configuration>
45 |       </plugin>
46 |     </plugins>
47 |   </build>
48 | </project>
49 | 


--------------------------------------------------------------------------------