implab/gradle-common Commit - r12:9ce58f1128fc

WIP minor changes

cin -

r12:9ce58f1128fc default

parent child

Context file:

r12:9ce58f1128fc

Collapse all files

common/src/main/java/org/implab/gradle/common/exec/CommandBuilder.java +29 -1

             package org.implab.gradle.common.exec;
             import java.util.stream.Stream;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.implab.gradle.common.utils.Values;
+            /** Command builder interface, used to specify the executable and parameters */
             @NonNullByDefault
             public interface CommandBuilder {
+                /** Sets the executable, the parameters are left intact. */
                 CommandBuilder executable(String executable);
+                /** Sets the specified executable and parameters, old executable and parameters
+                 * are discarded.
+                 */
                 default CommandBuilder commandLine(String executable, String... args) {
                     return executable(executable)
                         .arguments(args);
                 }
-                default CommandBuilder arg(String arg0, String... args) {
+                /** Sets the specified executable and parameters, old executable and parameters
+                 * are discarded.
+                 *
+                 * @param command The command line. Must contain at least one element (executable).
+                 *
+                 */
+                default CommandBuilder commandLine(Iterable<? extends String> command) {
+                    var iterator = command.iterator();
+                    // set executable
+                    executable(Values.take(iterator).orElseThrow());
+                    // cleat arguments
+                    arguments();
+                    // set new arguments
+                    while (iterator.hasNext())
+                        addArguments(iterator.next());
+                    return this;
+                }
+                /** Adds the specified arguments to this builder */
+                default CommandBuilder addArguments(String arg0, String... args) {
                     return arguments(() -> Stream
                             .concat(Stream.of(arg0), Stream.of(args))
                             .iterator());
                 }
+                /** Replaces arguments in the builder with the specified one. */
                 default CommandBuilder arguments(String... args) {
                     return arguments(Values.iterable(args));
                 }
+                /** Replaces arguments in the builder with the specified one. */
                 CommandBuilder arguments(Iterable<String> args);
                 default CommandBuilder from(CommandSpec commandSpec) {
                     return executable(commandSpec.executable())
                             .arguments(commandSpec.arguments());
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/ExecBuilder.java +1 -10

             package org.implab.gradle.common.exec;
             import java.util.ArrayList;
             import java.util.HashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Optional;
             import java.util.concurrent.CompletableFuture;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.eclipse.jdt.annotation.Nullable;
             import java.io.File;
             import java.io.IOException;
             import static java.util.Objects.requireNonNull;
             /** Command line builder */
             @NonNullByDefault
             public abstract class ExecBuilder implements
                 CommandBuilder,
                 PipeBuilder,
                 EnvironmentBuilder,
                 Runnable
             {
                 private String executable;
                 private final List<String> arguments = new ArrayList<>();
                 private final Map<String, String> environment = new HashMap<>();
                 private @Nullable File directory;
                 private RedirectFrom inputRedirect;
                 private RedirectTo outputRedirect;
                 private RedirectTo errorRedirect;
                 @Override
                 public ExecBuilder executable(String executable) {
                     requireNonNull(executable, "cmd can't be null");
                     this.executable = executable;
                     return this;
                 }
                 @Override
                 public ExecBuilder arguments(Iterable<String> args) {
                     requireNonNull(args, "Args must not be null");
                     arguments.clear();
                     for(var arg: args)
                         arguments.add(arg);
                     return this;
                 }
-                public ExecBuilder commandLine(Iterable<? extends String> cmd) {
-                    requireNonNull(cmd, "cmd can't be null");
-                    this.arguments.clear();
-                    for (var arg : cmd)
-                        this.arguments.add(arg);
-                    return this;
                 @Override
-                public ExecBuilder arg(String arg0, String... args) {
+                public ExecBuilder addArguments(String arg0, String... args) {
                     requireNonNull(arg0, "arg0 parameter can't be null");
                     arguments.add(arg0);
                     for (var arg : args)
                         arguments.add(arg);
                     return this;
                 }
                 /** Sets the working directory */
                 @Override
                 public ExecBuilder workingDirectory(File directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory;
                     return this;
                 }
                 @Override
                 public ExecBuilder workingDirectory(Optional<? extends File> directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory.orElse(null);
                     return this;
                 }
                 /**
                  * Sets the environment value. The value cannot be null.
                  *
                  * @param envVar The name of the environment variable
                  * @param value  The value to set,
                  */
                 @Override
                 public ExecBuilder setVariable(String envVar, String value) {
                     requireNonNull(value, "Value can't be null");
                     requireNonNull(envVar, "envVar parameter can't be null");
                     environment.put(envVar, value);
                     return this;
                 }
                 @Override
                 public ExecBuilder environment(Map<String,? extends String> env) {
                     requireNonNull(env, "env parameter can't be null");
                     environment.clear();
                     environment.putAll(env);
                     return this;
                 }
                 /**
                  * Sets redirection for the stdin, {@link RedirectFrom} will be applied
                  * every time the process is started.
                  *
                  * <p>
                  * If redirection
                  */
                 @Override
                 public ExecBuilder stdin(RedirectFrom from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from;
                     return this;
                 }
                 @Override
                 public PipeBuilder stdin(Optional<? extends RedirectFrom> from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from.orElse(null);
                     return this;
                 }
                 /**
                  * Sets redirection for the stdout, {@link RedirectTo} will be applied
                  * every time the process is started.
                  */
                 @Override
                 public ExecBuilder stdout(RedirectTo out) {
                     requireNonNull(out, "out parameter can't be null");
                     outputRedirect = out;
                     return this;
                 }
                 @Override
                 public PipeBuilder stdout(Optional<? extends RedirectTo> to) {
                     requireNonNull(to, "from parameter can't be null");
                     outputRedirect = to.orElse(null);
                     return this;
                 }
                 /**
                  * Sets redirection for the stderr, {@link RedirectTo} will be applied
                  * every time the process is started.
                  */
                 @Override
                 public ExecBuilder stderr(RedirectTo err) {
                     requireNonNull(err, "err parameter can't be null");
                     errorRedirect = err;
                     return this;
                 }
                 @Override
                 public PipeBuilder stderr(Optional<? extends RedirectTo> to) {
                     requireNonNull(to, "from parameter can't be null");
                     errorRedirect = to.orElse(null);
                     return this;
                 }
                 /** Implement this function to */
                 protected abstract CompletableFuture<Integer> startInternal(
                         Map<String, String> environment,
                         Optional<File> directory,
                         List<String> commandLine,
                         Optional<RedirectFrom> stdinRedirect,
                         Optional<RedirectTo> stdoutRedirect,
                         Optional<RedirectTo> stderrRedirect) throws IOException;
                 /**
                  * Creates and starts new process and returns {@link CompletableFuture}. The
                  * process may be a remote process, or a shell process or etc.
                  *
                  * @return
                  * @throws IOException
                  */
                 public CompletableFuture<Integer> run() throws IOException {
                     if (executable == null || executable.isEmpty())
                         throw new IllegalStateException("The executable isn't set");
                     var commandLine = new ArrayList<String>();
                     commandLine.add(executable);
                     commandLine.addAll(arguments);
                     return startInternal(
                             environment,
                             Optional.ofNullable(directory),
                             commandLine,
                             Optional.ofNullable(inputRedirect),
                             Optional.ofNullable(outputRedirect),
                             Optional.ofNullable(errorRedirect));
                 }
             }

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

             package org.implab.gradle.common.utils;
             import java.util.Iterator;
             import java.util.Map;
+            import java.util.Spliterator;
+            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) {
+                    var spliterator = Spliterators.spliteratorUnknownSize(remaining, 0);
+                    return StreamSupport.stream(spliterator, 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);
                 }
                 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