#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

2.6

/core/jreleaser-engine/src/main/java/org/jreleaser/packagers/JbangPackagerProcessor.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 com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.jreleaser.model.internal.JReleaserContext;
import org.jreleaser.model.internal.distributions.Distribution;
import org.jreleaser.model.internal.packagers.JbangPackager;
import org.jreleaser.model.internal.release.BaseReleaser;
import org.jreleaser.model.spi.packagers.PackagerProcessingException;
import org.jreleaser.mustache.TemplateContext;
import org.jreleaser.util.JsonUtils;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.jreleaser.model.Constants.KEY_JBANG_ALIAS_NAME;
import static org.jreleaser.model.Constants.KEY_JBANG_CATALOG_REPO_CLONE_URL;
import static org.jreleaser.model.Constants.KEY_JBANG_CATALOG_REPO_URL;
import static org.jreleaser.model.Constants.KEY_JBANG_DISTRIBUTION_GA;
import static org.jreleaser.model.Constants.KEY_JBANG_REPOSITORY_CLONE_URL;
import static org.jreleaser.model.Constants.KEY_JBANG_REPOSITORY_URL;
import static org.jreleaser.model.Constants.KEY_JBANG_SCRIPT_NAME;
import static org.jreleaser.model.Constants.KEY_REVERSE_DOMAIN;
import static org.jreleaser.model.Constants.KEY_REVERSE_REPO_HOST;
import static org.jreleaser.templates.TemplateUtils.trimTplExtension;
import static org.jreleaser.util.StringUtils.isBlank;

/**
 * @author Andres Almiray
 * @since 0.1.0
 */
public class JbangPackagerProcessor extends AbstractRepositoryPackagerProcessor<JbangPackager> {
    public JbangPackagerProcessor(JReleaserContext context) {
        super(context);
    }

    @Override
    public boolean supportsDistribution(Distribution distribution) {
        return distribution.getType() != org.jreleaser.model.Distribution.DistributionType.JLINK;
    }

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

    @Override
    protected boolean verifyAndAddArtifacts(TemplateContext props, Distribution distribution) {
        return true;
    }

    @Override
    protected void fillPackagerProperties(TemplateContext props, Distribution distribution) {
        BaseReleaser<?, ?> releaser = context.getModel().getRelease().getReleaser();

        props.set(KEY_JBANG_CATALOG_REPO_URL,
            releaser.getResolvedRepoUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));
        props.set(KEY_JBANG_CATALOG_REPO_CLONE_URL,
            releaser.getResolvedRepoCloneUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));

        props.set(KEY_JBANG_REPOSITORY_URL,
            releaser.getResolvedRepoUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));
        props.set(KEY_JBANG_REPOSITORY_CLONE_URL,
            releaser.getResolvedRepoCloneUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));

        String aliasName = sanitizeAlias(packager.getAlias());
        String scriptName = aliasName;
        if (context.getModel().getProject().isSnapshot()) {
            aliasName += "-snapshot";
            scriptName += "_snapshot";
        }
        scriptName = sanitizeScriptName(scriptName);

        props.set(KEY_JBANG_ALIAS_NAME, aliasName);
        props.set(KEY_JBANG_SCRIPT_NAME, scriptName);

        String jbangDistributionGA = (String) packager.resolvedExtraProperties().get(KEY_JBANG_DISTRIBUTION_GA);
        if (isBlank(jbangDistributionGA)) {
            if (context.getModel().getProject().isSnapshot()) {
                // if single
                // {{reverseRepoHost}}.{{repoOwner}}:{{distributionArtifactId}}
                // if multi-project
                // {{reverseRepoHost}}.{{repoOwner}}.{{repoName}}:{{distributionArtifactId}}

                String reverseRepoHost = releaser.getReverseRepoHost();
                if (packager.getExtraProperties().containsKey(KEY_REVERSE_DOMAIN)) {
                    reverseRepoHost = (String) packager.getExtraProperties().get(KEY_REVERSE_DOMAIN);
                } else if (isBlank(reverseRepoHost)) {
                    reverseRepoHost = (String) packager.getExtraProperties().get(KEY_REVERSE_REPO_HOST);
                }

                StringBuilder b = new StringBuilder(reverseRepoHost)
                    .append(".")
                    .append(releaser.getOwner());
                if (distribution.getJava().isMultiProject()) {
                    b.append(".")
                        .append(releaser.getName());
                }
                b.append(":")
                    .append(distribution.getJava().getArtifactId());

                jbangDistributionGA = b.toString();
            } else {
                jbangDistributionGA = distribution.getJava().getGroupId() +
                    ":" +
                    distribution.getJava().getArtifactId();
            }
        }
        props.set(KEY_JBANG_DISTRIBUTION_GA, jbangDistributionGA);
    }

    private String sanitizeAlias(String alias) {
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < alias.length(); i++) {
            char ch = alias.charAt(i);
            if (Character.isJavaIdentifierPart(ch) || ch == '-') {
                b.append(ch);
            }
        }
        return b.toString();
    }

    private String sanitizeScriptName(String scriptName) {
        scriptName = scriptName.replace("-", "_");
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < scriptName.length(); i++) {
            char ch = scriptName.charAt(i);
            if (Character.isJavaIdentifierPart(ch)) {
                b.append(ch);
            }
        }
        return b.toString();
    }

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

        String scriptName = props.get(KEY_JBANG_SCRIPT_NAME);
        Path outputFile = "jbang.java".equals(fileName) ?
            outputDirectory.resolve(scriptName.concat(".java")) :
            outputDirectory.resolve(fileName);

        writeFile(content, outputFile);
    }

    @Override
    protected void prepareWorkingCopy(TemplateContext props, Path directory, Distribution distribution) throws IOException {
        Path catalog = directory.resolve("jbang-catalog.json");

        if (catalog.toFile().exists()) {
            // read previous catalog
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode previous = objectMapper.readTree(Files.readAllBytes(catalog));

            // copy all files
            super.prepareWorkingCopy(props, directory, distribution);

            // read current catalog
            JsonNode current = objectMapper.readTree(Files.readAllBytes(catalog));

            // merge catalogs
            JsonNode merged = JsonUtils.merge(previous, current);

            // write merged catalog
            Files.write(catalog, merged.toPrettyString().getBytes(UTF_8));
        } else {
            // copy all files
            super.prepareWorkingCopy(props, directory, distribution);
        }
    }
}

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 com.fasterxml.jackson.databind.JsonNode;
21	import com.fasterxml.jackson.databind.ObjectMapper;
22	import org.jreleaser.model.internal.JReleaserContext;
23	import org.jreleaser.model.internal.distributions.Distribution;
24	import org.jreleaser.model.internal.packagers.JbangPackager;
25	import org.jreleaser.model.internal.release.BaseReleaser;
26	import org.jreleaser.model.spi.packagers.PackagerProcessingException;
27	import org.jreleaser.mustache.TemplateContext;
28	import org.jreleaser.util.JsonUtils;
29
30	import java.io.IOException;
31	import java.nio.file.Files;
32	import java.nio.file.Path;
33
34	import static java.nio.charset.StandardCharsets.UTF_8;
35	import static org.jreleaser.model.Constants.KEY_JBANG_ALIAS_NAME;
36	import static org.jreleaser.model.Constants.KEY_JBANG_CATALOG_REPO_CLONE_URL;
37	import static org.jreleaser.model.Constants.KEY_JBANG_CATALOG_REPO_URL;
38	import static org.jreleaser.model.Constants.KEY_JBANG_DISTRIBUTION_GA;
39	import static org.jreleaser.model.Constants.KEY_JBANG_REPOSITORY_CLONE_URL;
40	import static org.jreleaser.model.Constants.KEY_JBANG_REPOSITORY_URL;
41	import static org.jreleaser.model.Constants.KEY_JBANG_SCRIPT_NAME;
42	import static org.jreleaser.model.Constants.KEY_REVERSE_DOMAIN;
43	import static org.jreleaser.model.Constants.KEY_REVERSE_REPO_HOST;
44	import static org.jreleaser.templates.TemplateUtils.trimTplExtension;
45	import static org.jreleaser.util.StringUtils.isBlank;
46
47	/**
48	* @author Andres Almiray
49	* @since 0.1.0
50	*/
51	public class JbangPackagerProcessor extends AbstractRepositoryPackagerProcessor<JbangPackager> {
52	public JbangPackagerProcessor(JReleaserContext context) {
53	super(context);	1✔
54	}	1✔
55
56	@Override
57	public boolean supportsDistribution(Distribution distribution) {
58	return distribution.getType() != org.jreleaser.model.Distribution.DistributionType.JLINK;	×
59	}
60
61	@Override
62	protected void doPackageDistribution(Distribution distribution, TemplateContext props, Path packageDirectory) throws PackagerProcessingException {
63	super.doPackageDistribution(distribution, props, packageDirectory);	×
64	copyPreparedFiles(props);	×
65	}	×
66
67	@Override
68	protected boolean verifyAndAddArtifacts(TemplateContext props, Distribution distribution) {
69	return true;	×
70	}
71
72	@Override
73	protected void fillPackagerProperties(TemplateContext props, Distribution distribution) {
74	BaseReleaser<?, ?> releaser = context.getModel().getRelease().getReleaser();	×
75
76	props.set(KEY_JBANG_CATALOG_REPO_URL,	×
NEW 77	releaser.getResolvedRepoUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));	×
78	props.set(KEY_JBANG_CATALOG_REPO_CLONE_URL,	×
NEW 79	releaser.getResolvedRepoCloneUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));	×
80
81	props.set(KEY_JBANG_REPOSITORY_URL,	×
NEW 82	releaser.getResolvedRepoUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));	×
83	props.set(KEY_JBANG_REPOSITORY_CLONE_URL,	×
NEW 84	releaser.getResolvedRepoCloneUrl(context, packager.getRepository().getOwner(), packager.getRepository().getResolvedName()));	×
85
86	String aliasName = sanitizeAlias(packager.getAlias());	×
87	String scriptName = aliasName;	×
88	if (context.getModel().getProject().isSnapshot()) {	×
89	aliasName += "-snapshot";	×
90	scriptName += "_snapshot";	×
91	}
92	scriptName = sanitizeScriptName(scriptName);	×
93
94	props.set(KEY_JBANG_ALIAS_NAME, aliasName);	×
95	props.set(KEY_JBANG_SCRIPT_NAME, scriptName);	×
96
97	String jbangDistributionGA = (String) packager.resolvedExtraProperties().get(KEY_JBANG_DISTRIBUTION_GA);	×
98	if (isBlank(jbangDistributionGA)) {	×
99	if (context.getModel().getProject().isSnapshot()) {	×
100	// if single
101	// {{reverseRepoHost}}.{{repoOwner}}:{{distributionArtifactId}}
102	// if multi-project
103	// {{reverseRepoHost}}.{{repoOwner}}.{{repoName}}:{{distributionArtifactId}}
104
105	String reverseRepoHost = releaser.getReverseRepoHost();	×
106	if (packager.getExtraProperties().containsKey(KEY_REVERSE_DOMAIN)) {	×
107	reverseRepoHost = (String) packager.getExtraProperties().get(KEY_REVERSE_DOMAIN);	×
108	} else if (isBlank(reverseRepoHost)) {	×
109	reverseRepoHost = (String) packager.getExtraProperties().get(KEY_REVERSE_REPO_HOST);	×
110	}
111
112	StringBuilder b = new StringBuilder(reverseRepoHost)	×
113	.append(".")	×
114	.append(releaser.getOwner());	×
115	if (distribution.getJava().isMultiProject()) {	×
116	b.append(".")	×
117	.append(releaser.getName());	×
118	}
119	b.append(":")	×
120	.append(distribution.getJava().getArtifactId());	×
121
122	jbangDistributionGA = b.toString();	×
123	} else {	×
124	jbangDistributionGA = distribution.getJava().getGroupId() +	×
125	":" +
126	distribution.getJava().getArtifactId();	×
127	}
128	}
129	props.set(KEY_JBANG_DISTRIBUTION_GA, jbangDistributionGA);	×
130	}	×
131
132	private String sanitizeAlias(String alias) {
133	StringBuilder b = new StringBuilder();	×
134	for (int i = 0; i < alias.length(); i++) {	×
135	char ch = alias.charAt(i);	×
136	if (Character.isJavaIdentifierPart(ch) \|\| ch == '-') {	×
137	b.append(ch);	×
138	}
139	}
140	return b.toString();	×
141	}
142
143	private String sanitizeScriptName(String scriptName) {
144	scriptName = scriptName.replace("-", "_");	×
145	StringBuilder b = new StringBuilder();	×
146	for (int i = 0; i < scriptName.length(); i++) {	×
147	char ch = scriptName.charAt(i);	×
148	if (Character.isJavaIdentifierPart(ch)) {	×
149	b.append(ch);	×
150	}
151	}
152	return b.toString();	×
153	}
154
155	@Override
156	protected void writeFile(Distribution distribution,
157	String content,
158	TemplateContext props,
159	Path outputDirectory,
160	String fileName)
161	throws PackagerProcessingException {
162	fileName = trimTplExtension(fileName);	×
163
164	String scriptName = props.get(KEY_JBANG_SCRIPT_NAME);	×
165	Path outputFile = "jbang.java".equals(fileName) ?	×
166	outputDirectory.resolve(scriptName.concat(".java")) :	×
167	outputDirectory.resolve(fileName);	×
168
169	writeFile(content, outputFile);	×
170	}	×
171
172	@Override
173	protected void prepareWorkingCopy(TemplateContext props, Path directory, Distribution distribution) throws IOException {
174	Path catalog = directory.resolve("jbang-catalog.json");	×
175
176	if (catalog.toFile().exists()) {	×
177	// read previous catalog
178	ObjectMapper objectMapper = new ObjectMapper();	×
179	JsonNode previous = objectMapper.readTree(Files.readAllBytes(catalog));	×
180
181	// copy all files
182	super.prepareWorkingCopy(props, directory, distribution);	×
183
184	// read current catalog
185	JsonNode current = objectMapper.readTree(Files.readAllBytes(catalog));	×
186
187	// merge catalogs
188	JsonNode merged = JsonUtils.merge(previous, current);	×
189
190	// write merged catalog
191	Files.write(catalog, merged.toPrettyString().getBytes(UTF_8));	×
192	} else {	×
193	// copy all files
194	super.prepareWorkingCopy(props, directory, distribution);	×
195	}
196	}	×
197	}

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