implab/gradle-common Commit - r16:0e291927620c

Changed TaskEnvSpecMixin , Fixed bug in ExtraProps extension when updating extra pros of objects.

cin -

r16:0e291927620c default

parent child

Context file:

r16:0e291927620c

Collapse all files

common/src/main/java/org/implab/gradle/common/utils/ExtraPropsExtension.java created 644 +43 0

@@ -0,0 +1,43
	1	package org.implab.gradle.common.utils;
	2
	3	import java.util.Optional;
	4	import java.util.Set;
	5
	6	import org.eclipse.jdt.annotation.NonNullByDefault;
	7	import org.gradle.api.plugins.ExtraPropertiesExtension;
	8
	9	@NonNullByDefault
	10	class ExtraPropsExtension implements ExtraProps {
	11
	12	private final ExtraPropertiesExtension ext;
	13
	14	public ExtraPropsExtension(ExtraPropertiesExtension ext) {
	15	this.ext = ext;
	16	}
	17
	18	@Override
	19	public Set<String> keys() {
	20	return ext.getProperties().keySet();
	21	}
	22
	23	@Override
	24	public boolean has(String name) {
	25	return ext.has(name);
	26	}
	27
	28	@Override
	29	public <T> Optional<T> get(String name, Class<T> clazz) {
	30	return Optional.ofNullable(ext.get(name)).map(clazz::cast);
	31	}
	32
	33	@Override
	34	public void put(String name, Object value) {
	35	ext.set(name, value);
	36	}
	37
	38	@Override
	39	public void remove(String name) {
	40	ext.set(name, null);
	41	}
	42
	43	}

common/src/main/java/org/implab/gradle/common/utils/ExtraPropsNone.java created 644 +31 0

@@ -0,0 +1,31
	1	package org.implab.gradle.common.utils;
	2
	3	import java.util.Optional;
	4	import java.util.Set;
	5
	6	public class ExtraPropsNone implements ExtraProps {
	7
	8	@Override
	9	public Set<String> keys() {
	10	return Set.of();
	11	}
	12
	13	@Override
	14	public boolean has(String name) {
	15	return false;
	16	}
	17
	18	@Override
	19	public <T> Optional<T> get(String name, Class<T> clazz) {
	20	return Optional.empty();
	21	}
	22
	23	@Override
	24	public void put(String name, Object value) {
	25	}
	26
	27	@Override
	28	public void remove(String name) {
	29	}
	30
	31	}

