#558

Committed 08 Dec 2025 02:56PM UTC coverage: 48.239% (+0.02%) from 48.215%

Build # #558

Build Type

push

github

Committed by

aalmiray

Commit Message

feat(core): warn when a name template cannot be resolved

Closes #1960

Closes #1961

Coverage Stats

299 of 573 new or added lines in 133 files covered. (52.18%)

4 existing lines in 4 files now uncovered.

26047 of 53996 relevant lines covered (48.24%)

0.48 hits per line

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

1.63

/core/jreleaser-engine/src/main/java/org/jreleaser/packagers/WingetPackagerProcessor.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.packagers;

import org.jreleaser.model.internal.JReleaserContext;
import org.jreleaser.model.internal.common.Artifact;
import org.jreleaser.model.internal.distributions.Distribution;
import org.jreleaser.model.internal.packagers.WingetPackager;
import org.jreleaser.model.internal.util.Artifacts;
import org.jreleaser.model.spi.packagers.PackagerProcessingException;
import org.jreleaser.mustache.MustacheUtils;
import org.jreleaser.mustache.TemplateContext;
import org.jreleaser.util.Algorithm;
import org.jreleaser.util.FileType;
import org.jreleaser.util.PlatformUtils;

import java.io.Reader;
import java.nio.file.Path;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toList;
import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_ARTIFACT_PLATFORM;
import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_CLASS;
import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_MODULE;
import static org.jreleaser.model.Constants.KEY_PROJECT_LONG_DESCRIPTION;
import static org.jreleaser.model.Constants.KEY_WINGET_AUTHOR;
import static org.jreleaser.model.Constants.KEY_WINGET_DEFAULT_LOCALE;
import static org.jreleaser.model.Constants.KEY_WINGET_EXTERNAL_DEPENDENCIES;
import static org.jreleaser.model.Constants.KEY_WINGET_HAS_DEPENDENCIES;
import static org.jreleaser.model.Constants.KEY_WINGET_HAS_EXTERNAL_DEPENDENCIES;
import static org.jreleaser.model.Constants.KEY_WINGET_HAS_PACKAGE_DEPENDENCIES;
import static org.jreleaser.model.Constants.KEY_WINGET_HAS_TAGS;
import static org.jreleaser.model.Constants.KEY_WINGET_HAS_WINDOWS_FEATURES;
import static org.jreleaser.model.Constants.KEY_WINGET_HAS_WINDOWS_LIBRARIES;
import static org.jreleaser.model.Constants.KEY_WINGET_INSTALLERS;
import static org.jreleaser.model.Constants.KEY_WINGET_INSTALLER_ARCHITECTURE;
import static org.jreleaser.model.Constants.KEY_WINGET_INSTALLER_TYPE;
import static org.jreleaser.model.Constants.KEY_WINGET_INSTALL_MODES;
import static org.jreleaser.model.Constants.KEY_WINGET_MANIFEST_TYPE;
import static org.jreleaser.model.Constants.KEY_WINGET_MINIMUM_OS_VERSION;
import static org.jreleaser.model.Constants.KEY_WINGET_MONIKER;
import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_DEPENDENCIES;
import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_IDENTIFIER;
import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_LOCALE;
import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_NAME;
import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_URL;
import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_VERSION;
import static org.jreleaser.model.Constants.KEY_WINGET_PRODUCT_CODE;
import static org.jreleaser.model.Constants.KEY_WINGET_PUBLISHER_NAME;
import static org.jreleaser.model.Constants.KEY_WINGET_PUBLISHER_SUPPORT_URL;
import static org.jreleaser.model.Constants.KEY_WINGET_PUBLISHER_URL;
import static org.jreleaser.model.Constants.KEY_WINGET_RELEASE_DATE;
import static org.jreleaser.model.Constants.KEY_WINGET_SCOPE;
import static org.jreleaser.model.Constants.KEY_WINGET_TAGS;
import static org.jreleaser.model.Constants.KEY_WINGET_UPGRADE_BEHAVIOR;
import static org.jreleaser.model.Constants.KEY_WINGET_WINDOWS_FEATURES;
import static org.jreleaser.model.Constants.KEY_WINGET_WINDOWS_LIBRARIES;
import static org.jreleaser.mustache.Templates.resolveTemplate;
import static org.jreleaser.templates.TemplateUtils.trimTplExtension;
import static org.jreleaser.util.FileType.ZIP;
import static org.jreleaser.util.StringUtils.getFilename;
import static org.jreleaser.util.StringUtils.isBlank;

/**
 * @author Andres Almiray
 * @since 1.5.0
 */
public class WingetPackagerProcessor extends AbstractRepositoryPackagerProcessor<WingetPackager> {
    public WingetPackagerProcessor(JReleaserContext context) {
        super(context);
    }

    @Override
    protected void doPackageDistribution(Distribution distribution, TemplateContext props, Path packageDirectory) throws PackagerProcessingException {
        super.doPackageDistribution(distribution, props, packageDirectory);
        copyPreparedFiles(props);
    }

    @Override
    protected void fillPackagerProperties(TemplateContext props, Distribution distribution) {
        props.set(KEY_DISTRIBUTION_JAVA_MAIN_CLASS, distribution.getJava().getMainClass());
        props.set(KEY_DISTRIBUTION_JAVA_MAIN_MODULE, distribution.getJava().getMainModule());
        String desc = context.getModel().getProject().getLongDescription();
        desc = Arrays.stream(desc.split(System.lineSeparator()))
            .map(line -> "  " + line)
            .collect(Collectors.joining(System.lineSeparator()));
        props.set(KEY_PROJECT_LONG_DESCRIPTION,
            MustacheUtils.passThrough("|" + System.lineSeparator() + desc));

        props.set(KEY_WINGET_DEFAULT_LOCALE, packager.getDefaultLocale());
        props.set(KEY_WINGET_AUTHOR, packager.getAuthor());
        props.set(KEY_WINGET_MONIKER, resolveTemplate(context.getLogger(), packager.getMoniker(), props));
        props.set(KEY_WINGET_MINIMUM_OS_VERSION, packager.getMinimumOsVersion());
        props.set(KEY_WINGET_PRODUCT_CODE, resolveTemplate(context.getLogger(), packager.getProductCode(), props));
        props.set(KEY_WINGET_HAS_TAGS, !packager.getTags().isEmpty());
        props.set(KEY_WINGET_TAGS, packager.getTags());
        props.set(KEY_WINGET_PACKAGE_IDENTIFIER, resolveTemplate(context.getLogger(), packager.getPackage().getIdentifier(), props));
        props.set(KEY_WINGET_PACKAGE_NAME, resolveTemplate(context.getLogger(), packager.getPackage().getName(), props));
        props.set(KEY_WINGET_PACKAGE_VERSION, resolveTemplate(context.getLogger(), packager.getPackage().getVersion(), props));
        props.set(KEY_WINGET_PACKAGE_URL, resolveTemplate(context.getLogger(), packager.getPackage().getUrl(), props));
        props.set(KEY_WINGET_PUBLISHER_NAME, resolveTemplate(context.getLogger(), packager.getPublisher().getName(), props));
        props.set(KEY_WINGET_PUBLISHER_URL, resolveTemplate(context.getLogger(), packager.getPublisher().getUrl(), props));
        props.set(KEY_WINGET_PUBLISHER_SUPPORT_URL, resolveTemplate(context.getLogger(), packager.getPublisher().getSupportUrl(), props));
        props.set(KEY_WINGET_INSTALLER_TYPE, packager.getInstaller().getType().formatted());
        if (null != packager.getInstaller().getScope()) {
            props.set(KEY_WINGET_SCOPE, packager.getInstaller().getScope().formatted());
        }
        props.set(KEY_WINGET_INSTALL_MODES, packager.getInstaller().getModes().stream()
            .map(org.jreleaser.model.api.packagers.WingetPackager.Installer.Mode::formatted)
            .collect(toList()));
        if (null != packager.getInstaller().getUpgradeBehavior()) {
            props.set(KEY_WINGET_UPGRADE_BEHAVIOR, packager.getInstaller().getUpgradeBehavior().formatted());
        }
        props.set(KEY_WINGET_RELEASE_DATE, new SimpleDateFormat("yyyy-MM-dd").format(new Date()));

        props.set(KEY_WINGET_INSTALLER_ARCHITECTURE, resolveArchitecture(props.get(KEY_DISTRIBUTION_ARTIFACT_PLATFORM)));

        props.set(KEY_WINGET_HAS_DEPENDENCIES, packager.getInstaller().getDependencies().hasDependencies());
        props.set(KEY_WINGET_HAS_WINDOWS_FEATURES, packager.getInstaller().getDependencies().hasWindowsFeatures());
        props.set(KEY_WINGET_HAS_WINDOWS_LIBRARIES, packager.getInstaller().getDependencies().hasWindowsLibraries());
        props.set(KEY_WINGET_HAS_EXTERNAL_DEPENDENCIES, packager.getInstaller().getDependencies().hasExternalDependencies());
        props.set(KEY_WINGET_HAS_PACKAGE_DEPENDENCIES, packager.getInstaller().getDependencies().hasPackageDependencies());
        props.set(KEY_WINGET_WINDOWS_FEATURES, packager.getInstaller().getDependencies().getWindowsFeatures());
        props.set(KEY_WINGET_WINDOWS_LIBRARIES, packager.getInstaller().getDependencies().getWindowsLibraries());
        props.set(KEY_WINGET_EXTERNAL_DEPENDENCIES, packager.getInstaller().getDependencies().getExternalDependencies());
        props.set(KEY_WINGET_PACKAGE_DEPENDENCIES, packager.getInstaller().getDependencies().getPackageDependencies());

        if (distribution.getType() == org.jreleaser.model.Distribution.DistributionType.JLINK) {
            List<Installer> installers = new ArrayList<>();
            for (Artifact artifact : collectArtifacts(distribution)) {
                if (!artifact.getPath().endsWith(ZIP.extension()) || isBlank(artifact.getPlatform())) {
                    continue;
                }

                String artifactFile = artifact.getEffectivePath().getFileName().toString();
                String architecture = resolveArchitecture(artifact.getPlatform());
                String url = resolveArtifactUrl(distribution, artifact);
                String fileName = getFilename(artifactFile, FileType.getSupportedExtensions());
                String checksum = artifact.getHash(Algorithm.SHA_256);
                String executableName = distribution.getExecutable().getName();
                String executablePath = fileName + "\\bin\\" + executableName + distribution.getExecutable().resolveWindowsExtension();

                installers.add(new Installer()
                    .withArchitecture(architecture)
                    .withUrl(url)
                    .withChecksum(checksum)
                    .withExecutablePath(executablePath)
                    .withExecutableName(executableName));
            }
            props.set(KEY_WINGET_INSTALLERS, installers);
        }
    }

    @Override
    protected String applyTemplate(String fileName, Reader reader, TemplateContext props) {
        fileName = trimTplExtension(fileName);
        if ("locale.yaml".equals(fileName)) {
            props.set(KEY_WINGET_MANIFEST_TYPE, "defaultLocale");
            props.set(KEY_WINGET_PACKAGE_LOCALE, packager.getDefaultLocale());
        } else if (fileName.startsWith("locale.")) {
            String locale = fileName.substring(7);
            locale = locale.substring(0, locale.length() - 5);
            props.set(KEY_WINGET_MANIFEST_TYPE, "locale");
            props.set(KEY_WINGET_PACKAGE_LOCALE, locale);
        }
        return super.applyTemplate(fileName, reader, props);
    }

    @Override
    protected void writeFile(Distribution distribution,
                             String content,
                             TemplateContext props,
                             Path outputDirectory,
                             String fileName) throws PackagerProcessingException {
        fileName = trimTplExtension(fileName);

        String packageIdentifier = getPackager().getPackage().getIdentifier();

        if ("version.yaml".equals(fileName)) {
            fileName = packageIdentifier + ".yaml";
            outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);
        } else if ("installer.yaml".equals(fileName)) {
            fileName = packageIdentifier + ".installer.yaml";
            outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);
        } else if ("locale.yaml".equals(fileName)) {
            fileName = packageIdentifier + ".locale." + getPackager().getDefaultLocale() + ".yaml";
            outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);
        } else if (fileName.startsWith("locale") && fileName.endsWith(".yaml")) {
            fileName = packageIdentifier + "." + fileName;
            outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);
        }

        Path outputFile = outputDirectory.resolve(fileName);
        writeFile(content, outputFile);
    }

    private Path resolvePackageDirectory(Path outputDirectory, String packageIdentifier) {
        return outputDirectory.resolve("manifests/" + packageIdentifier.substring(0, 1).toLowerCase(Locale.ENGLISH) + "/" +
            packageIdentifier.replace(".", "/") + "/" +
            context.getModel().getProject().getResolvedVersion());
    }

    private String resolveArchitecture(String platform) {
        if (PlatformUtils.isIntel32(platform)) {
            return "x86";
        } else if (PlatformUtils.isIntel64(platform)) {
            return "x64";
        } else if (PlatformUtils.isArm32(platform)) {
            return "arm";
        } else if (PlatformUtils.isArm64(platform)) {
            return "arm64";
        }
        return "neutral";
    }

    private String resolveArtifactUrl(Distribution distribution, Artifact artifact) {
        return Artifacts.resolveDownloadUrl(context, org.jreleaser.model.api.packagers.WingetPackager.TYPE, distribution, artifact);
    }

    public static class Installer {
        private String architecture;
        private String url;
        private String checksum;
        private String executablePath;
        private String executableName;

        public String getArchitecture() {
            return architecture;
        }

        public Installer withArchitecture(String architecture) {
            this.architecture = architecture;
            return this;
        }

        public String getUrl() {
            return url;
        }

        public Installer withUrl(String url) {
            this.url = url;
            return this;
        }

        public String getChecksum() {
            return checksum;
        }

        public Installer withChecksum(String checksum) {
            this.checksum = checksum;
            return this;
        }

        public String getExecutablePath() {
            return executablePath;
        }

        public Installer withExecutablePath(String executablePath) {
            this.executablePath = executablePath;
            return this;
        }

        public String getExecutableName() {
            return executableName;
        }

        public Installer withExecutableName(String executableName) {
            this.executableName = executableName;
            return this;
        }
    }
}

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.packagers;
19
20	import org.jreleaser.model.internal.JReleaserContext;
21	import org.jreleaser.model.internal.common.Artifact;
22	import org.jreleaser.model.internal.distributions.Distribution;
23	import org.jreleaser.model.internal.packagers.WingetPackager;
24	import org.jreleaser.model.internal.util.Artifacts;
25	import org.jreleaser.model.spi.packagers.PackagerProcessingException;
26	import org.jreleaser.mustache.MustacheUtils;
27	import org.jreleaser.mustache.TemplateContext;
28	import org.jreleaser.util.Algorithm;
29	import org.jreleaser.util.FileType;
30	import org.jreleaser.util.PlatformUtils;
31
32	import java.io.Reader;
33	import java.nio.file.Path;
34	import java.text.SimpleDateFormat;
35	import java.util.ArrayList;
36	import java.util.Arrays;
37	import java.util.Date;
38	import java.util.List;
39	import java.util.Locale;
40	import java.util.stream.Collectors;
41
42	import static java.util.stream.Collectors.toList;
43	import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_ARTIFACT_PLATFORM;
44	import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_CLASS;
45	import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_MODULE;
46	import static org.jreleaser.model.Constants.KEY_PROJECT_LONG_DESCRIPTION;
47	import static org.jreleaser.model.Constants.KEY_WINGET_AUTHOR;
48	import static org.jreleaser.model.Constants.KEY_WINGET_DEFAULT_LOCALE;
49	import static org.jreleaser.model.Constants.KEY_WINGET_EXTERNAL_DEPENDENCIES;
50	import static org.jreleaser.model.Constants.KEY_WINGET_HAS_DEPENDENCIES;
51	import static org.jreleaser.model.Constants.KEY_WINGET_HAS_EXTERNAL_DEPENDENCIES;
52	import static org.jreleaser.model.Constants.KEY_WINGET_HAS_PACKAGE_DEPENDENCIES;
53	import static org.jreleaser.model.Constants.KEY_WINGET_HAS_TAGS;
54	import static org.jreleaser.model.Constants.KEY_WINGET_HAS_WINDOWS_FEATURES;
55	import static org.jreleaser.model.Constants.KEY_WINGET_HAS_WINDOWS_LIBRARIES;
56	import static org.jreleaser.model.Constants.KEY_WINGET_INSTALLERS;
57	import static org.jreleaser.model.Constants.KEY_WINGET_INSTALLER_ARCHITECTURE;
58	import static org.jreleaser.model.Constants.KEY_WINGET_INSTALLER_TYPE;
59	import static org.jreleaser.model.Constants.KEY_WINGET_INSTALL_MODES;
60	import static org.jreleaser.model.Constants.KEY_WINGET_MANIFEST_TYPE;
61	import static org.jreleaser.model.Constants.KEY_WINGET_MINIMUM_OS_VERSION;
62	import static org.jreleaser.model.Constants.KEY_WINGET_MONIKER;
63	import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_DEPENDENCIES;
64	import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_IDENTIFIER;
65	import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_LOCALE;
66	import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_NAME;
67	import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_URL;
68	import static org.jreleaser.model.Constants.KEY_WINGET_PACKAGE_VERSION;
69	import static org.jreleaser.model.Constants.KEY_WINGET_PRODUCT_CODE;
70	import static org.jreleaser.model.Constants.KEY_WINGET_PUBLISHER_NAME;
71	import static org.jreleaser.model.Constants.KEY_WINGET_PUBLISHER_SUPPORT_URL;
72	import static org.jreleaser.model.Constants.KEY_WINGET_PUBLISHER_URL;
73	import static org.jreleaser.model.Constants.KEY_WINGET_RELEASE_DATE;
74	import static org.jreleaser.model.Constants.KEY_WINGET_SCOPE;
75	import static org.jreleaser.model.Constants.KEY_WINGET_TAGS;
76	import static org.jreleaser.model.Constants.KEY_WINGET_UPGRADE_BEHAVIOR;
77	import static org.jreleaser.model.Constants.KEY_WINGET_WINDOWS_FEATURES;
78	import static org.jreleaser.model.Constants.KEY_WINGET_WINDOWS_LIBRARIES;
79	import static org.jreleaser.mustache.Templates.resolveTemplate;
80	import static org.jreleaser.templates.TemplateUtils.trimTplExtension;
81	import static org.jreleaser.util.FileType.ZIP;
82	import static org.jreleaser.util.StringUtils.getFilename;
83	import static org.jreleaser.util.StringUtils.isBlank;
84
85	/**
86	* @author Andres Almiray
87	* @since 1.5.0
88	*/
89	public class WingetPackagerProcessor extends AbstractRepositoryPackagerProcessor<WingetPackager> {
90	public WingetPackagerProcessor(JReleaserContext context) {
91	super(context);	1✔
92	}	1✔
93
94	@Override
95	protected void doPackageDistribution(Distribution distribution, TemplateContext props, Path packageDirectory) throws PackagerProcessingException {
96	super.doPackageDistribution(distribution, props, packageDirectory);	×
97	copyPreparedFiles(props);	×
98	}	×
99
100	@Override
101	protected void fillPackagerProperties(TemplateContext props, Distribution distribution) {
102	props.set(KEY_DISTRIBUTION_JAVA_MAIN_CLASS, distribution.getJava().getMainClass());	×
103	props.set(KEY_DISTRIBUTION_JAVA_MAIN_MODULE, distribution.getJava().getMainModule());	×
104	String desc = context.getModel().getProject().getLongDescription();	×
105	desc = Arrays.stream(desc.split(System.lineSeparator()))	×
106	.map(line -> " " + line)	×
107	.collect(Collectors.joining(System.lineSeparator()));	×
108	props.set(KEY_PROJECT_LONG_DESCRIPTION,	×
109	MustacheUtils.passThrough("\|" + System.lineSeparator() + desc));	×
110
111	props.set(KEY_WINGET_DEFAULT_LOCALE, packager.getDefaultLocale());	×
112	props.set(KEY_WINGET_AUTHOR, packager.getAuthor());	×
NEW 113	props.set(KEY_WINGET_MONIKER, resolveTemplate(context.getLogger(), packager.getMoniker(), props));	×
114	props.set(KEY_WINGET_MINIMUM_OS_VERSION, packager.getMinimumOsVersion());	×
NEW 115	props.set(KEY_WINGET_PRODUCT_CODE, resolveTemplate(context.getLogger(), packager.getProductCode(), props));	×
116	props.set(KEY_WINGET_HAS_TAGS, !packager.getTags().isEmpty());	×
117	props.set(KEY_WINGET_TAGS, packager.getTags());	×
NEW 118	props.set(KEY_WINGET_PACKAGE_IDENTIFIER, resolveTemplate(context.getLogger(), packager.getPackage().getIdentifier(), props));	×
NEW 119	props.set(KEY_WINGET_PACKAGE_NAME, resolveTemplate(context.getLogger(), packager.getPackage().getName(), props));	×
NEW 120	props.set(KEY_WINGET_PACKAGE_VERSION, resolveTemplate(context.getLogger(), packager.getPackage().getVersion(), props));	×
NEW 121	props.set(KEY_WINGET_PACKAGE_URL, resolveTemplate(context.getLogger(), packager.getPackage().getUrl(), props));	×
NEW 122	props.set(KEY_WINGET_PUBLISHER_NAME, resolveTemplate(context.getLogger(), packager.getPublisher().getName(), props));	×
NEW 123	props.set(KEY_WINGET_PUBLISHER_URL, resolveTemplate(context.getLogger(), packager.getPublisher().getUrl(), props));	×
NEW 124	props.set(KEY_WINGET_PUBLISHER_SUPPORT_URL, resolveTemplate(context.getLogger(), packager.getPublisher().getSupportUrl(), props));	×
125	props.set(KEY_WINGET_INSTALLER_TYPE, packager.getInstaller().getType().formatted());	×
126	if (null != packager.getInstaller().getScope()) {	×
127	props.set(KEY_WINGET_SCOPE, packager.getInstaller().getScope().formatted());	×
128	}
129	props.set(KEY_WINGET_INSTALL_MODES, packager.getInstaller().getModes().stream()	×
130	.map(org.jreleaser.model.api.packagers.WingetPackager.Installer.Mode::formatted)	×
131	.collect(toList()));	×
132	if (null != packager.getInstaller().getUpgradeBehavior()) {	×
133	props.set(KEY_WINGET_UPGRADE_BEHAVIOR, packager.getInstaller().getUpgradeBehavior().formatted());	×
134	}
135	props.set(KEY_WINGET_RELEASE_DATE, new SimpleDateFormat("yyyy-MM-dd").format(new Date()));	×
136
137	props.set(KEY_WINGET_INSTALLER_ARCHITECTURE, resolveArchitecture(props.get(KEY_DISTRIBUTION_ARTIFACT_PLATFORM)));	×
138
139	props.set(KEY_WINGET_HAS_DEPENDENCIES, packager.getInstaller().getDependencies().hasDependencies());	×
140	props.set(KEY_WINGET_HAS_WINDOWS_FEATURES, packager.getInstaller().getDependencies().hasWindowsFeatures());	×
141	props.set(KEY_WINGET_HAS_WINDOWS_LIBRARIES, packager.getInstaller().getDependencies().hasWindowsLibraries());	×
142	props.set(KEY_WINGET_HAS_EXTERNAL_DEPENDENCIES, packager.getInstaller().getDependencies().hasExternalDependencies());	×
143	props.set(KEY_WINGET_HAS_PACKAGE_DEPENDENCIES, packager.getInstaller().getDependencies().hasPackageDependencies());	×
144	props.set(KEY_WINGET_WINDOWS_FEATURES, packager.getInstaller().getDependencies().getWindowsFeatures());	×
145	props.set(KEY_WINGET_WINDOWS_LIBRARIES, packager.getInstaller().getDependencies().getWindowsLibraries());	×
146	props.set(KEY_WINGET_EXTERNAL_DEPENDENCIES, packager.getInstaller().getDependencies().getExternalDependencies());	×
147	props.set(KEY_WINGET_PACKAGE_DEPENDENCIES, packager.getInstaller().getDependencies().getPackageDependencies());	×
148
149	if (distribution.getType() == org.jreleaser.model.Distribution.DistributionType.JLINK) {	×
150	List<Installer> installers = new ArrayList<>();	×
151	for (Artifact artifact : collectArtifacts(distribution)) {	×
152	if (!artifact.getPath().endsWith(ZIP.extension()) \|\| isBlank(artifact.getPlatform())) {	×
153	continue;	×
154	}
155
156	String artifactFile = artifact.getEffectivePath().getFileName().toString();	×
157	String architecture = resolveArchitecture(artifact.getPlatform());	×
158	String url = resolveArtifactUrl(distribution, artifact);	×
159	String fileName = getFilename(artifactFile, FileType.getSupportedExtensions());	×
160	String checksum = artifact.getHash(Algorithm.SHA_256);	×
161	String executableName = distribution.getExecutable().getName();	×
162	String executablePath = fileName + "\\bin\\" + executableName + distribution.getExecutable().resolveWindowsExtension();	×
163
164	installers.add(new Installer()	×
165	.withArchitecture(architecture)	×
166	.withUrl(url)	×
167	.withChecksum(checksum)	×
168	.withExecutablePath(executablePath)	×
169	.withExecutableName(executableName));	×
170	}	×
171	props.set(KEY_WINGET_INSTALLERS, installers);	×
172	}
173	}	×
174
175	@Override
176	protected String applyTemplate(String fileName, Reader reader, TemplateContext props) {
177	fileName = trimTplExtension(fileName);	×
178	if ("locale.yaml".equals(fileName)) {	×
179	props.set(KEY_WINGET_MANIFEST_TYPE, "defaultLocale");	×
180	props.set(KEY_WINGET_PACKAGE_LOCALE, packager.getDefaultLocale());	×
181	} else if (fileName.startsWith("locale.")) {	×
182	String locale = fileName.substring(7);	×
183	locale = locale.substring(0, locale.length() - 5);	×
184	props.set(KEY_WINGET_MANIFEST_TYPE, "locale");	×
185	props.set(KEY_WINGET_PACKAGE_LOCALE, locale);	×
186	}
187	return super.applyTemplate(fileName, reader, props);	×
188	}
189
190	@Override
191	protected void writeFile(Distribution distribution,
192	String content,
193	TemplateContext props,
194	Path outputDirectory,
195	String fileName) throws PackagerProcessingException {
196	fileName = trimTplExtension(fileName);	×
197
198	String packageIdentifier = getPackager().getPackage().getIdentifier();	×
199
200	if ("version.yaml".equals(fileName)) {	×
201	fileName = packageIdentifier + ".yaml";	×
202	outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);	×
203	} else if ("installer.yaml".equals(fileName)) {	×
204	fileName = packageIdentifier + ".installer.yaml";	×
205	outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);	×
206	} else if ("locale.yaml".equals(fileName)) {	×
207	fileName = packageIdentifier + ".locale." + getPackager().getDefaultLocale() + ".yaml";	×
208	outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);	×
209	} else if (fileName.startsWith("locale") && fileName.endsWith(".yaml")) {	×
210	fileName = packageIdentifier + "." + fileName;	×
211	outputDirectory = resolvePackageDirectory(outputDirectory, packageIdentifier);	×
212	}
213
214	Path outputFile = outputDirectory.resolve(fileName);	×
215	writeFile(content, outputFile);	×
216	}	×
217
218	private Path resolvePackageDirectory(Path outputDirectory, String packageIdentifier) {
219	return outputDirectory.resolve("manifests/" + packageIdentifier.substring(0, 1).toLowerCase(Locale.ENGLISH) + "/" +	×
220	packageIdentifier.replace(".", "/") + "/" +	×
221	context.getModel().getProject().getResolvedVersion());	×
222	}
223
224	private String resolveArchitecture(String platform) {
225	if (PlatformUtils.isIntel32(platform)) {	×
226	return "x86";	×
227	} else if (PlatformUtils.isIntel64(platform)) {	×
228	return "x64";	×
229	} else if (PlatformUtils.isArm32(platform)) {	×
230	return "arm";	×
231	} else if (PlatformUtils.isArm64(platform)) {	×
232	return "arm64";	×
233	}
234	return "neutral";	×
235	}
236
237	private String resolveArtifactUrl(Distribution distribution, Artifact artifact) {
238	return Artifacts.resolveDownloadUrl(context, org.jreleaser.model.api.packagers.WingetPackager.TYPE, distribution, artifact);	×
239	}
240
241	public static class Installer {	×
242	private String architecture;
243	private String url;
244	private String checksum;
245	private String executablePath;
246	private String executableName;
247
248	public String getArchitecture() {
249	return architecture;	×
250	}
251
252	public Installer withArchitecture(String architecture) {
253	this.architecture = architecture;	×
254	return this;	×
255	}
256
257	public String getUrl() {
258	return url;	×
259	}
260
261	public Installer withUrl(String url) {
262	this.url = url;	×
263	return this;	×
264	}
265
266	public String getChecksum() {
267	return checksum;	×
268	}
269
270	public Installer withChecksum(String checksum) {
271	this.checksum = checksum;	×
272	return this;	×
273	}
274
275	public String getExecutablePath() {
276	return executablePath;	×
277	}
278
279	public Installer withExecutablePath(String executablePath) {
280	this.executablePath = executablePath;	×
281	return this;	×
282	}
283
284	public String getExecutableName() {
285	return executableName;	×
286	}
287
288	public Installer withExecutableName(String executableName) {
289	this.executableName = executableName;	×
290	return this;	×
291	}
292	}
293	}

jreleaser / jreleaser / #558

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