implab/gradle-common Commit - r15:a8aa61eea9d1

sync

cin -

r15:a8aa61eea9d1 default

parent child

Context file:

r15:a8aa61eea9d1

common/src/main/java/org/implab/gradle/common/dsl/TaskCommandSpecMixin.java ~~common/src/main/java/org/implab/gradle/common/dsl/CommandSpec.java~~ renamed +1 -1

             package org.implab.gradle.common.dsl;
             import org.gradle.api.provider.ListProperty;
-            public interface CommandSpec {
+            public interface TaskCommandSpecMixin {
                 ListProperty<String> getCommandLine();
                 void commandLine(Object arg0, Object... args);
                 void args(Object arg0, Object... args);
             }

common/src/main/java/org/implab/gradle/common/dsl/TaskEnvSpecMixin.java ~~common/src/main/java/org/implab/gradle/common/dsl/EnvironmentSpec.java~~ renamed +5 -1

             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.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 EnvironmentSpec {
+            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;
                  */
                 default void env(Action<Map<String, Object>> configure) {
                     var provider = getEnvironment()
                             .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/dsl/TaskPipeSpecMixin.java ~~common/src/main/java/org/implab/gradle/common/dsl/PipeSpec.java~~ renamed +1 -1

             package org.implab.gradle.common.dsl;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             @NonNullByDefault
-            public interface PipeSpec {
+            public interface TaskPipeSpecMixin {
                 RedirectToSpec getStdout();
                 RedirectToSpec getStderr();
                 RedirectFromSpec getStdin();
             }

common/src/main/java/org/implab/gradle/common/tasks/ShellExecTask.java +9 -4

             package org.implab.gradle.common.tasks;
             import java.io.IOException;
             import java.util.Map;
             import java.util.concurrent.ExecutionException;
             import java.util.stream.Stream;
             import org.gradle.api.DefaultTask;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.MapProperty;
+            import org.gradle.api.provider.Property;
             import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.TaskAction;
-            import org.implab.gradle.common.dsl.CommandSpec;
+            import org.implab.gradle.common.dsl.TaskCommandSpecMixin;
-            import org.implab.gradle.common.dsl.PipeSpec;
+            import org.implab.gradle.common.dsl.TaskPipeSpecMixin;
             import org.implab.gradle.common.dsl.RedirectFromSpec;
             import org.implab.gradle.common.dsl.RedirectToSpec;
-            import org.implab.gradle.common.dsl.EnvironmentSpec;
+            import org.implab.gradle.common.dsl.TaskEnvSpecMixin;
             import org.implab.gradle.common.exec.ExecBuilder;
             import org.implab.gradle.common.utils.ObjectsMixin;
             import org.implab.gradle.common.utils.Strings;
             import org.implab.gradle.common.utils.ThrowingConsumer;
             public abstract class ShellExecTask
                     extends DefaultTask
-                    implements CommandSpec, PipeSpec, EnvironmentSpec, ObjectsMixin {
+                    implements TaskCommandSpecMixin, TaskPipeSpecMixin, TaskEnvSpecMixin, ObjectsMixin {
                 private final RedirectToSpec redirectStderr = new RedirectToSpec();
                 private final RedirectToSpec redirectStdout = new RedirectToSpec();
                 private final RedirectFromSpec redirectStdin = new RedirectFromSpec();
                 @Internal
                 @Override
+                public abstract Property<Boolean> getInheritEnvironment();
+                @Internal
+                @Override
                 public abstract DirectoryProperty getWorkingDirectory();
                 @Internal
                 @Override
                 public abstract MapProperty<String, String> getEnvironment();
                 @Internal
                 @Override
                 public abstract ListProperty<String> getCommandLine();
                 /**
                  * STDIN redirection, if not specified, no input will be passed to the command
                  */
                 @Internal
                 @Override
                 public RedirectFromSpec getStdin() {
                     return redirectStdin;
                 }
                 /**
                  * STDOUT redirection, if not specified, redirected to logger::info
                  */
                 @Internal
                 @Override
                 public RedirectToSpec getStdout() {
                     return redirectStdout;
                 }
                 /**
                  * STDERR redirection, if not specified, redirected to logger::error
                  */
                 @Internal
                 @Override
                 public RedirectToSpec getStderr() {
                     return redirectStderr;
                 }
                 @Override
                 public void commandLine(Object arg0, Object... args) {
                     getCommandLine().set(provider(() -> Stream.concat(
                             Stream.of(arg0),
                             Stream.of(args))
                             .map(Strings::asString).toList()));
                 }
                 @Override
                 public void args(Object arg0, Object... args) {
                     getCommandLine().addAll(provider(() -> Stream.concat(
                             Stream.of(arg0),
                             Stream.of(args))
                             .map(Strings::asString).toList()));
                 }
                 protected abstract ExecBuilder execBuilder();
                 @TaskAction
                 public final void run() throws IOException, InterruptedException, ExecutionException {
                     var execBuilder = execBuilder();
                     execBuilder.workingDirectory(getWorkingDirectory().get().getAsFile());
                     execBuilder.environment(getEnvironment().getOrElse(Map.of()));
                     execBuilder.commandLine(getCommandLine().get());
                     getStdout().getRedirection().ifPresent(execBuilder::stdout);
                     getStderr().getRedirection().ifPresent(execBuilder::stderr);
                     getStdin().getRedirection().ifPresent(execBuilder::stdin);
                     execBuilder.exec().thenAccept(ThrowingConsumer.guard(this::checkRetCode)).join();
                 }
                 protected void checkRetCode(Integer code) throws IOException {
                     throw new IOException(String.format("The process is terminated with code %s", code));
                 }
             }

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

             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() {
                 }
                 public static <T> Action<T> action(Closure<?> closure) {
-                    return arg -> {
+                    return arg -> apply(closure, arg);
-                        closure.setDelegate(arg);
-                        closure.call(arg);
-                    };
                 }
                 public static void apply(Closure<?> action, Object target) {
                     action.setDelegate(target);
                     action.call(target);
                 }
             }

common/src/main/java/org/implab/gradle/common/utils/Values.java +4 0

             package org.implab.gradle.common.utils;
             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.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)));
                 }
                 /**
                  * 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++];
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/dsl/TaskDependency.java removed 0 -22

	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