#510

Committed 27 Jul 2025 12:31PM UTC coverage: 45.783% (-3.6%) from 49.39%

Build # #510

Build Type

push

github

Committed by

aalmiray

Commit Message

feat(packagers): Stage distribution publication in a fixed directory

Closes #1943

Coverage Stats

12 of 25 new or added lines in 4 files covered. (48.0%)

2208 existing lines in 190 files now uncovered.

23924 of 52255 relevant lines covered (45.78%)

0.46 hits per line

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

46.15

/core/jreleaser-model-impl/src/main/java/org/jreleaser/model/internal/packagers/DockerSpec.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.model.internal.packagers;

import com.fasterxml.jackson.annotation.JsonIgnore;
import org.jreleaser.model.Active;
import org.jreleaser.model.internal.common.Artifact;
import org.jreleaser.model.internal.common.Domain;
import org.jreleaser.util.PlatformUtils;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static java.util.Collections.unmodifiableList;
import static java.util.Collections.unmodifiableMap;
import static java.util.Collections.unmodifiableSet;
import static java.util.stream.Collectors.toSet;
import static org.jreleaser.model.Constants.KEY_PLATFORM;
import static org.jreleaser.util.StringUtils.isNotBlank;

/**
 * @author Andres Almiray
 * @since 0.4.0
 */
public final class DockerSpec extends AbstractDockerConfiguration<DockerSpec> implements Domain {
    private static final long serialVersionUID = 5373884037924711407L;

    private final Map<String, Object> matchers = new LinkedHashMap<>();
    private Artifact artifact;
    private String name;

    @JsonIgnore
    private final org.jreleaser.model.api.packagers.DockerSpec immutable = new org.jreleaser.model.api.packagers.DockerSpec() {
        private static final long serialVersionUID = 989266321689529110L;

        private Set<? extends org.jreleaser.model.api.packagers.DockerPackager.Registry> registries;

        @Override
        public org.jreleaser.model.api.common.Artifact getArtifact() {
            return artifact.asImmutable();
        }

        @Override
        public String getName() {
            return name;
        }

        @Override
        public Map<String, Object> getMatchers() {
            return unmodifiableMap(matchers);
        }

        @Override
        public String getTemplateDirectory() {
            return DockerSpec.this.getTemplateDirectory();
        }

        @Override
        public List<String> getSkipTemplates() {
            return unmodifiableList(DockerSpec.this.getSkipTemplates());
        }

        @Override
        public String getBaseImage() {
            return DockerSpec.this.getBaseImage();
        }

        @Override
        public String getEntrypoint() {
            return DockerSpec.this.getEntrypoint();
        }

        @Override
        public String getCmd() {
            return DockerSpec.this.getCmd();
        }

        @Override
        public Map<String, String> getLabels() {
            return unmodifiableMap(DockerSpec.this.getLabels());
        }

        @Override
        public Set<String> getImageNames() {
            return unmodifiableSet(DockerSpec.this.getImageNames());
        }

        @Override
        public List<String> getBuildArgs() {
            return unmodifiableList(DockerSpec.this.getBuildArgs());
        }

        @Override
        public List<String> getPreCommands() {
            return unmodifiableList(DockerSpec.this.getPreCommands());
        }

        @Override
        public List<String> getPostCommands() {
            return unmodifiableList(DockerSpec.this.getPostCommands());
        }

        @Override
        public Set<? extends org.jreleaser.model.api.packagers.DockerPackager.Registry> getRegistries() {
            if (null == registries) {
                registries = DockerSpec.this.getRegistries().stream()
                    .map(DockerConfiguration.Registry::asImmutable)
                    .collect(toSet());
            }
            return registries;
        }

        @Override
        public boolean isUseLocalArtifact() {
            return DockerSpec.this.isUseLocalArtifact();
        }

        @Override
        public Active getActive() {
            return DockerSpec.this.getActive();
        }

        @Override
        public boolean isEnabled() {
            return DockerSpec.this.isEnabled();
        }

        @Override
        public Map<String, Object> asMap(boolean full) {
            return unmodifiableMap(DockerSpec.this.asMap(full));
        }

        @Override
        public String getPrefix() {
            return DockerSpec.this.prefix();
        }

        @Override
        public org.jreleaser.model.api.packagers.DockerConfiguration.DockerCommand getCommand() {
            return DockerSpec.this.getCommand();
        }

        @Override
        public Buildx getBuildx() {
            return DockerSpec.this.getBuildx().asImmutable();
        }

        @Override
        public Map<String, Object> getExtraProperties() {
            return unmodifiableMap(DockerSpec.this.getExtraProperties());
        }
    };

    public org.jreleaser.model.api.packagers.DockerSpec asImmutable() {
        return immutable;
    }

    @Override
    public void merge(DockerSpec source) {
        super.merge(source);
        this.name = merge(this.name, source.name);
        this.artifact = source.artifact;
        setMatchers(merge(this.matchers, source.matchers));
    }

    public Artifact getArtifact() {
        return artifact;
    }

    public void setArtifact(Artifact artifact) {
        this.artifact = artifact;
        this.artifact.select();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Map<String, Object> getMatchers() {
        return matchers;
    }

    public void setMatchers(Map<String, Object> matchers) {
        this.matchers.putAll(matchers);
    }

    @Override
    public Map<String, Object> asMap(boolean full) {
        Map<String, Object> props = super.asMap(full);

        if (!props.isEmpty()) {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put(name, props);
            return map;
        }

        return props;
    }

    @Override
    protected void asMap(boolean full, Map<String, Object> props) {
        props.put("matchers", matchers);
        if (null != artifact) {
            props.put("artifact", artifact.asMap(full));
        }
    }

    public boolean matches(Artifact artifact) {
        boolean matched = true;

        for (Map.Entry<String, Object> e : matchers.entrySet()) {
            String key = e.getKey();
            if (KEY_PLATFORM.equals(key)) {
                matched &= isNotBlank(artifact.getPlatform()) && PlatformUtils.isCompatible(String.valueOf(e.getValue()), artifact.getPlatform());
            } else if (artifact.getExtraProperties().containsKey(key)) {
                matched &= e.getValue().equals(artifact.getExtraProperties().get(key));
            }
        }

        return matched;
    }
}

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.model.internal.packagers;
19
20	import com.fasterxml.jackson.annotation.JsonIgnore;
21	import org.jreleaser.model.Active;
22	import org.jreleaser.model.internal.common.Artifact;
23	import org.jreleaser.model.internal.common.Domain;
24	import org.jreleaser.util.PlatformUtils;
25
26	import java.util.LinkedHashMap;
27	import java.util.List;
28	import java.util.Map;
29	import java.util.Set;
30
31	import static java.util.Collections.unmodifiableList;
32	import static java.util.Collections.unmodifiableMap;
33	import static java.util.Collections.unmodifiableSet;
34	import static java.util.stream.Collectors.toSet;
35	import static org.jreleaser.model.Constants.KEY_PLATFORM;
36	import static org.jreleaser.util.StringUtils.isNotBlank;
37
38	/**
39	* @author Andres Almiray
40	* @since 0.4.0
41	*/
42	public final class DockerSpec extends AbstractDockerConfiguration<DockerSpec> implements Domain {	1✔
43	private static final long serialVersionUID = 5373884037924711407L;
44
45	private final Map<String, Object> matchers = new LinkedHashMap<>();	1✔
46	private Artifact artifact;
47	private String name;
48
49	@JsonIgnore	1✔
50	private final org.jreleaser.model.api.packagers.DockerSpec immutable = new org.jreleaser.model.api.packagers.DockerSpec() {	1✔
51	private static final long serialVersionUID = 989266321689529110L;
52
53	private Set<? extends org.jreleaser.model.api.packagers.DockerPackager.Registry> registries;
54
55	@Override
56	public org.jreleaser.model.api.common.Artifact getArtifact() {
57	return artifact.asImmutable();	×
58	}
59
60	@Override
61	public String getName() {
62	return name;	×
63	}
64
65	@Override
66	public Map<String, Object> getMatchers() {
67	return unmodifiableMap(matchers);	×
68	}
69
70	@Override
71	public String getTemplateDirectory() {
72	return DockerSpec.this.getTemplateDirectory();	×
73	}
74
75	@Override
76	public List<String> getSkipTemplates() {
77	return unmodifiableList(DockerSpec.this.getSkipTemplates());	×
78	}
79
80	@Override
81	public String getBaseImage() {
82	return DockerSpec.this.getBaseImage();	×
83	}
84
85	@Override
86	public String getEntrypoint() {
87	return DockerSpec.this.getEntrypoint();	×
88	}
89
90	@Override
91	public String getCmd() {
92	return DockerSpec.this.getCmd();	×
93	}
94
95	@Override
96	public Map<String, String> getLabels() {
97	return unmodifiableMap(DockerSpec.this.getLabels());	×
98	}
99
100	@Override
101	public Set<String> getImageNames() {
102	return unmodifiableSet(DockerSpec.this.getImageNames());	×
103	}
104
105	@Override
106	public List<String> getBuildArgs() {
107	return unmodifiableList(DockerSpec.this.getBuildArgs());	×
108	}
109
110	@Override
111	public List<String> getPreCommands() {
112	return unmodifiableList(DockerSpec.this.getPreCommands());	×
113	}
114
115	@Override
116	public List<String> getPostCommands() {
117	return unmodifiableList(DockerSpec.this.getPostCommands());	×
118	}
119
120	@Override
121	public Set<? extends org.jreleaser.model.api.packagers.DockerPackager.Registry> getRegistries() {
122	if (null == registries) {	×
UNCOV 123	registries = DockerSpec.this.getRegistries().stream()	×
UNCOV 124	.map(DockerConfiguration.Registry::asImmutable)	×
UNCOV 125	.collect(toSet());	×
126	}
127	return registries;	×
128	}
129
130	@Override
131	public boolean isUseLocalArtifact() {
132	return DockerSpec.this.isUseLocalArtifact();	×
133	}
134
135	@Override
136	public Active getActive() {
137	return DockerSpec.this.getActive();	×
138	}
139
140	@Override
141	public boolean isEnabled() {
142	return DockerSpec.this.isEnabled();	×
143	}
144
145	@Override
146	public Map<String, Object> asMap(boolean full) {
147	return unmodifiableMap(DockerSpec.this.asMap(full));	×
148	}
149
150	@Override
151	public String getPrefix() {
152	return DockerSpec.this.prefix();	×
153	}
154
155	@Override
156	public org.jreleaser.model.api.packagers.DockerConfiguration.DockerCommand getCommand() {
157	return DockerSpec.this.getCommand();	×
158	}
159
160	@Override
161	public Buildx getBuildx() {
162	return DockerSpec.this.getBuildx().asImmutable();	×
163	}
164
165	@Override
166	public Map<String, Object> getExtraProperties() {
167	return unmodifiableMap(DockerSpec.this.getExtraProperties());	×
168	}
169	};
170
171	public org.jreleaser.model.api.packagers.DockerSpec asImmutable() {
172	return immutable;	×
173	}
174
175	@Override
176	public void merge(DockerSpec source) {
UNCOV 177	super.merge(source);	×
UNCOV 178	this.name = merge(this.name, source.name);	×
UNCOV 179	this.artifact = source.artifact;	×
UNCOV 180	setMatchers(merge(this.matchers, source.matchers));	×
UNCOV 181	}	×
182
183	public Artifact getArtifact() {
184	return artifact;	1✔
185	}
186
187	public void setArtifact(Artifact artifact) {
188	this.artifact = artifact;	1✔
189	this.artifact.select();	1✔
190	}	1✔
191
192	public String getName() {
193	return name;	1✔
194	}
195
196	public void setName(String name) {
197	this.name = name;	1✔
198	}	1✔
199
200	public Map<String, Object> getMatchers() {
201	return matchers;	1✔
202	}
203
204	public void setMatchers(Map<String, Object> matchers) {
205	this.matchers.putAll(matchers);	1✔
206	}	1✔
207
208	@Override
209	public Map<String, Object> asMap(boolean full) {
210	Map<String, Object> props = super.asMap(full);	1✔
211
212	if (!props.isEmpty()) {	1✔
213	Map<String, Object> map = new LinkedHashMap<>();	1✔
214	map.put(name, props);	1✔
215	return map;	1✔
216	}
217
UNCOV 218	return props;	×
219	}
220
221	@Override
222	protected void asMap(boolean full, Map<String, Object> props) {
223	props.put("matchers", matchers);	1✔
224	if (null != artifact) {	1✔
225	props.put("artifact", artifact.asMap(full));	1✔
226	}
227	}	1✔
228
229	public boolean matches(Artifact artifact) {
230	boolean matched = true;	1✔
231
232	for (Map.Entry<String, Object> e : matchers.entrySet()) {	1✔
233	String key = e.getKey();	1✔
234	if (KEY_PLATFORM.equals(key)) {	1✔
235	matched &= isNotBlank(artifact.getPlatform()) && PlatformUtils.isCompatible(String.valueOf(e.getValue()), artifact.getPlatform());	1✔
UNCOV 236	} else if (artifact.getExtraProperties().containsKey(key)) {	×
UNCOV 237	matched &= e.getValue().equals(artifact.getExtraProperties().get(key));	×
238	}
239	}	1✔
240
241	return matched;	1✔
242	}
243	}

jreleaser / jreleaser / #510

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