implab/gradle-common Commit - r19:44d7291c1c1b

sync, minor fixes

cin -

r19:44d7291c1c1b default

parent child

Context file:

r19:44d7291c1c1b

Collapse all files

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

             package org.implab.gradle.common.dsl;
             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.implab.gradle.common.utils.Closures;
             import org.implab.gradle.common.utils.Properties;
             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, ?>> configure) {
+                default void env(Action<Map<String, Object>> configure) {
                     Properties.configureMap(getEnvironment(), configure, Object::toString);
                 }
                 default void env(Closure<?> configure) {
                     env(Closures.action(configure));
                 }
             }

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

             package org.implab.gradle.common.utils;
             import groovy.lang.Closure;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             @NonNullByDefault
             public final class Closures {
                 private Closures() {
                 }
                 /**
                  * Wraps {@link Action} around the specified closure. The parameter
                  * of the action will be used as delegate in the specified closure.
                  *
                  * @param <T> The type of the action parameter
                  * @param closure The closure
                  * @return
                  */
                 public static <T> Action<T> action(Closure<?> closure) {
                     return arg -> apply(closure, arg);
                 }
                 public static void apply(Closure<?> action, Object target) {
                     var c = (Closure<?>)action.clone();
-                    c.setResolveStrategy(0);
+                    c.setResolveStrategy(Closure.DELEGATE_FIRST);
                     c.setDelegate(target);
                     c.call(target);
                 }
             }

common/src/main/java/org/implab/gradle/common/utils/Properties.java +2 -2

             package org.implab.gradle.common.utils;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.function.Function;
             import org.gradle.api.Action;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.MapProperty;
             import org.gradle.api.provider.Provider;
             public final class Properties {
                 private Properties() {
                 }
                 public static <K> void mergeMap(MapProperty<K, Object> property, Map<K, Object> map) {
                     map.forEach((k, v) -> {
                         if (v instanceof Provider<?>)
                             property.put(k, (Provider<?>) v);
                         else
                             property.put(k, v);
                     });
                 }
                 public static <K, V> void mergeMap(MapProperty<K, V> property, Map<K, ?> map, Function<Object, V> mapper) {
                     map.forEach((k, v) -> {
                         if (v instanceof Provider<?>)
                             property.put(k, ((Provider<?>) v).map(mapper::apply));
                         else
                             property.put(k, mapper.apply(v));
                     });
                 }
                 public static void mergeList(ListProperty<Object> property, Iterable<Object> values) {
                     values.forEach(v -> {
                         if (v instanceof Provider<?>)
                             property.add((Provider<?>) v);
                         else
                             property.add(v);
                     });
                 }
                 public static <V> void mergeList(ListProperty<V> property, Iterable<Object> values, Function<Object, V> mapper) {
                     values.forEach(v -> {
                         if (v instanceof Provider<?>)
                             property.add(((Provider<?>) v).map(mapper::apply));
                         else
                             property.add(mapper.apply(v));
                     });
                 }
-                public static <K> void configureMap(MapProperty<K, Object> prop, Action<Map<K, ?>> configure) {
+                public static <K> void configureMap(MapProperty<K, Object> prop, Action<Map<K, Object>> configure) {
                     var map = new HashMap<K, Object>();
                     configure.execute(map);
                     mergeMap(prop, map);
                 }
-                public static <K, V> void configureMap(MapProperty<K, V> prop, Action<Map<K, ?>> configure, Function<Object, V> mapper) {
+                public static <K, V> void configureMap(MapProperty<K, V> prop, Action<Map<K, Object>> configure, Function<Object, V> mapper) {
                     var map = new HashMap<K, Object>();
                     configure.execute(map);
                     mergeMap(prop, map, mapper);
                 }
             }

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