common/build.gradle +1 -1

             plugins {
                 id "java-library"
                 id "ivy-publish"
             }
             java {
                 withJavadocJar()
                 withSourcesJar()
-                    toolchain {
+                toolchain {
                     languageVersion = JavaLanguageVersion.of(17)
                 }
             }
             dependencies {
                 compileOnly libs.jdt.annotations
                 api gradleApi()
             }
             task printVersion{
                 doLast {
                     println "project: $project.group:$project.name:$project.version"
                     println "jar: ${->jar.archiveFileName.get()}"
                 }
             }
             publishing {
                 repositories {
                     ivy {
                         url "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
                 publications {
                     ivy(IvyPublication) {
                         from components.java
                         descriptor.description {
                             text = providers.provider({ description })
                         }
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/dsl/TaskEnvSpecMixin.java +7 -12

             package org.implab.gradle.common.dsl;
             import java.util.HashMap;
             import java.util.Map;
             import org.gradle.api.Action;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.provider.MapProperty;
             import org.gradle.api.provider.Property;
+            import org.gradle.api.provider.Provider;
             import org.implab.gradle.common.utils.Closures;
             import org.implab.gradle.common.utils.Values;
             import groovy.lang.Closure;
             /**
              * Configuration properties of the execution shell. This object specifies a
              * working directory and environment variables for the processes started within
              * this shell.
              */
             public interface TaskEnvSpecMixin {
                 /** Inherit environment from current process */
                 Property<Boolean> getInheritEnvironment();
                 /** Working directory */
                 DirectoryProperty getWorkingDirectory();
                 /** Environment variables */
                 MapProperty<String, String> getEnvironment();
                 /**
                  * Configures the environment variable using the specified action. The
                  * action is called when the value is calculated;
+                 *
+                 * <p>
+                 * The configuration action is called immediately. To support lazy evaluation,
+                 * properties may be assigned to providers.
                  */
-                default void env(Action<Map<String, Object>> configure) {
+                default void env(Action<Map<String, ?>> configure) {
-                    var provider = getEnvironment()
+                    Values.configureMap(getEnvironment(), configure, Object.class, Values::toString);
-                            .orElse(Map.of())
-                            .map((base) -> {
-                                var props = new HashMap<String, Object>(base);
-                                configure.execute(props);
-                                return Values.mapValues(props, Values::toString);
-                            });
-                    getEnvironment().set(provider);
                 }
                 default void env(Closure<?> configure) {
                     env(Closures.action(configure));
                 }
             }

common/src/main/java/org/implab/gradle/common/utils/ExtraProps.java +17 -8

@@ -1,16 +1,25
1	package org.implab.gradle.common.utils;	1	package org.implab.gradle.common.utils;
2		2
3	import java.util.~~Map~~;	3	import java.util.Optional;
		4	import java.util.Set;
4		5
5	import org.gradle.api.plugins.ExtensionAware;	6	import org.gradle.api.plugins.ExtensionAware;
6		7
7	public ~~class~~ ExtraProps {	8	public interface ExtraProps {
		9
		10	Set<String> keys();
		11
		12	boolean has(String name);
		13
		14	<T> Optional<T> get(String name, Class<T> clazz);
8		15
9	public static Map<String, Object> of(Object target) {	16	void put(String name, Object value);
10	if (target instanceof ExtensionAware ext)	17
11	return ext.getExtensions().getExtraProperties().getProperties();	18	void remove(String name);
12	else	19
13	return Map.of();	20	public static ExtraProps of(Object target) {
		21	return target instanceof ExtensionAware ext
		22	? new ExtraPropsExtension(ext.getExtensions().getExtraProperties())
		23	: new ExtraPropsNone();
14	}	24	}
15
16	}	25	}

common/src/main/java/org/implab/gradle/common/utils/Values.java +31 -1

             package org.implab.gradle.common.utils;
+            import java.util.HashMap;
             import java.util.Iterator;
             import java.util.Map;
             import java.util.Spliterators;
             import java.util.Map.Entry;
             import java.util.Optional;
             import java.util.function.Function;
             import java.util.function.Supplier;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import java.util.stream.StreamSupport;
+            import org.gradle.api.Action;
+            import org.gradle.api.provider.MapProperty;
             import org.gradle.api.provider.Provider;
             public final class Values {
                 private Values() {
                 }
                 /**
                  * Converts values in the specified map
+                 *
                  * @param <K>
                  * @param <V>
                  * @param <U>
                  * @param map
                  * @param mapper
                  * @return
                  */
                 public static <K, V, U> Map<K, U> mapValues(Map<K, V> map, Function<V, U> mapper) {
                     Function<Entry<K, V>, V> getter = Entry::getValue;
                     return map.entrySet().stream()
                             .collect(Collectors.toMap(Entry::getKey, getter.andThen(mapper)));
                 }
+                public static <K, V> void mergeMap(MapProperty<K,V> prop, Map<K, ? > map, Class<V> clazz) {
+                    map.forEach((k,v) -> {
+                        if(v instanceof Provider<?>)
+                            prop.put(k, ((Provider<?>)v).map(clazz::cast));
+                        else
+                            prop.put(k, clazz.cast(v));
+                    });
+                }
+                public static <K,V,U> void mergeMap(MapProperty<K,V> prop, Map<K, ?> map, Class<U> clazz, Function<U,V> mapper) {
+                    Function<Object, U> caster = clazz::cast;
+                    var castMap = caster.andThen(mapper);
+                    map.forEach((k,v) -> {
+                        if(v instanceof Provider<?>)
+                            prop.put(k, ((Provider<?>)v).map(x -> castMap.apply(x)));
+                        else
+                            prop.put(k, castMap.apply(v));
+                    });
+                }
+                public static <K,V,U> void configureMap(MapProperty<K,V> prop, Action<Map<K, ?>> configure, Class<U> clazz, Function<U,V> mapper)  {
+                    var map = new HashMap<K,V>();
+                    configure.execute(map);
+                    mergeMap(prop, map, clazz, mapper);
+                }
                 /**
                  * Converts the supplied value to a string.
                  */
                 public static String toString(Object value) {
                     if (value == null) {
                         return null;
                     } else if (value instanceof String string) {
                         return string;
                     } else if (value instanceof Provider<?> provider) {
                         return toString(provider.getOrNull());
                     } else if (value instanceof Supplier<?> supplier) {
                         return toString(supplier.get());
                     } else {
                         return value.toString();
                     }
                 }
                 public static <T> Stream<T> stream(Iterator<T> remaining) {
                     return StreamSupport.stream(
                             Spliterators.spliteratorUnknownSize(remaining, 0),
                             false);
                 }
                 public static <T> Optional<T> take(Iterator<T> iterator) {
                     return iterator.hasNext() ? Optional.of(iterator.next()) : Optional.empty();
                 }
                 public static <T> Iterable<T> iterable(T[] values) {
                     return () -> new ArrayIterator<>(values);
                 }
                 public static <T> Optional<T> optional(Provider<T> provider) {
                     return provider.isPresent() ? Optional.of(provider.get()) : Optional.empty();
                 }
                 private static class ArrayIterator<T> implements Iterator<T> {
                     private final T[] data;
                     private int pos = 0;
                     ArrayIterator(T[] data) {
                         this.data = data;
                     }
                     @Override
                     public boolean hasNext() {
                         return pos < data.length;
                     }
                     @Override
                     public T next() {
                         return data[pos++];
                     }
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages