#500

Committed 30 Jun 2025 04:44PM UTC coverage: 49.36% (+0.004%) from 49.356%

Build # #500

Build Type

push

github

Committed by

aalmiray

Commit Message

fix(core): Do not display empty or blank environment vars

Fixes #1913

Coverage Stats

4 of 4 new or added lines in 2 files covered. (100.0%)

11 existing lines in 1 file now uncovered.

25731 of 52129 relevant lines covered (49.36%)

0.49 hits per line

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

82.39

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

import com.fasterxml.jackson.annotation.JsonIgnore;
import org.jreleaser.bundle.RB;
import org.jreleaser.config.JReleaserConfigLoader;
import org.jreleaser.config.JReleaserConfigParser;
import org.jreleaser.model.internal.JReleaserContext;
import org.jreleaser.model.internal.common.AbstractModelObject;
import org.jreleaser.model.internal.common.Domain;
import org.jreleaser.util.Env;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Properties;
import java.util.ServiceLoader;
import java.util.Set;
import java.util.TreeSet;

import static java.nio.file.Files.newInputStream;
import static java.util.Collections.unmodifiableMap;
import static org.jreleaser.model.Constants.DEFAULT_GIT_REMOTE;
import static org.jreleaser.model.Constants.JRELEASER_USER_HOME;
import static org.jreleaser.model.Constants.XDG_CONFIG_HOME;
import static org.jreleaser.util.Env.JRELEASER_ENV_PREFIX;
import static org.jreleaser.util.Env.JRELEASER_SYS_PREFIX;
import static org.jreleaser.util.Env.envKey;
import static org.jreleaser.util.StringUtils.getPropertyNameForLowerCaseHyphenSeparatedName;
import static org.jreleaser.util.StringUtils.isBlank;
import static org.jreleaser.util.StringUtils.isNotBlank;

/**
 * @author Andres Almiray
 * @since 0.1.0
 */
public final class Environment extends AbstractModelObject<Environment> implements Domain {
    private static final long serialVersionUID = 4554098923129885325L;

    private final Map<String, Object> properties = new LinkedHashMap<>();
    @JsonIgnore
    private final Map<String, Object> sourcedProperties = new LinkedHashMap<>();
    @JsonIgnore
    private PropertiesSource propertiesSource;
    private String variables;
    @JsonIgnore
    private Properties vars;
    @JsonIgnore
    private Path propertiesFile;

    @JsonIgnore
    private final org.jreleaser.model.api.environment.Environment immutable = new org.jreleaser.model.api.environment.Environment() {
        private static final long serialVersionUID = -7287090119869371299L;

        @Override
        public Properties getVars() {
            return vars;
        }

        @Override
        public String getVariables() {
            return variables;
        }

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

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

    public org.jreleaser.model.api.environment.Environment asImmutable() {
        return immutable;
    }

    @Override
    public void merge(Environment source) {
        this.variables = merge(this.variables, source.variables);
        setProperties(merge(this.properties, source.properties));
        setPropertiesSource(merge(this.propertiesSource, source.propertiesSource));
    }

    public String resolve(String key) {
        return env(key, Env.sys(key, ""));
    }

    public String resolve(String key, String value) {
        return env(key, Env.sys(key, value));
    }

    public String resolveOrDefault(String key, String value, String defaultValue) {
        String result = env(key, Env.sys(key, value));
        return isNotBlank(result) ? result : defaultValue;
    }

    private String env(String key, String value) {
        if (isNotBlank(value)) {
            return value;
        }
        return getVariable(envKey(key));
    }

    public Properties getVars() {
        return vars;
    }

    public String getVariable(String key) {
        return vars.getProperty(Env.envKey(key));
    }

    public boolean isSet() {
        return isNotBlank(variables) ||
            !properties.isEmpty();
    }

    public PropertiesSource getPropertiesSource() {
        return propertiesSource;
    }

    public void setPropertiesSource(PropertiesSource propertiesSource) {
        this.propertiesSource = propertiesSource;
        if (null != this.propertiesSource) {
            sourcedProperties.putAll(propertiesSource.getProperties());
        }
    }

    public String getVariables() {
        return variables;
    }

    public void setVariables(String variables) {
        this.variables = variables;
    }

    public Map<String, Object> getProperties() {
        return properties;
    }

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

    public Map<String, Object> getSourcedProperties() {
        return sourcedProperties;
    }

    public Path getPropertiesFile() {
        return propertiesFile;
    }

    @Override
    public Map<String, Object> asMap(boolean full) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("variables", variables);
        map.put("properties", properties);

        return map;
    }

    public void initProps(JReleaserContext context) {
        if (null == vars) {
            vars = new Properties();

            Path configDirectory = null;

            String home = System.getenv(XDG_CONFIG_HOME);
            if (isNotBlank(home) && Files.exists(Paths.get(home).resolve("jreleaser"))) {
                configDirectory = Paths.get(home).resolve("jreleaser");
            }

            if (null == configDirectory) {
                home = System.getenv(JRELEASER_USER_HOME);
                if (isBlank(home)) {
                    home = System.getProperty("user.home") + File.separator + ".jreleaser";
                }
                configDirectory = Paths.get(home);
            }

            loadVariables(context, resolveConfigFileAt(configDirectory)
                .orElse(configDirectory.resolve("config.properties")));

            if (isNotBlank(variables)) {
                loadVariables(context, context.getBasedir().resolve(variables.trim()));
            }

            Path envFilePath = context.getBasedir().resolve(".env");
            if (Files.exists(envFilePath)) {
                loadVariables(context, envFilePath);
            }

            // env vars
            Set<String> keyNames = new TreeSet<>();
            Properties envVars = new Properties();
            System.getenv().forEach((k, v) -> {
                if (k.startsWith(JRELEASER_ENV_PREFIX) && isNotBlank(v)) {
                    keyNames.add(k);
                    envVars.put(k, v);
                }
            });
            if (System.getenv().containsKey(envKey(DEFAULT_GIT_REMOTE))) {
                keyNames.add(envKey(DEFAULT_GIT_REMOTE));
            }
            if (!keyNames.isEmpty()) {
                context.getLogger().debug(RB.$("environment.variables.env"));
                keyNames.forEach(message -> context.getLogger().debug("  " + message));
            }

            // system props
            keyNames.clear();
            System.getProperties().stringPropertyNames().forEach(k -> {
                if (k.startsWith(JRELEASER_SYS_PREFIX)) keyNames.add(k);
            });
            if (!keyNames.isEmpty()) {
                context.getLogger().debug(RB.$("environment.system.properties"));
                keyNames.forEach(message -> context.getLogger().debug("  " + message));
            }

            // merge keyNames
            Properties merged = new Properties();
            merged.putAll(envVars);
            merged.putAll(this.vars);
            this.vars.clear();
            this.vars.putAll(merged);

            if (null != propertiesSource) {
                sourcedProperties.putAll(propertiesSource.getProperties());
            }
        }
    }

    private void loadVariables(JReleaserContext context, Path file) {
        propertiesFile = file;
        context.getLogger().info(RB.$("environment.load.variables"), file.toAbsolutePath());
        if (Files.exists(file)) {
            try {
                Properties p = new Properties();
                if (file.getFileName().toString().endsWith(".properties") ||
                    file.getFileName().toString().equals(".env")) {
                    try (InputStream in = newInputStream(file)) {
                        p.load(in);
                    }
                } else {
                    p.putAll(JReleaserConfigLoader.loadProperties(file));
                }
                vars.putAll(p);

                Set<String> keyNames = new TreeSet<>();
                p.stringPropertyNames().stream()
                    .filter(k -> k.startsWith(JRELEASER_ENV_PREFIX)).
                    forEach(keyNames::add);

                if (!keyNames.isEmpty()) {
                    context.getLogger().debug(RB.$("environment.variables.file", file.getFileName().toString()));
                    keyNames.forEach(message -> context.getLogger().debug("  " + message));
                }
            } catch (IOException e) {
                context.getLogger().debug(RB.$("environment.variables.load.error"), file.toAbsolutePath(), e);
            }
        } else {
            context.getLogger().warn(RB.$("environment.variables.source.missing"), file.toAbsolutePath());
        }
    }

    private Optional<Path> resolveConfigFileAt(Path directory) {
        ServiceLoader<JReleaserConfigParser> parsers = ServiceLoader.load(JReleaserConfigParser.class,
            JReleaserConfigParser.class.getClassLoader());

        for (JReleaserConfigParser parser : parsers) {
            Path file = directory.resolve("config." + parser.getPreferredFileExtension());
            if (Files.exists(file)) {
                return Optional.of(file);
            }
        }

        return Optional.empty();
    }

    public boolean getBooleanProperty(String key) {
        boolean keyInProperties = properties.containsKey(key) && Boolean.parseBoolean(String.valueOf(properties.get(key)));
        boolean keyInSourcedProperties = sourcedProperties.containsKey(key) && Boolean.parseBoolean(String.valueOf(sourcedProperties.get(key)));
        return keyInProperties || keyInSourcedProperties;
    }

    public interface PropertiesSource extends Serializable {
        Map<String, String> getProperties();
    }

    public abstract static class AbstractPropertiesSource implements PropertiesSource {
        private static final long serialVersionUID = 9102569253517657171L;

        @Override
        public Map<String, String> getProperties() {
            Map<String, String> props = doGetProperties();
            Map<String, String> map = new LinkedHashMap<>();

            props.forEach((key, value) -> {
                if (key.startsWith("JRELEASER_")) return;
                String k = key.replace(".", "-");
                k = getPropertyNameForLowerCaseHyphenSeparatedName(k);
                map.put(k, value);
            });

            return map;
        }

        protected abstract Map<String, String> doGetProperties();
    }

    public static class PropertiesPropertiesSource extends AbstractPropertiesSource {
        private static final long serialVersionUID = 7747477120107034027L;

        private final Properties properties;

        public PropertiesPropertiesSource(Properties properties) {
            this.properties = properties;
        }

        @Override
        protected Map<String, String> doGetProperties() {
            Map<String, String> map = new LinkedHashMap<>();
            properties.forEach((k, v) -> map.put(String.valueOf(k), String.valueOf(v)));
            return map;
        }
    }

    public static class MapPropertiesSource extends AbstractPropertiesSource {
        private static final long serialVersionUID = 6643212572356054605L;

        private final Map<String, ?> properties;

        public MapPropertiesSource(Map<String, ?> properties) {
            this.properties = properties;
        }

        @Override
        protected Map<String, String> doGetProperties() {
            Map<String, String> map = new LinkedHashMap<>();
            properties.forEach((k, v) -> map.put(k, String.valueOf(v)));
            return map;
        }
    }
}

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.environment;
19
20	import com.fasterxml.jackson.annotation.JsonIgnore;
21	import org.jreleaser.bundle.RB;
22	import org.jreleaser.config.JReleaserConfigLoader;
23	import org.jreleaser.config.JReleaserConfigParser;
24	import org.jreleaser.model.internal.JReleaserContext;
25	import org.jreleaser.model.internal.common.AbstractModelObject;
26	import org.jreleaser.model.internal.common.Domain;
27	import org.jreleaser.util.Env;
28
29	import java.io.File;
30	import java.io.IOException;
31	import java.io.InputStream;
32	import java.io.Serializable;
33	import java.nio.file.Files;
34	import java.nio.file.Path;
35	import java.nio.file.Paths;
36	import java.util.LinkedHashMap;
37	import java.util.Map;
38	import java.util.Optional;
39	import java.util.Properties;
40	import java.util.ServiceLoader;
41	import java.util.Set;
42	import java.util.TreeSet;
43
44	import static java.nio.file.Files.newInputStream;
45	import static java.util.Collections.unmodifiableMap;
46	import static org.jreleaser.model.Constants.DEFAULT_GIT_REMOTE;
47	import static org.jreleaser.model.Constants.JRELEASER_USER_HOME;
48	import static org.jreleaser.model.Constants.XDG_CONFIG_HOME;
49	import static org.jreleaser.util.Env.JRELEASER_ENV_PREFIX;
50	import static org.jreleaser.util.Env.JRELEASER_SYS_PREFIX;
51	import static org.jreleaser.util.Env.envKey;
52	import static org.jreleaser.util.StringUtils.getPropertyNameForLowerCaseHyphenSeparatedName;
53	import static org.jreleaser.util.StringUtils.isBlank;
54	import static org.jreleaser.util.StringUtils.isNotBlank;
55
56	/**
57	* @author Andres Almiray
58	* @since 0.1.0
59	*/
60	public final class Environment extends AbstractModelObject<Environment> implements Domain {	1✔
61	private static final long serialVersionUID = 4554098923129885325L;
62
63	private final Map<String, Object> properties = new LinkedHashMap<>();	1✔
64	@JsonIgnore	1✔
65	private final Map<String, Object> sourcedProperties = new LinkedHashMap<>();
66	@JsonIgnore
67	private PropertiesSource propertiesSource;
68	private String variables;
69	@JsonIgnore
70	private Properties vars;
71	@JsonIgnore
72	private Path propertiesFile;
73
74	@JsonIgnore	1✔
75	private final org.jreleaser.model.api.environment.Environment immutable = new org.jreleaser.model.api.environment.Environment() {	1✔
76	private static final long serialVersionUID = -7287090119869371299L;
77
78	@Override
79	public Properties getVars() {
80	return vars;	1✔
81	}
82
83	@Override
84	public String getVariables() {
85	return variables;	×
86	}
87
88	@Override
89	public Map<String, Object> getProperties() {
90	return unmodifiableMap(properties);	×
91	}
92
93	@Override
94	public Map<String, Object> asMap(boolean full) {
95	return unmodifiableMap(Environment.this.asMap(full));	×
96	}
97	};
98
99	public org.jreleaser.model.api.environment.Environment asImmutable() {
100	return immutable;	1✔
101	}
102
103	@Override
104	public void merge(Environment source) {
105	this.variables = merge(this.variables, source.variables);	1✔
106	setProperties(merge(this.properties, source.properties));	1✔
107	setPropertiesSource(merge(this.propertiesSource, source.propertiesSource));	1✔
108	}	1✔
109
110	public String resolve(String key) {
111	return env(key, Env.sys(key, ""));	1✔
112	}
113
114	public String resolve(String key, String value) {
115	return env(key, Env.sys(key, value));	1✔
116	}
117
118	public String resolveOrDefault(String key, String value, String defaultValue) {
119	String result = env(key, Env.sys(key, value));	1✔
120	return isNotBlank(result) ? result : defaultValue;	1✔
121	}
122
123	private String env(String key, String value) {
124	if (isNotBlank(value)) {	1✔
125	return value;	×
126	}
127	return getVariable(envKey(key));	1✔
128	}
129
130	public Properties getVars() {
131	return vars;	1✔
132	}
133
134	public String getVariable(String key) {
135	return vars.getProperty(Env.envKey(key));	1✔
136	}
137
138	public boolean isSet() {
139	return isNotBlank(variables) \|\|	1✔
140	!properties.isEmpty();	1✔
141	}
142
143	public PropertiesSource getPropertiesSource() {
144	return propertiesSource;	×
145	}
146
147	public void setPropertiesSource(PropertiesSource propertiesSource) {
148	this.propertiesSource = propertiesSource;	1✔
149	if (null != this.propertiesSource) {	1✔
150	sourcedProperties.putAll(propertiesSource.getProperties());	1✔
151	}
152	}	1✔
153
154	public String getVariables() {
155	return variables;	×
156	}
157
158	public void setVariables(String variables) {
159	this.variables = variables;	×
160	}	×
161
162	public Map<String, Object> getProperties() {
163	return properties;	1✔
164	}
165
166	public void setProperties(Map<String, Object> properties) {
167	this.properties.putAll(properties);	1✔
168	}	1✔
169
170	public Map<String, Object> getSourcedProperties() {
171	return sourcedProperties;	1✔
172	}
173
174	public Path getPropertiesFile() {
175	return propertiesFile;	1✔
176	}
177
178	@Override
179	public Map<String, Object> asMap(boolean full) {
180	Map<String, Object> map = new LinkedHashMap<>();	1✔
181	map.put("variables", variables);	1✔
182	map.put("properties", properties);	1✔
183
184	return map;	1✔
185	}
186
187	public void initProps(JReleaserContext context) {
188	if (null == vars) {	1✔
189	vars = new Properties();	1✔
190
191	Path configDirectory = null;	1✔
192
193	String home = System.getenv(XDG_CONFIG_HOME);	1✔
194	if (isNotBlank(home) && Files.exists(Paths.get(home).resolve("jreleaser"))) {	1✔
195	configDirectory = Paths.get(home).resolve("jreleaser");	×
196	}
197
198	if (null == configDirectory) {	1✔
199	home = System.getenv(JRELEASER_USER_HOME);	1✔
200	if (isBlank(home)) {	1✔
201	home = System.getProperty("user.home") + File.separator + ".jreleaser";	×
202	}
203	configDirectory = Paths.get(home);	1✔
204	}
205
206	loadVariables(context, resolveConfigFileAt(configDirectory)	1✔
207	.orElse(configDirectory.resolve("config.properties")));	1✔
208
209	if (isNotBlank(variables)) {	1✔
210	loadVariables(context, context.getBasedir().resolve(variables.trim()));	×
211	}
212
213	Path envFilePath = context.getBasedir().resolve(".env");	1✔
214	if (Files.exists(envFilePath)) {	1✔
215	loadVariables(context, envFilePath);	×
216	}
217
218	// env vars
219	Set<String> keyNames = new TreeSet<>();	1✔
220	Properties envVars = new Properties();	1✔
221	System.getenv().forEach((k, v) -> {	1✔
222	if (k.startsWith(JRELEASER_ENV_PREFIX) && isNotBlank(v)) {	1✔
223	keyNames.add(k);	1✔
224	envVars.put(k, v);	1✔
225	}
226	});	1✔
227	if (System.getenv().containsKey(envKey(DEFAULT_GIT_REMOTE))) {	1✔
UNCOV 228	keyNames.add(envKey(DEFAULT_GIT_REMOTE));	×
229	}
230	if (!keyNames.isEmpty()) {	1✔
231	context.getLogger().debug(RB.$("environment.variables.env"));	1✔
232	keyNames.forEach(message -> context.getLogger().debug(" " + message));	1✔
233	}
234
235	// system props
236	keyNames.clear();	1✔
237	System.getProperties().stringPropertyNames().forEach(k -> {	1✔
238	if (k.startsWith(JRELEASER_SYS_PREFIX)) keyNames.add(k);	1✔
239	});	1✔
240	if (!keyNames.isEmpty()) {	1✔
241	context.getLogger().debug(RB.$("environment.system.properties"));	1✔
242	keyNames.forEach(message -> context.getLogger().debug(" " + message));	1✔
243	}
244
245	// merge keyNames
246	Properties merged = new Properties();	1✔
247	merged.putAll(envVars);	1✔
248	merged.putAll(this.vars);	1✔
249	this.vars.clear();	1✔
250	this.vars.putAll(merged);	1✔
251
252	if (null != propertiesSource) {	1✔
253	sourcedProperties.putAll(propertiesSource.getProperties());	1✔
254	}
255	}
256	}	1✔
257
258	private void loadVariables(JReleaserContext context, Path file) {
259	propertiesFile = file;	1✔
260	context.getLogger().info(RB.$("environment.load.variables"), file.toAbsolutePath());	1✔
261	if (Files.exists(file)) {	1✔
262	try {
263	Properties p = new Properties();	1✔
264	if (file.getFileName().toString().endsWith(".properties") \|\|	1✔
265	file.getFileName().toString().equals(".env")) {	1✔
UNCOV 266	try (InputStream in = newInputStream(file)) {	×
UNCOV 267	p.load(in);	×
268	}
269	} else {
270	p.putAll(JReleaserConfigLoader.loadProperties(file));	1✔
271	}
272	vars.putAll(p);	1✔
273
274	Set<String> keyNames = new TreeSet<>();	1✔
275	p.stringPropertyNames().stream()	1✔
276	.filter(k -> k.startsWith(JRELEASER_ENV_PREFIX)).	1✔
277	forEach(keyNames::add);	1✔
278
279	if (!keyNames.isEmpty()) {	1✔
280	context.getLogger().debug(RB.$("environment.variables.file", file.getFileName().toString()));	1✔
281	keyNames.forEach(message -> context.getLogger().debug(" " + message));	1✔
282	}
UNCOV 283	} catch (IOException e) {	×
UNCOV 284	context.getLogger().debug(RB.$("environment.variables.load.error"), file.toAbsolutePath(), e);	×
285	}	1✔
286	} else {
UNCOV 287	context.getLogger().warn(RB.$("environment.variables.source.missing"), file.toAbsolutePath());	×
288	}
289	}	1✔
290
291	private Optional<Path> resolveConfigFileAt(Path directory) {
292	ServiceLoader<JReleaserConfigParser> parsers = ServiceLoader.load(JReleaserConfigParser.class,	1✔
293	JReleaserConfigParser.class.getClassLoader());	1✔
294
295	for (JReleaserConfigParser parser : parsers) {	1✔
296	Path file = directory.resolve("config." + parser.getPreferredFileExtension());	1✔
297	if (Files.exists(file)) {	1✔
298	return Optional.of(file);	1✔
299	}
300	}	1✔
301
UNCOV 302	return Optional.empty();	×
303	}
304
305	public boolean getBooleanProperty(String key) {
306	boolean keyInProperties = properties.containsKey(key) && Boolean.parseBoolean(String.valueOf(properties.get(key)));	1✔
307	boolean keyInSourcedProperties = sourcedProperties.containsKey(key) && Boolean.parseBoolean(String.valueOf(sourcedProperties.get(key)));	1✔
308	return keyInProperties \|\| keyInSourcedProperties;	1✔
309	}
310
311	public interface PropertiesSource extends Serializable {
312	Map<String, String> getProperties();
313	}
314
315	public abstract static class AbstractPropertiesSource implements PropertiesSource {	1✔
316	private static final long serialVersionUID = 9102569253517657171L;
317
318	@Override
319	public Map<String, String> getProperties() {
320	Map<String, String> props = doGetProperties();	1✔
321	Map<String, String> map = new LinkedHashMap<>();	1✔
322
323	props.forEach((key, value) -> {	1✔
324	if (key.startsWith("JRELEASER_")) return;	1✔
325	String k = key.replace(".", "-");	1✔
326	k = getPropertyNameForLowerCaseHyphenSeparatedName(k);	1✔
327	map.put(k, value);	1✔
328	});	1✔
329
330	return map;	1✔
331	}
332
333	protected abstract Map<String, String> doGetProperties();
334	}
335
336	public static class PropertiesPropertiesSource extends AbstractPropertiesSource {
337	private static final long serialVersionUID = 7747477120107034027L;
338
339	private final Properties properties;
340
341	public PropertiesPropertiesSource(Properties properties) {	1✔
342	this.properties = properties;	1✔
343	}	1✔
344
345	@Override
346	protected Map<String, String> doGetProperties() {
347	Map<String, String> map = new LinkedHashMap<>();	1✔
348	properties.forEach((k, v) -> map.put(String.valueOf(k), String.valueOf(v)));	1✔
349	return map;	1✔
350	}
351	}
352
353	public static class MapPropertiesSource extends AbstractPropertiesSource {
354	private static final long serialVersionUID = 6643212572356054605L;
355
356	private final Map<String, ?> properties;
357
UNCOV 358	public MapPropertiesSource(Map<String, ?> properties) {	×
UNCOV 359	this.properties = properties;	×
360	}	×
361
362	@Override
363	protected Map<String, String> doGetProperties() {
UNCOV 364	Map<String, String> map = new LinkedHashMap<>();	×
UNCOV 365	properties.forEach((k, v) -> map.put(k, String.valueOf(v)));	×
366	return map;	×
367	}
368	}
369	}

jreleaser / jreleaser / #500

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