#524

Committed 01 Aug 2025 02:16PM UTC coverage: 48.454% (-0.9%) from 49.315%

Build # #524

Build Type

push

github

Committed by

aalmiray

Commit Message

fix(hooks): Inherit matrix and environment from named groups

Relates to #1947

Coverage Stats

56 of 125 new or added lines in 5 files covered. (44.8%)

450 existing lines in 37 files now uncovered.

25680 of 52999 relevant lines covered (48.45%)

0.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.55

/core/jreleaser-engine/src/main/java/org/jreleaser/assemblers/JpackageAssemblerProcessor.java

/*
 * SPDX-License-Identifier: Apache-2.0
 *
 * Copyright 2020-2025 The JReleaser authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jreleaser.assemblers;

import org.apache.commons.io.IOUtils;
import org.jreleaser.bundle.RB;
import org.jreleaser.model.Constants;
import org.jreleaser.model.internal.JReleaserContext;
import org.jreleaser.model.internal.assemble.JlinkAssembler;
import org.jreleaser.model.internal.assemble.JpackageAssembler;
import org.jreleaser.model.internal.common.Artifact;
import org.jreleaser.model.spi.assemble.AssemblerProcessingException;
import org.jreleaser.mustache.TemplateContext;
import org.jreleaser.sdk.command.Command;
import org.jreleaser.templates.TemplateResource;
import org.jreleaser.templates.TemplateUtils;
import org.jreleaser.util.FileUtils;
import org.jreleaser.util.PlatformUtils;
import org.jreleaser.version.SemanticVersion;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Optional;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
import static org.jreleaser.assemblers.AssemblerUtils.copyJars;
import static org.jreleaser.assemblers.AssemblerUtils.readJavaVersion;
import static org.jreleaser.mustache.Templates.resolveTemplate;
import static org.jreleaser.util.FileType.JAR;
import static org.jreleaser.util.FileUtils.listFilesAndProcess;
import static org.jreleaser.util.PlatformUtils.isWindows;
import static org.jreleaser.util.StringUtils.isBlank;
import static org.jreleaser.util.StringUtils.isNotBlank;

/**
 * @author Andres Almiray
 * @since 0.10.0
 */
public class JpackageAssemblerProcessor extends AbstractAssemblerProcessor<org.jreleaser.model.api.assemble.JpackageAssembler, JpackageAssembler> {
    private static final String FILES_DIRECTORY = "files";

    public JpackageAssemblerProcessor(JReleaserContext context) {
        super(context);
    }

    @Override
    protected void doAssemble(TemplateContext props) throws AssemblerProcessingException {
        JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();

        if (!packager.getJdk().isActiveAndSelected()) return;

        // verify jdk
        Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);
        SemanticVersion jdkVersion = SemanticVersion.of(readJavaVersion(jdkPath));
        context.getLogger().debug(RB.$("assembler.jpackage.jdk"), jdkVersion, jdkPath.toAbsolutePath().toString());
        if (jdkVersion.getMajor() < 16) {
            throw new AssemblerProcessingException(RB.$("ERROR_jpackage_minimum_jdk_required", jdkVersion.toString()));
        }

        String platform = packager.getJdk().getPlatform();
        String platformReplaced = assembler.getPlatform().applyReplacements(platform);

        Path assembleDirectory = props.get(Constants.KEY_DISTRIBUTION_ASSEMBLE_DIRECTORY);
        Path workDirectory = assembleDirectory.resolve(WORK_DIRECTORY + "-" + platformReplaced);
        Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);
        Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);

        // copy files to inputs
        copyTemplates(context, props, filesDirectory);
        copyArtifacts(context, filesDirectory, platform, true);
        copyFiles(context, filesDirectory);
        copyFileSets(context, filesDirectory);

        // copy jars to inputs
        context.getLogger().debug(RB.$("assembler.copy.jars"), context.relativizeToBasedir(filesDirectory));
        if (isBlank(assembler.getJava().getMainModule())) {
            if (isNotBlank(assembler.getJlink())) {
                JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());
                if (jlink.getJavaArchive().isSet()) {
                    String archiveFile = resolveTemplate(jlink.getJavaArchive().getPath(), props);
                    Path archivePath = context.getBasedir().resolve(Paths.get(archiveFile));
                    if (!Files.exists(archivePath)) {
                        throw new AssemblerProcessingException(RB.$("ERROR_path_does_not_exist", archivePath));
                    }

                    Path archiveDirectory = inputsDirectory.resolve(ARCHIVE_DIRECTORY);
                    try {
                        FileUtils.unpackArchive(archivePath, archiveDirectory, true);
                    } catch (IOException e) {
                        throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
                    }

                    String libDirectoryName = resolveTemplate(jlink.getJavaArchive().getLibDirectoryName(), props);
                    Path libPath = inputsDirectory.resolve(ARCHIVE_DIRECTORY).resolve(libDirectoryName);
                    try {
                        FileUtils.copyFiles(context.getLogger(), libPath, filesDirectory);
                    } catch (IOException e) {
                        throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
                    }
                }
            }

            copyJars(context, assembler, filesDirectory, "");
            copyJars(context, assembler, filesDirectory, platform);
        }

        // copy icon to inputs
        copyIcon(context, assembler, packager, inputsDirectory, platform, props);

        // adjust runtime image
        if (isNotBlank(assembler.getJlink())) {
            adjustRuntimeImage(context, assembler, workDirectory, platform);
        }

        for (String type : packager.getTypes()) {
            context.getLogger().info("- " + RB.$("assembler.jpackage.type"), type);
            jpackage(context, type, workDirectory, props);
        }
    }

    private void copyIcon(JReleaserContext context, JpackageAssembler assembler,
                          JpackageAssembler.PlatformPackager packager, Path inputsDirectory,
                          String platform, TemplateContext props) throws AssemblerProcessingException {
        String p = "linux";
        String ext = ".png";

        if (isWindows(platform)) {
            p = "windows";
            ext = ".ico";
        } else if (PlatformUtils.isMac(platform)) {
            p = "osx";
            ext = ".icns";
        }

        String icon = resolveTemplate(packager.getIcon(), props);
        try {
            if (isNotBlank(icon) && Files.exists(context.getBasedir().resolve(icon)) && icon.endsWith(ext)) {
                Path iconPath = context.getBasedir().resolve(icon);
                Files.copy(iconPath, inputsDirectory.resolve(assembler.getName() + ext), REPLACE_EXISTING);
            } else {
                String iconResource = "META-INF/jreleaser/icons/" + p + "/duke" + ext;
                try (TemplateResource templateResource = TemplateUtils.resolveResource(context.getLogger(), iconResource)) {
                    writeFile(IOUtils.toByteArray(templateResource.getInputStream()), inputsDirectory.resolve(assembler.getName() + ext));
                }
            }
        } catch (Exception e) {
            throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
        }
    }

    @SuppressWarnings("UnnecessaryParentheses")
    private void adjustRuntimeImage(JReleaserContext context, JpackageAssembler assembler, Path workDirectory, String platform) throws AssemblerProcessingException {
        Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);
        if (!runtimeImageByPlatform.isPresent()) {
            throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));
        }

        Path originalImage = runtimeImageByPlatform.get().getEffectivePath(context, assembler);
        Path adjustedImage = workDirectory.resolve("runtime-image");

        try {
            if (!FileUtils.copyFilesRecursive(context.getLogger(), originalImage, adjustedImage, path -> {
                String fileName = path.getFileName().toString();
                boolean pathIsJar = fileName.endsWith(JAR.extension()) && path.getParent().getFileName().toString().equals(JARS_DIRECTORY);
                boolean pathIsExecutable = fileName.equals(context.getModel().getAssemble().findJlink(assembler.getJlink()).getExecutable());
                return pathIsJar || pathIsExecutable;
            })) {
                throw new IOException(RB.$("ERROR_assembler_adjusting_image", adjustedImage));
            }
        } catch (IOException e) {
            throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
        }

        runtimeImageByPlatform.get().setPath(adjustedImage.toAbsolutePath().toString());
    }

    private void jpackage(JReleaserContext context, String type, Path workDirectory, TemplateContext props) throws AssemblerProcessingException {
        JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();
        Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);
        String platform = packager.getJdk().getPlatform();
        String platformReplaced = assembler.getPlatform().applyReplacements(platform);

        Path assembleDirectory = workDirectory.getParent();
        Path packagerDirectory = workDirectory.resolve(type).toAbsolutePath();
        try {
            FileUtils.deleteFiles(packagerDirectory);
        } catch (IOException e) {
            throw new AssemblerProcessingException(RB.$("ERROR_assembler_delete_dir",
                context.relativizeToBasedir(packagerDirectory)), e);
        }

        Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);

        Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);
        if (!runtimeImageByPlatform.isPresent()) {
            throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));
        }

        String moduleName = assembler.getJava().getMainModule();
        String appName = packager.getResolvedAppName(context, assembler);
        String appVersion = assembler.getApplicationPackage().getResolvedAppVersion(context, assembler);
        String vendor = assembler.getApplicationPackage().getVendor();
        String copyright = assembler.getApplicationPackage().getCopyright();

        Path jpackageExecutable = jdkPath
            .resolve(BIN_DIRECTORY)
            .resolve(isWindows() ? "jpackage.exe" : "jpackage")
            .toAbsolutePath();

        Command cmd = new Command(jpackageExecutable.toAbsolutePath().toString(), true)
            .arg("--type")
            .arg(type)
            .arg("--dest")
            .arg(assembleDirectory.toAbsolutePath().toString())
            .arg("--input")
            .arg(inputsDirectory.resolve(FILES_DIRECTORY).toAbsolutePath().toString())
            .arg("--name")
            .arg(maybeQuote(appName))
            .arg("--runtime-image")
            .arg(maybeQuote(runtimeImageByPlatform.get().getEffectivePath(context, assembler).toAbsolutePath().toString()))
            .arg("--app-version")
            .arg(appVersion)
            .arg("--vendor")
            .arg(maybeQuote(vendor))
            .arg("--copyright")
            .arg(maybeQuote(copyright))
            .arg("--description")
            .arg(maybeQuote(context.getModel().getProject().getDescription()));

        if (assembler.isVerbose()) {
            cmd.arg("--verbose");
        }

        if (isNotBlank(moduleName)) {
            cmd.arg("--module")
                .arg(moduleName + "/" + assembler.getJava().getMainClass());
        } else {
            String mainJarPath = "";

            if (isNotBlank(assembler.getMainJar().getPath())) {
                mainJarPath = assembler.getMainJar().getResolvedPath().getFileName().toString();
            }

            if (isNotBlank(assembler.getJlink())) {
                JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());
                if (jlink.getJavaArchive().isSet()) {
                    String mainJarName = resolveTemplate(jlink.getJavaArchive().getMainJarName(), props);
                    Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);
                    mainJarPath = filesDirectory.resolve(mainJarName).getFileName().toString();
                }
            }

            cmd.arg("--main-class")
                .arg(assembler.getJava().getMainClass())
                .arg("--main-jar")
                .arg(maybeQuote(mainJarPath));
        }

        // Launcher
        for (String argument : assembler.getLauncher().getArguments()) {
            cmd.arg("--arguments")
                .arg(maybeQuote(argument));
        }
        for (String javaOption : assembler.getLauncher().getJavaOptions()) {
            cmd.arg("--java-options")
                .arg(maybeQuote(javaOption));
        }
        for (String launcher : assembler.getLauncher().getLaunchers()) {
            cmd.arg("--add-launcher")
                .arg(maybeQuote(launcher));
        }

        // ApplicationPackage
        String licenseFile = resolveTemplate(assembler.getApplicationPackage().getLicenseFile(), props);
        if (isNotBlank(licenseFile)) {
            Path licenseFilePath = context.getBasedir().resolve(licenseFile);
            if (Files.exists(licenseFilePath)) {
                cmd.arg("--license-file")
                    .arg(maybeQuote(licenseFilePath.toAbsolutePath().toString()));
            }
        }

        if (!assembler.getApplicationPackage().getFileAssociations().isEmpty()) {
            for (String filename : assembler.getApplicationPackage().getFileAssociations()) {
                Path path = context.getBasedir().resolve(resolveTemplate(filename, props));
                if (Files.exists(path)) {
                    cmd.arg("--file-associations")
                        .arg(maybeQuote(path.toAbsolutePath().toString()));
                }
            }
        }

        customize(type, packager, inputsDirectory, cmd, props);

        context.getLogger().debug(String.join(" ", cmd.getArgs()));
        Command.Result result = executeCommand(cmd);
        if (assembler.isVerbose()) {
            context.getLogger().debug(result.getOut());
        }

        // replace only if not linux
        if (!PlatformUtils.isLinux(platform) && assembler.isAttachPlatform()) {
            try {
                Optional<Path> artifact = listFilesAndProcess(assembleDirectory, files ->
                    files.filter(path -> path.getFileName().toString().endsWith(type))
                        .findFirst().orElse(null));

                if (artifact.isPresent()) {
                    String dest = artifact.get().getFileName().toString()
                        .replace("." + type, "-" + platformReplaced + "." + type);
                    Files.move(
                        assembleDirectory.resolve(artifact.get().getFileName()),
                        assembleDirectory.resolve(dest), REPLACE_EXISTING);
                }
            } catch (IOException e) {
                throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
            }
        }
    }

    private void customize(String type, JpackageAssembler.PlatformPackager packager, Path inputsDirectory, Command cmd, TemplateContext props) {
        String installDir = resolveTemplate(packager.getInstallDir(), props);
        if (isNotBlank(installDir)) {
            cmd.arg("--install-dir")
                .arg(maybeQuote(installDir));
        }

        String resourceDir = resolveTemplate(packager.getResourceDir(), props);
        if (isNotBlank(resourceDir)) {
            Path resourceDirPath = context.getBasedir().resolve(resourceDir);
            if (Files.exists(resourceDirPath)) {
                cmd.arg("--resource-dir")
                    .arg(maybeQuote(resourceDirPath.toAbsolutePath().toString()));
            }
        }

        if (packager instanceof JpackageAssembler.Osx) {
            customizeOsx((JpackageAssembler.Osx) packager, inputsDirectory, cmd, props);
        } else if (packager instanceof JpackageAssembler.Linux) {
            customizeLinux(type, (JpackageAssembler.Linux) packager, inputsDirectory, cmd);
        } else if (packager instanceof JpackageAssembler.Windows) {
            customizeWindows((JpackageAssembler.Windows) packager, inputsDirectory, cmd, props);
        }
    }

    private void customizeOsx(JpackageAssembler.Osx packager, Path inputsDirectory, Command cmd, TemplateContext props) {
        if (isNotBlank(packager.getPackageName())) {
            cmd.arg("--mac-package-name")
                .arg(packager.getPackageName());
        }
        if (isNotBlank(packager.getPackageSigningPrefix())) {
            cmd.arg("--mac-package-signing-prefix")
                .arg(packager.getPackageSigningPrefix());
        }
        if (packager.isSign()) {
            cmd.arg("--mac-sign");
        }

        String signingKeychain = resolveTemplate(packager.getSigningKeychain(), props);
        if (isNotBlank(signingKeychain)) {
            Path path = context.getBasedir().resolve(resolveTemplate(signingKeychain, props));
            if (Files.exists(path)) {
                cmd.arg("--mac-signing-keychain")
                    .arg(path.toAbsolutePath().toString());
            }
        }
        if (isNotBlank(packager.getSigningKeyUsername())) {
            cmd.arg("--mac-signing-key-user-name")
                .arg(packager.getSigningKeyUsername());
        }

        cmd.arg("--icon")
            .arg(inputsDirectory.resolve(assembler.getName() + ".icns").toAbsolutePath().toString());
    }

    private void customizeLinux(String type, JpackageAssembler.Linux packager, Path inputsDirectory, Command cmd) {
        if (isNotBlank(packager.getPackageName())) {
            cmd.arg("--linux-package-name")
                .arg(packager.getPackageName());
        }
        if (isNotBlank(packager.getMenuGroup())) {
            cmd.arg("--linux-menu-group")
                .arg(packager.getMenuGroup());
        }
        if (isNotBlank(packager.getAppRelease())) {
            cmd.arg("--linux-app-release")
                .arg(packager.getAppRelease());
        }
        if (isNotBlank(packager.getAppCategory())) {
            cmd.arg("--linux-app-category")
                .arg(packager.getAppCategory());
        }
        if (packager.isShortcut()) {
            cmd.arg("--linux-shortcut");
        }
        if (!packager.getPackageDeps().isEmpty()) {
            cmd.arg("--linux-package-deps")
                .arg(String.join(",", packager.getPackageDeps()));
        }

        if ("deb".equals(type)) {
            if (isNotBlank(packager.getMaintainer())) {
                cmd.arg("--linux-deb-maintainer")
                    .arg(packager.getMaintainer());
            }
        } else if ("rpm".equals(type)) {
            if (isNotBlank(packager.getLicense())) {
                cmd.arg("--linux-rpm-license-type")
                    .arg(packager.getLicense());
            }
        }

        cmd.arg("--icon")
            .arg(inputsDirectory.resolve(assembler.getName() + ".png").toAbsolutePath().toString());
    }

    private void customizeWindows(JpackageAssembler.Windows packager, Path inputsDirectory, Command cmd, TemplateContext props) {
        if (packager.isConsole()) {
            cmd.arg("--win-console");
        }
        if (packager.isDirChooser()) {
            cmd.arg("--win-dir-chooser");
        }
        if (packager.isMenu()) {
            cmd.arg("--win-menu");
        }
        if (packager.isPerUserInstall()) {
            cmd.arg("--win-per-user-install");
        }
        if (packager.isShortcut()) {
            cmd.arg("--win-shortcut");
        }
        if (packager.isShortcutPrompt()) {
            cmd.arg("--win-shortcut-prompt");
        }
        if (isNotBlank(packager.getMenuGroup())) {
            cmd.arg("--win-menu-group")
                .arg(maybeQuote(packager.getMenuGroup()));
        }
        if (isNotBlank(packager.getUpgradeUuid())) {
            cmd.arg("--win-upgrade-uuid")
                .arg(packager.getUpgradeUuid());
        }
        if (isNotBlank(packager.getHelpUrl())) {
            cmd.arg("--win-help-url")
                .arg(resolveTemplate(packager.getHelpUrl(), props));
        }
        if (isNotBlank(packager.getUpdateUrl())) {
            cmd.arg("--win-update-url")
                .arg(resolveTemplate(packager.getUpdateUrl(), props));
        }

        cmd.arg("--icon")
            .arg(maybeQuote(inputsDirectory.resolve(assembler.getName() + ".ico").toAbsolutePath().toString()));
    }
}

1	/*
2	* SPDX-License-Identifier: Apache-2.0
3	*
4	* Copyright 2020-2025 The JReleaser authors.
5	*
6	* Licensed under the Apache License, Version 2.0 (the "License");
7	* you may not use this file except in compliance with the License.
8	* You may obtain a copy of the License at
9	*
10	* https://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing, software
13	* distributed under the License is distributed on an "AS IS" BASIS,
14	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15	* See the License for the specific language governing permissions and
16	* limitations under the License.
17	*/
18	package org.jreleaser.assemblers;
19
20	import org.apache.commons.io.IOUtils;
21	import org.jreleaser.bundle.RB;
22	import org.jreleaser.model.Constants;
23	import org.jreleaser.model.internal.JReleaserContext;
24	import org.jreleaser.model.internal.assemble.JlinkAssembler;
25	import org.jreleaser.model.internal.assemble.JpackageAssembler;
26	import org.jreleaser.model.internal.common.Artifact;
27	import org.jreleaser.model.spi.assemble.AssemblerProcessingException;
28	import org.jreleaser.mustache.TemplateContext;
29	import org.jreleaser.sdk.command.Command;
30	import org.jreleaser.templates.TemplateResource;
31	import org.jreleaser.templates.TemplateUtils;
32	import org.jreleaser.util.FileUtils;
33	import org.jreleaser.util.PlatformUtils;
34	import org.jreleaser.version.SemanticVersion;
35
36	import java.io.IOException;
37	import java.nio.file.Files;
38	import java.nio.file.Path;
39	import java.nio.file.Paths;
40	import java.util.Optional;
41
42	import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
43	import static org.jreleaser.assemblers.AssemblerUtils.copyJars;
44	import static org.jreleaser.assemblers.AssemblerUtils.readJavaVersion;
45	import static org.jreleaser.mustache.Templates.resolveTemplate;
46	import static org.jreleaser.util.FileType.JAR;
47	import static org.jreleaser.util.FileUtils.listFilesAndProcess;
48	import static org.jreleaser.util.PlatformUtils.isWindows;
49	import static org.jreleaser.util.StringUtils.isBlank;
50	import static org.jreleaser.util.StringUtils.isNotBlank;
51
52	/**
53	* @author Andres Almiray
54	* @since 0.10.0
55	*/
56	public class JpackageAssemblerProcessor extends AbstractAssemblerProcessor<org.jreleaser.model.api.assemble.JpackageAssembler, JpackageAssembler> {
57	private static final String FILES_DIRECTORY = "files";
58
59	public JpackageAssemblerProcessor(JReleaserContext context) {
60	super(context);	1✔
61	}	1✔
62
63	@Override
64	protected void doAssemble(TemplateContext props) throws AssemblerProcessingException {
65	JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();	1✔
66
67	if (!packager.getJdk().isActiveAndSelected()) return;	1✔
68
69	// verify jdk
70	Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);	1✔
71	SemanticVersion jdkVersion = SemanticVersion.of(readJavaVersion(jdkPath));	1✔
72	context.getLogger().debug(RB.$("assembler.jpackage.jdk"), jdkVersion, jdkPath.toAbsolutePath().toString());	1✔
73	if (jdkVersion.getMajor() < 16) {	1✔
74	throw new AssemblerProcessingException(RB.$("ERROR_jpackage_minimum_jdk_required", jdkVersion.toString()));	×
75	}
76
77	String platform = packager.getJdk().getPlatform();	1✔
78	String platformReplaced = assembler.getPlatform().applyReplacements(platform);	1✔
79
80	Path assembleDirectory = props.get(Constants.KEY_DISTRIBUTION_ASSEMBLE_DIRECTORY);	1✔
81	Path workDirectory = assembleDirectory.resolve(WORK_DIRECTORY + "-" + platformReplaced);	1✔
82	Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);	1✔
83	Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);	1✔
84
85	// copy files to inputs
86	copyTemplates(context, props, filesDirectory);	1✔
87	copyArtifacts(context, filesDirectory, platform, true);	1✔
88	copyFiles(context, filesDirectory);	1✔
89	copyFileSets(context, filesDirectory);	1✔
90
91	// copy jars to inputs
92	context.getLogger().debug(RB.$("assembler.copy.jars"), context.relativizeToBasedir(filesDirectory));	1✔
93	if (isBlank(assembler.getJava().getMainModule())) {	1✔
94	if (isNotBlank(assembler.getJlink())) {	1✔
95	JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());	1✔
96	if (jlink.getJavaArchive().isSet()) {	1✔
97	String archiveFile = resolveTemplate(jlink.getJavaArchive().getPath(), props);	×
98	Path archivePath = context.getBasedir().resolve(Paths.get(archiveFile));	×
99	if (!Files.exists(archivePath)) {	×
100	throw new AssemblerProcessingException(RB.$("ERROR_path_does_not_exist", archivePath));	×
101	}
102
103	Path archiveDirectory = inputsDirectory.resolve(ARCHIVE_DIRECTORY);	×
104	try {
105	FileUtils.unpackArchive(archivePath, archiveDirectory, true);	×
106	} catch (IOException e) {	×
107	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
108	}	×
109
110	String libDirectoryName = resolveTemplate(jlink.getJavaArchive().getLibDirectoryName(), props);	×
111	Path libPath = inputsDirectory.resolve(ARCHIVE_DIRECTORY).resolve(libDirectoryName);	×
112	try {
113	FileUtils.copyFiles(context.getLogger(), libPath, filesDirectory);	×
114	} catch (IOException e) {	×
115	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
116	}	×
117	}
118	}
119
120	copyJars(context, assembler, filesDirectory, "");	1✔
121	copyJars(context, assembler, filesDirectory, platform);	1✔
122	}
123
124	// copy icon to inputs
125	copyIcon(context, assembler, packager, inputsDirectory, platform, props);	1✔
126
127	// adjust runtime image
128	if (isNotBlank(assembler.getJlink())) {	1✔
129	adjustRuntimeImage(context, assembler, workDirectory, platform);	1✔
130	}
131
132	for (String type : packager.getTypes()) {	1✔
133	context.getLogger().info("- " + RB.$("assembler.jpackage.type"), type);	1✔
134	jpackage(context, type, workDirectory, props);	1✔
135	}	1✔
136	}	1✔
137
138	private void copyIcon(JReleaserContext context, JpackageAssembler assembler,
139	JpackageAssembler.PlatformPackager packager, Path inputsDirectory,
140	String platform, TemplateContext props) throws AssemblerProcessingException {
141	String p = "linux";	1✔
142	String ext = ".png";	1✔
143
144	if (isWindows(platform)) {	1✔
145	p = "windows";	×
146	ext = ".ico";	×
147	} else if (PlatformUtils.isMac(platform)) {	1✔
148	p = "osx";	1✔
149	ext = ".icns";	1✔
150	}
151
152	String icon = resolveTemplate(packager.getIcon(), props);	1✔
153	try {
154	if (isNotBlank(icon) && Files.exists(context.getBasedir().resolve(icon)) && icon.endsWith(ext)) {	1✔
155	Path iconPath = context.getBasedir().resolve(icon);	1✔
156	Files.copy(iconPath, inputsDirectory.resolve(assembler.getName() + ext), REPLACE_EXISTING);	1✔
157	} else {	1✔
158	String iconResource = "META-INF/jreleaser/icons/" + p + "/duke" + ext;	×
159	try (TemplateResource templateResource = TemplateUtils.resolveResource(context.getLogger(), iconResource)) {	×
160	writeFile(IOUtils.toByteArray(templateResource.getInputStream()), inputsDirectory.resolve(assembler.getName() + ext));	×
161	}
162	}
163	} catch (Exception e) {	×
164	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
165	}	1✔
166	}	1✔
167
168	@SuppressWarnings("UnnecessaryParentheses")
169	private void adjustRuntimeImage(JReleaserContext context, JpackageAssembler assembler, Path workDirectory, String platform) throws AssemblerProcessingException {
170	Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);	1✔
171	if (!runtimeImageByPlatform.isPresent()) {	1✔
172	throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));	×
173	}
174
175	Path originalImage = runtimeImageByPlatform.get().getEffectivePath(context, assembler);	1✔
176	Path adjustedImage = workDirectory.resolve("runtime-image");	1✔
177
178	try {
179	if (!FileUtils.copyFilesRecursive(context.getLogger(), originalImage, adjustedImage, path -> {	1✔
180	String fileName = path.getFileName().toString();	1✔
181	boolean pathIsJar = fileName.endsWith(JAR.extension()) && path.getParent().getFileName().toString().equals(JARS_DIRECTORY);	1✔
182	boolean pathIsExecutable = fileName.equals(context.getModel().getAssemble().findJlink(assembler.getJlink()).getExecutable());	1✔
183	return pathIsJar \|\| pathIsExecutable;	1✔
184	})) {
185	throw new IOException(RB.$("ERROR_assembler_adjusting_image", adjustedImage));	×
186	}
187	} catch (IOException e) {	×
188	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
189	}	1✔
190
191	runtimeImageByPlatform.get().setPath(adjustedImage.toAbsolutePath().toString());	1✔
192	}	1✔
193
194	private void jpackage(JReleaserContext context, String type, Path workDirectory, TemplateContext props) throws AssemblerProcessingException {
195	JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();	1✔
196	Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);	1✔
197	String platform = packager.getJdk().getPlatform();	1✔
198	String platformReplaced = assembler.getPlatform().applyReplacements(platform);	1✔
199
200	Path assembleDirectory = workDirectory.getParent();	1✔
201	Path packagerDirectory = workDirectory.resolve(type).toAbsolutePath();	1✔
202	try {
203	FileUtils.deleteFiles(packagerDirectory);	1✔
204	} catch (IOException e) {	×
205	throw new AssemblerProcessingException(RB.$("ERROR_assembler_delete_dir",	×
206	context.relativizeToBasedir(packagerDirectory)), e);	×
207	}	1✔
208
209	Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);	1✔
210
211	Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);	1✔
212	if (!runtimeImageByPlatform.isPresent()) {	1✔
213	throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));	×
214	}
215
216	String moduleName = assembler.getJava().getMainModule();	1✔
217	String appName = packager.getResolvedAppName(context, assembler);	1✔
218	String appVersion = assembler.getApplicationPackage().getResolvedAppVersion(context, assembler);	1✔
219	String vendor = assembler.getApplicationPackage().getVendor();	1✔
220	String copyright = assembler.getApplicationPackage().getCopyright();	1✔
221
222	Path jpackageExecutable = jdkPath	1✔
223	.resolve(BIN_DIRECTORY)	1✔
224	.resolve(isWindows() ? "jpackage.exe" : "jpackage")	1✔
225	.toAbsolutePath();	1✔
226
227	Command cmd = new Command(jpackageExecutable.toAbsolutePath().toString(), true)	1✔
228	.arg("--type")	1✔
229	.arg(type)	1✔
230	.arg("--dest")	1✔
231	.arg(assembleDirectory.toAbsolutePath().toString())	1✔
232	.arg("--input")	1✔
233	.arg(inputsDirectory.resolve(FILES_DIRECTORY).toAbsolutePath().toString())	1✔
234	.arg("--name")	1✔
235	.arg(maybeQuote(appName))	1✔
236	.arg("--runtime-image")	1✔
237	.arg(maybeQuote(runtimeImageByPlatform.get().getEffectivePath(context, assembler).toAbsolutePath().toString()))	1✔
238	.arg("--app-version")	1✔
239	.arg(appVersion)	1✔
240	.arg("--vendor")	1✔
241	.arg(maybeQuote(vendor))	1✔
242	.arg("--copyright")	1✔
243	.arg(maybeQuote(copyright))	1✔
244	.arg("--description")	1✔
245	.arg(maybeQuote(context.getModel().getProject().getDescription()));	1✔
246
247	if (assembler.isVerbose()) {	1✔
248	cmd.arg("--verbose");	×
249	}
250
251	if (isNotBlank(moduleName)) {	1✔
252	cmd.arg("--module")	×
253	.arg(moduleName + "/" + assembler.getJava().getMainClass());	×
254	} else {
255	String mainJarPath = "";	1✔
256
257	if (isNotBlank(assembler.getMainJar().getPath())) {	1✔
258	mainJarPath = assembler.getMainJar().getResolvedPath().getFileName().toString();	1✔
259	}
260
261	if (isNotBlank(assembler.getJlink())) {	1✔
262	JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());	1✔
263	if (jlink.getJavaArchive().isSet()) {	1✔
264	String mainJarName = resolveTemplate(jlink.getJavaArchive().getMainJarName(), props);	×
265	Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);	×
266	mainJarPath = filesDirectory.resolve(mainJarName).getFileName().toString();	×
267	}
268	}
269
270	cmd.arg("--main-class")	1✔
271	.arg(assembler.getJava().getMainClass())	1✔
272	.arg("--main-jar")	1✔
273	.arg(maybeQuote(mainJarPath));	1✔
274	}
275
276	// Launcher
277	for (String argument : assembler.getLauncher().getArguments()) {	1✔
278	cmd.arg("--arguments")	×
279	.arg(maybeQuote(argument));	×
280	}	×
281	for (String javaOption : assembler.getLauncher().getJavaOptions()) {	1✔
282	cmd.arg("--java-options")	×
283	.arg(maybeQuote(javaOption));	×
284	}	×
285	for (String launcher : assembler.getLauncher().getLaunchers()) {	1✔
286	cmd.arg("--add-launcher")	×
287	.arg(maybeQuote(launcher));	×
288	}	×
289
290	// ApplicationPackage
291	String licenseFile = resolveTemplate(assembler.getApplicationPackage().getLicenseFile(), props);	1✔
292	if (isNotBlank(licenseFile)) {	1✔
293	Path licenseFilePath = context.getBasedir().resolve(licenseFile);	×
294	if (Files.exists(licenseFilePath)) {	×
295	cmd.arg("--license-file")	×
296	.arg(maybeQuote(licenseFilePath.toAbsolutePath().toString()));	×
297	}
298	}
299
300	if (!assembler.getApplicationPackage().getFileAssociations().isEmpty()) {	1✔
301	for (String filename : assembler.getApplicationPackage().getFileAssociations()) {	×
302	Path path = context.getBasedir().resolve(resolveTemplate(filename, props));	×
303	if (Files.exists(path)) {	×
304	cmd.arg("--file-associations")	×
305	.arg(maybeQuote(path.toAbsolutePath().toString()));	×
306	}
307	}	×
308	}
309
310	customize(type, packager, inputsDirectory, cmd, props);	1✔
311
312	context.getLogger().debug(String.join(" ", cmd.getArgs()));	1✔
313	Command.Result result = executeCommand(cmd);	1✔
314	if (assembler.isVerbose()) {	1✔
315	context.getLogger().debug(result.getOut());	×
316	}
317
318	// replace only if not linux
319	if (!PlatformUtils.isLinux(platform) && assembler.isAttachPlatform()) {	1✔
320	try {
321	Optional<Path> artifact = listFilesAndProcess(assembleDirectory, files ->	1✔
322	files.filter(path -> path.getFileName().toString().endsWith(type))	1✔
323	.findFirst().orElse(null));	1✔
324
325	if (artifact.isPresent()) {	1✔
326	String dest = artifact.get().getFileName().toString()	1✔
327	.replace("." + type, "-" + platformReplaced + "." + type);	1✔
328	Files.move(	1✔
329	assembleDirectory.resolve(artifact.get().getFileName()),	1✔
330	assembleDirectory.resolve(dest), REPLACE_EXISTING);	1✔
331	}
332	} catch (IOException e) {	×
333	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
334	}	1✔
335	}
336	}	1✔
337
338	private void customize(String type, JpackageAssembler.PlatformPackager packager, Path inputsDirectory, Command cmd, TemplateContext props) {
339	String installDir = resolveTemplate(packager.getInstallDir(), props);	1✔
340	if (isNotBlank(installDir)) {	1✔
341	cmd.arg("--install-dir")	×
342	.arg(maybeQuote(installDir));	×
343	}
344
345	String resourceDir = resolveTemplate(packager.getResourceDir(), props);	1✔
346	if (isNotBlank(resourceDir)) {	1✔
347	Path resourceDirPath = context.getBasedir().resolve(resourceDir);	1✔
348	if (Files.exists(resourceDirPath)) {	1✔
349	cmd.arg("--resource-dir")	×
350	.arg(maybeQuote(resourceDirPath.toAbsolutePath().toString()));	×
351	}
352	}
353
354	if (packager instanceof JpackageAssembler.Osx) {	1✔
355	customizeOsx((JpackageAssembler.Osx) packager, inputsDirectory, cmd, props);	1✔
UNCOV 356	} else if (packager instanceof JpackageAssembler.Linux) {	×
UNCOV 357	customizeLinux(type, (JpackageAssembler.Linux) packager, inputsDirectory, cmd);	×
358	} else if (packager instanceof JpackageAssembler.Windows) {	×
359	customizeWindows((JpackageAssembler.Windows) packager, inputsDirectory, cmd, props);	×
360	}
361	}	1✔
362
363	private void customizeOsx(JpackageAssembler.Osx packager, Path inputsDirectory, Command cmd, TemplateContext props) {
364	if (isNotBlank(packager.getPackageName())) {	1✔
365	cmd.arg("--mac-package-name")	1✔
366	.arg(packager.getPackageName());	1✔
367	}
368	if (isNotBlank(packager.getPackageSigningPrefix())) {	1✔
369	cmd.arg("--mac-package-signing-prefix")	×
370	.arg(packager.getPackageSigningPrefix());	×
371	}
372	if (packager.isSign()) {	1✔
373	cmd.arg("--mac-sign");	×
374	}
375
376	String signingKeychain = resolveTemplate(packager.getSigningKeychain(), props);	1✔
377	if (isNotBlank(signingKeychain)) {	1✔
378	Path path = context.getBasedir().resolve(resolveTemplate(signingKeychain, props));	×
379	if (Files.exists(path)) {	×
380	cmd.arg("--mac-signing-keychain")	×
381	.arg(path.toAbsolutePath().toString());	×
382	}
383	}
384	if (isNotBlank(packager.getSigningKeyUsername())) {	1✔
385	cmd.arg("--mac-signing-key-user-name")	×
386	.arg(packager.getSigningKeyUsername());	×
387	}
388
389	cmd.arg("--icon")	1✔
390	.arg(inputsDirectory.resolve(assembler.getName() + ".icns").toAbsolutePath().toString());	1✔
391	}	1✔
392
393	private void customizeLinux(String type, JpackageAssembler.Linux packager, Path inputsDirectory, Command cmd) {
UNCOV 394	if (isNotBlank(packager.getPackageName())) {	×
395	cmd.arg("--linux-package-name")	×
396	.arg(packager.getPackageName());	×
397	}
UNCOV 398	if (isNotBlank(packager.getMenuGroup())) {	×
399	cmd.arg("--linux-menu-group")	×
400	.arg(packager.getMenuGroup());	×
401	}
UNCOV 402	if (isNotBlank(packager.getAppRelease())) {	×
403	cmd.arg("--linux-app-release")	×
404	.arg(packager.getAppRelease());	×
405	}
UNCOV 406	if (isNotBlank(packager.getAppCategory())) {	×
407	cmd.arg("--linux-app-category")	×
408	.arg(packager.getAppCategory());	×
409	}
UNCOV 410	if (packager.isShortcut()) {	×
411	cmd.arg("--linux-shortcut");	×
412	}
UNCOV 413	if (!packager.getPackageDeps().isEmpty()) {	×
414	cmd.arg("--linux-package-deps")	×
415	.arg(String.join(",", packager.getPackageDeps()));	×
416	}
417
UNCOV 418	if ("deb".equals(type)) {	×
UNCOV 419	if (isNotBlank(packager.getMaintainer())) {	×
UNCOV 420	cmd.arg("--linux-deb-maintainer")	×
UNCOV 421	.arg(packager.getMaintainer());	×
422	}
UNCOV 423	} else if ("rpm".equals(type)) {	×
UNCOV 424	if (isNotBlank(packager.getLicense())) {	×
UNCOV 425	cmd.arg("--linux-rpm-license-type")	×
UNCOV 426	.arg(packager.getLicense());	×
427	}
428	}
429
UNCOV 430	cmd.arg("--icon")	×
UNCOV 431	.arg(inputsDirectory.resolve(assembler.getName() + ".png").toAbsolutePath().toString());	×
UNCOV 432	}	×
433
434	private void customizeWindows(JpackageAssembler.Windows packager, Path inputsDirectory, Command cmd, TemplateContext props) {
435	if (packager.isConsole()) {	×
436	cmd.arg("--win-console");	×
437	}
438	if (packager.isDirChooser()) {	×
439	cmd.arg("--win-dir-chooser");	×
440	}
441	if (packager.isMenu()) {	×
442	cmd.arg("--win-menu");	×
443	}
444	if (packager.isPerUserInstall()) {	×
445	cmd.arg("--win-per-user-install");	×
446	}
447	if (packager.isShortcut()) {	×
448	cmd.arg("--win-shortcut");	×
449	}
450	if (packager.isShortcutPrompt()) {	×
451	cmd.arg("--win-shortcut-prompt");	×
452	}
453	if (isNotBlank(packager.getMenuGroup())) {	×
454	cmd.arg("--win-menu-group")	×
455	.arg(maybeQuote(packager.getMenuGroup()));	×
456	}
457	if (isNotBlank(packager.getUpgradeUuid())) {	×
458	cmd.arg("--win-upgrade-uuid")	×
459	.arg(packager.getUpgradeUuid());	×
460	}
461	if (isNotBlank(packager.getHelpUrl())) {	×
462	cmd.arg("--win-help-url")	×
463	.arg(resolveTemplate(packager.getHelpUrl(), props));	×
464	}
465	if (isNotBlank(packager.getUpdateUrl())) {	×
466	cmd.arg("--win-update-url")	×
467	.arg(resolveTemplate(packager.getUpdateUrl(), props));	×
468	}
469
470	cmd.arg("--icon")	×
471	.arg(maybeQuote(inputsDirectory.resolve(assembler.getName() + ".ico").toAbsolutePath().toString()));	×
472	}	×
473	}

jreleaser / jreleaser / #524

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous