implab/gradle-common Commit - r23:8e57f0a2d4de

Refactoring, removed GenericSourceSetOutput.

cin -

r23:8e57f0a2d4de default

parent child

Context file:

r23:8e57f0a2d4de

Expand all files

.vscode/settings.json +2 -1

             {
                 "java.configuration.updateBuildConfiguration": "automatic",
                 "java.compile.nullAnalysis.mode": "automatic",
                 "cSpell.words": [
-                    "implab"
+                    "implab",
+                    "rawtypes"
                 ]
             }

common/src/main/java/org/implab/gradle/common/core/gradle/Extensions.java ~~common/src/main/java/org/implab/gradle/common/utils/Extensions.java~~ renamed +1 -1

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.gradle;
             import java.util.function.Consumer;
             import org.gradle.api.plugins.ExtensionContainer;
             public final class Extensions {
                 private Extensions() {
                 }
                 public static Consumer<Class<?>> registerClass(ExtensionContainer extensions) {
                     var extra = extensions.getExtraProperties();
                     return clazz -> extra.set(clazz.getSimpleName(), clazz);
                 }
             }

common/src/main/java/org/implab/gradle/common/core/gradle/Properties.java ~~common/src/main/java/org/implab/gradle/common/utils/Properties.java~~ renamed +1 -1

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.gradle;
             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) {
                     mergeMap(property, map, Function.identity());
                 }
                 public static <K, V> void putMapEntry(MapProperty<K, V> property, K key, Object value,
                         Function<Object, ? extends V> mapper) {
                     if (value instanceof Provider<?>)
                         property.put(key, ((Provider<?>) value).map(mapper::apply));
                     else
                         property.put(key, mapper.apply(value));
                 }
                 public static <K> void putMapEntry(MapProperty<K, Object> property, K key, Object value) {
                     putMapEntry(property, key, value, Function.identity());
                 }
                 public static <K, V> void putMapEntry(MapProperty<K, V> property, K key, Object value, Class<V> valueType) {
                     putMapEntry(property, key, value, valueType::cast);
                 }
                 public static <K, V> void mergeMap(MapProperty<K, V> property, Map<K, ?> map,
                         Function<Object, ? extends 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) {
                     mergeList(property, values, Function.identity());
                 }
                 public static <V> void mergeList(ListProperty<V> property, Iterable<Object> values,
                         Function<Object, ? extends 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<? super Map<K, Object>> configure) {
                     configureMap(prop, configure, Function.identity());
                 }
                 public static <K, V> void configureMap(MapProperty<K, V> prop, Action<? super Map<K, Object>> configure,
                         Function<Object, V> mapper) {
                     var map = new HashMap<K, Object>();
                     configure.execute(map);
                     mergeMap(prop, map, mapper);
                 }
             }

common/src/main/java/org/implab/gradle/common/core/gradle/TaskExtra.java ~~common/src/main/java/org/implab/gradle/common/tasks/TaskExtra.java~~ renamed +1 -1

-            package org.implab.gradle.common.tasks;
+            package org.implab.gradle.common.core.gradle;
             import org.gradle.api.Project;
             import org.gradle.api.Task;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.specs.Spec;
             import org.gradle.api.tasks.Internal;
             /** Task methods available by default, this interface is used by mixins to
              * interact with their task.
              */
             public interface TaskExtra {
                 @Internal
                 Project getProject();
                 void onlyIf(Spec<? super Task> spec);
                 @Internal
                 Logger getLogger();
                 default void onlyIfReason(String skipReason, Spec<? super Task> spec) {
                     onlyIf(self -> {
                         var satisfied = spec.isSatisfiedBy(self);
                         if (!satisfied)
                             getLogger().info("SKIP: {}", skipReason);
                         return satisfied;
                     });
                 }
             }

common/src/main/java/org/implab/gradle/common/core/lang/Closures.java ~~common/src/main/java/org/implab/gradle/common/utils/Closures.java~~ renamed +1 -1

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.lang;
             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(Closure.DELEGATE_FIRST);
                     c.setDelegate(target);
                     c.call(target);
                 }
             }

common/src/main/java/org/implab/gradle/common/core/lang/Exceptions.java ~~common/src/main/java/org/implab/gradle/common/utils/Exceptions.java~~ renamed +1 -2

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.lang;
             import java.util.function.Consumer;
             import java.util.function.Function;
             public class Exceptions {
                 /**
                  * Helper function which declares that this block can throw the specified
                  * exception.
                  *
                  * @param <E>
                  * @param clazz
                  * @throws E
                  */
-                @SuppressWarnings("unused")
                 public static <E extends Throwable> void mayThrow(Class<E> clazz) throws E {
                 }
                 @SuppressWarnings("unchecked")
                 public static <E extends Throwable> E sneakyThrow(Throwable t) throws E {
                     throw (E) t;
                 }
                 public static <T, U> Function<T, U> unchecked(ThrowingFunction<T, U> fn) {
                     return val -> {
                         try {
                             return fn.apply(val);
                         } catch (Exception e) {
                             throw sneakyThrow(e);
                         }
                     };
                 }
                 public static <T> Consumer<T> unchecked(ThrowingConsumer<T> c)  {
                     return val -> {
                         try {
                             c.accept(val);
                         } catch (Exception e) {
                             throw sneakyThrow(e);
                         }
                     };
                 }
                 public interface ThrowingConsumer<T> {
                     void accept(T value) throws Exception;
                 }
                 public interface ThrowingFunction<T, U> {
                     U apply(T value) throws Exception;
                 }
             }

common/src/main/java/org/implab/gradle/common/core/lang/LazyValue.java ~~common/src/main/java/org/implab/gradle/common/utils/LazyValue.java~~ renamed +17 -12

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.lang;
-            import java.util.concurrent.atomic.AtomicReference;
+            import java.util.Objects;
             import java.util.function.Supplier;
             public class LazyValue<T> implements Supplier<T> {
-                private final AtomicReference<T> reference = new AtomicReference<>();
+                private volatile T value;
                 private final Supplier<T> innerSupplier;
                 public LazyValue(Supplier<T> supplier) {
                     this.innerSupplier = supplier;
                 }
                 @Override
                 public T get() {
-                    var t = reference.get();
+                    var v = value;
-                    if (t != null)
+                    if (v != null) {
-                        return t;
+                        return v;
-                    return updateValue();
-                private T updateValue() {
+                    synchronized (this) {
-                    var v = innerSupplier.get();
+                        v = value;
-                    var t = reference.compareAndExchange(null, v);
+                        if (v == null) {
-                    return t != null ? t : v;
+                            v = Objects.requireNonNull(
+                                    innerSupplier.get(),
+                                    "LazyValue supplier returned null");
+                            value = v;
+                        }
+                        return v;
+                    }
                 }
             }

common/src/main/java/org/implab/gradle/common/core/lang/SemVersion.java ~~common/src/main/java/org/implab/gradle/common/utils/SemVersion.java~~ renamed +1 -1

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.lang;
             import com.fasterxml.jackson.annotation.JsonCreator;
             import com.fasterxml.jackson.annotation.JsonValue;
             import java.util.Objects;
             import java.util.Optional;
             import java.util.regex.Matcher;
             import java.util.regex.Pattern;
             /**
              * Immutable Semantic Version (SemVer 2.0.0) of the form:
              *
              * <pre>
              * MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]
              * </pre>
              *
              * Ordering (as defined by {@link #compareTo(SemVersion)}) follows
              * the SemVer 2.0.0 precedence rules:
              * <ul>
              * <li>Compare {@code major}, then {@code minor}, then {@code patch}.</li>
              * <li>Pre-release versions have lower precedence than the corresponding
              * normal version.</li>
              * <li>Build metadata does not affect precedence.</li>
              * </ul>
              *
              * Public API does not use {@code null} for semantic values:
              * {@link Optional} is used for pre-release and build metadata.
              */
             public record SemVersion(
                     int major,
                     int minor,
                     int patch,
                     Optional<String> preRelease,
                     Optional<String> buildMetadata) implements Comparable<SemVersion> {
                 // Pattern close to the official SemVer 2.0.0 recommendation.
                 // Groups:
                 // 1 - major
                 // 2 - minor
                 // 3 - patch
                 // 4 - pre-release (without '-')
                 // 5 - build metadata (without '+')
                 private static final Pattern SEMVER_PATTERN = Pattern.compile(
                         "^(0|[1-9]\\d*)" + // major
                                 "\\.(0|[1-9]\\d*)" + // minor
                                 "\\.(0|[1-9]\\d*)" + // patch
                                 "(?:-((?:0|[1-9]\\d*|[0-9A-Za-z-][0-9A-Za-z-]*)" +
                                 "(?:\\.(?:0|[1-9]\\d*|[0-9A-Za-z-][0-9A-Za-z-]*))*" +
                                 "))?" + // pre-release
                                 "(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$" // build metadata
                 );
                 /**
                  * Compact constructor with basic invariants.
                  */
                 public SemVersion {
                     if (major < 0 || minor < 0 || patch < 0) {
                         throw new IllegalArgumentException("Version numbers must be >= 0");
                     }
                     // Be tolerant internally, but never expose null Optionals.
                     preRelease = (preRelease != null) ? preRelease : Optional.empty();
                     buildMetadata = (buildMetadata != null) ? buildMetadata : Optional.empty();
                 }
                 /**
                  * Creates a version without pre-release and build metadata.
                  *
                  * @param major non-negative MAJOR number
                  * @param minor non-negative MINOR number
                  * @param patch non-negative PATCH number
                  */
                 public static SemVersion of(int major, int minor, int patch) {
                     return new SemVersion(major, minor, patch, Optional.empty(), Optional.empty());
                 }
                 /**
                  * Creates a version from components.
                  *
                  * @param major         non-negative MAJOR number
                  * @param minor         non-negative MINOR number
                  * @param patch         non-negative PATCH number
                  * @param preRelease    optional pre-release part (without '-')
                  * @param buildMetadata optional build metadata (without '+')
                  */
                 public static SemVersion of(
                         int major,
                         int minor,
                         int patch,
                         Optional<String> preRelease,
                         Optional<String> buildMetadata) {
                     return new SemVersion(
                             major,
                             minor,
                             patch,
                             Objects.requireNonNull(preRelease, "preRelease"),
                             Objects.requireNonNull(buildMetadata, "buildMetadata"));
                 }
                 /**
                  * Parses a SemVer string of the form
                  * {@code MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]}.
                  *
                  * @param value the string to parse (must not be {@code null})
                  * @return a new {@code SemVersion}
                  * @throws IllegalArgumentException if the string is not a valid SemVer
                  */
                 public static SemVersion parse(String value) {
                     Objects.requireNonNull(value, "value");
                     Matcher m = SEMVER_PATTERN.matcher(value);
                     if (!m.matches()) {
                         throw new IllegalArgumentException("Invalid SemVer: " + value);
                     }
                     int major = Integer.parseInt(m.group(1));
                     int minor = Integer.parseInt(m.group(2));
                     int patch = Integer.parseInt(m.group(3));
                     String pre = m.group(4);
                     String meta = m.group(5);
                     Optional<String> preOpt = Optional.ofNullable(pre);
                     Optional<String> metaOpt = Optional.ofNullable(meta);
                     // Extra validation for numeric pre-release identifiers (no leading zeros)
                     preOpt.ifPresent(SemVersion::validatePreReleaseIdentifiers);
                     return new SemVersion(major, minor, patch, preOpt, metaOpt);
                 }
                 private static void validatePreReleaseIdentifiers(String preRelease) {
                     String[] parts = preRelease.split("\\.");
                     for (String p : parts) {
                         if (isNumericIdentifier(p)) {
                             // numeric identifiers must not have leading zeros (except "0")
                             if (p.length() > 1 && p.charAt(0) == '0') {
                                 throw new IllegalArgumentException(
                                         "Numeric pre-release identifier must not contain leading zeros: " + p);
                             }
                         }
                     }
                 }
                 private static boolean isNumericIdentifier(String s) {
                     int len = s.length();
                     if (len == 0) {
                         return false;
                     }
                     for (int i = 0; i < len; i++) {
                         char c = s.charAt(i);
                         if (c < '0' || c > '9') {
                             return false;
                         }
                     }
                     return true;
                 }
                 /**
                  * Returns {@code true} if this version has a pre-release part.
                  *
                  * @return {@code true} if {@link #preRelease()} is present
                  */
                 public boolean isPreRelease() {
                     return preRelease().isPresent();
                 }
                 /**
                  * Returns {@code true} if this version is considered "stable".
                  * <p>
                  * By convention:
                  * <ul>
                  * <li>MAJOR must be greater than 0</li>
                  * <li>No pre-release part is present</li>
                  * </ul>
                  *
                  * @return {@code true} if this version is a stable release
                  */
                 public boolean isStable() {
                     return !isPreRelease() && major() > 0;
                 }
                 /**
                  * Returns {@code true} if this version has strictly lower precedence
                  * than the given {@code other} version according to
                  * {@link #compareTo(SemVersion)}.
                  *
                  * @param other the version to compare to
                  * @return {@code true} if {@code this.compareTo(other) < 0}
                  */
                 public boolean isBefore(SemVersion other) {
                     return compareTo(other) < 0;
                 }
                 /**
                  * Returns {@code true} if this version has strictly higher precedence
                  * than the given {@code other} version according to
                  * {@link #compareTo(SemVersion)}.
                  *
                  * @param other the version to compare to
                  * @return {@code true} if {@code this.compareTo(other) > 0}
                  */
                 public boolean isAfter(SemVersion other) {
                     return compareTo(other) > 0;
                 }
                 /**
                  * Canonical SemVer string representation.
                  * <p>
                  * This method is also used by Jackson during serialization.
                  *
                  * @return canonical SemVer string, e.g. {@code "1.2.3-alpha+build.1"}
                  */
                 @JsonValue
                 public String asString() {
                     StringBuilder sb = new StringBuilder()
                             .append(major).append('.')
                             .append(minor).append('.')
                             .append(patch);
                     preRelease.ifPresent(pr -> sb.append('-').append(pr));
                     buildMetadata.ifPresent(md -> sb.append('+').append(md));
                     return sb.toString();
                 }
                 /**
                  * Creates a {@code SemVersion} from a canonical SemVer string.
                  * <p>
                  * Jackson will use this factory method when deserializing from a JSON string.
                  *
                  * @param value canonical SemVer string
                  * @return parsed {@code SemVersion}
                  */
                 @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
                 public static SemVersion fromJson(String value) {
                     return parse(value);
                 }
                 /**
                  * Compares this version to another {@link SemVersion} according to the
                  * SemVer 2.0.0 precedence rules.
                  * <p>
                  * Build metadata is ignored for ordering.
                  */
                 @Override
                 public int compareTo(SemVersion other) {
                     // 1. major / minor / patch
                     int c = Integer.compare(this.major, other.major);
                     if (c != 0)
                         return c;
                     c = Integer.compare(this.minor, other.minor);
                     if (c != 0)
                         return c;
                     c = Integer.compare(this.patch, other.patch);
                     if (c != 0)
                         return c;
                     // 2. pre-release (absence > presence)
                     boolean thisHasPre = this.preRelease.isPresent();
                     boolean otherHasPre = other.preRelease.isPresent();
                     if (!thisHasPre && !otherHasPre) {
                         return 0;
                     } else if (!thisHasPre) {
                         // normal version > pre-release
                         return 1;
                     } else if (!otherHasPre) {
                         return -1;
                     }
                     // 3. both have pre-release: compare identifiers
                     return comparePreRelease(this.preRelease.get(), other.preRelease.get());
                 }
                 private static int comparePreRelease(String a, String b) {
                     String[] aParts = a.split("\\.");
                     String[] bParts = b.split("\\.");
                     int len = Math.min(aParts.length, bParts.length);
                     for (int i = 0; i < len; i++) {
                         String ai = aParts[i];
                         String bi = bParts[i];
                         boolean aNum = isNumericIdentifier(ai);
                         boolean bNum = isNumericIdentifier(bi);
                         if (aNum && bNum) {
                             int aiVal = Integer.parseInt(ai);
                             int biVal = Integer.parseInt(bi);
                             int c = Integer.compare(aiVal, biVal);
                             if (c != 0)
                                 return c;
                         } else if (aNum && !bNum) {
                             // numeric identifiers have lower precedence than non-numeric
                             return -1;
                         } else if (!aNum && bNum) {
                             return 1;
                         } else {
                             int c = ai.compareTo(bi);
                             if (c != 0)
                                 return c;
                         }
                     }
                     // If all common identifiers are equal, the shorter one has lower precedence
                     return Integer.compare(aParts.length, bParts.length);
                 }
                 @Override
                 public String toString() {
                     return asString();
                 }
             }

common/src/main/java/org/implab/gradle/common/core/lang/Strings.java ~~common/src/main/java/org/implab/gradle/common/utils/Strings.java~~ renamed +1 -1

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.lang;
             import java.util.regex.Pattern;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.provider.Provider;
             @NonNullByDefault
             public class Strings {
                 private static final Pattern firstLetter = Pattern.compile("^\\w");
                 public static String capitalize(String string) {
                     return string == null ? null
                             : string.length() == 0 ? string
                                     : firstLetter.matcher(string).replaceFirst(m -> m.group().toUpperCase());
                 }
                 public static String toCamelCase(String name) {
                     if (name == null || name.isEmpty())
                         return name;
                     StringBuilder out = new StringBuilder(name.length());
                     boolean up = false;
                     boolean first = true;
                     for (int i = 0; i < name.length(); i++) {
                         char c = name.charAt(i);
                         switch (c) {
                             case '-', '_', ' ', '.' -> up = true;
                             default -> {
                                 out.append(
                                         first ? Character.toLowerCase(c)
                                                 : up ? Character.toUpperCase(c): c);
                                 up = false;
                                 first = false;
                             }
                         }
                     }
                     return out.toString();
                 }
                 public static void argumentNotNullOrEmpty(String value, String argumentName) {
                     if (value == null || value.length() == 0)
                         throw new IllegalArgumentException(String.format("Argument %s can't be null or empty", argumentName));
                 }
                 public static String asString(Object value) {
                     if (value == null)
                         return null;
                     if (value instanceof Provider<?> provider)
                         return asString(provider.get());
                     else
                         return value.toString();
                 }
             }

common/src/main/java/org/implab/gradle/common/core/lang/Values.java ~~common/src/main/java/org/implab/gradle/common/utils/Values.java~~ renamed +1 -1

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.lang;
             import java.text.MessageFormat;
             import java.util.Iterator;
             import java.util.Spliterators;
             import java.util.Optional;
             import java.util.function.Supplier;
             import java.util.stream.Stream;
             import java.util.stream.StreamSupport;
             import org.gradle.api.provider.Provider;
             public final class Values {
                 private Values() {
                 }
                 /**
                  * 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();
                 }
                 public static <T> T required(Provider<T> provider, String providerName) {
                     if (!provider.isPresent())
                         throw new IllegalStateException(
                                 MessageFormat.format("The value for the '{0}' provider must be specified", providerName));
                     return provider.get();
                 }
                 public static boolean parseBoolean(Object value) {
                     if (value instanceof Boolean) {
                         return (Boolean) value;
                     } else {
                         var text = toString(value);
                         switch (text != null ? text.toLowerCase() : "") {
                             case "true", "yes", "1" ->  {
                                 return true;
                             }
                             case "false", "no", "0", "" -> {
                                 return false;
                             }
                             default -> throw new IllegalArgumentException(
                                     MessageFormat.format("Cannot parse boolean value from ''{0}''", text));
                         }
                     }
                 }
                 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/core/os/FreeBsd.java ~~common/src/main/java/org/implab/gradle/common/utils/os/FreeBsd.java~~ renamed +2 -4

-            package org.implab.gradle.common.utils.os;
+            package org.implab.gradle.common.core.os;
-            import org.implab.gradle.common.utils.OperatingSystem;
+            class FreeBsd extends GenericSystem{
-            public class FreeBsd extends GenericSystem{
                 FreeBsd(String name, String version) {
                     super(name, version);
                 }
                 @Override
                 public String family() {
                     return OperatingSystem.FREE_BSD_FAMILY;
                 }
             }

common/src/main/java/org/implab/gradle/common/core/os/GenericSystem.java ~~common/src/main/java/org/implab/gradle/common/utils/os/GenericSystem.java~~ renamed +2 -3

-            package org.implab.gradle.common.utils.os;
+            package org.implab.gradle.common.core.os;
             import java.io.File;
             import java.util.Arrays;
             import java.util.Optional;
             import java.util.function.Function;
             import java.util.regex.Pattern;
             import java.util.stream.Stream;
-            import org.implab.gradle.common.utils.OperatingSystem;
+            import org.implab.gradle.common.core.lang.Values;
-            import org.implab.gradle.common.utils.Values;
             class GenericSystem implements OperatingSystem {
                 private final String name;
                 private final String version;
                 GenericSystem(String name, String version) {
                     this.name = name;
                     this.version = version;
                 }
                 public String getPathVar() {
                     return "PATH";
                 }
                 @Override
                 public String family() {
                     return OperatingSystem.UNKNOWN_FAMILY;
                 }
                 @Override
                 public String name() {
                     return name;
                 }
                 @Override
                 public String version() {
                     return version;
                 }
                 protected Stream<File> getPath() {
                     String path = System.getenv(getPathVar());
                     return path == null
                             ? Stream.empty()
                             : Arrays.stream(path.split(Pattern.quote(File.pathSeparator)))
                                     .map(File::new);
                 }
                 protected Function<File, Stream<File>> candidates(String cmd) {
                     return base -> Stream.of(new File(base, cmd));
                 }
                 @Override
                 public Optional<File> which(String cmd) {
                     return getPath().flatMap(candidates(cmd)).filter(File::isFile).findAny();
                 }
                 @Override
                 public Optional<File> which(String cmd, Iterable<? extends File> paths) {
                     return Values.stream(paths.iterator()).flatMap(candidates(cmd)).filter(File::isFile).findAny();
                 }
             }

common/src/main/java/org/implab/gradle/common/core/os/Linux.java ~~common/src/main/java/org/implab/gradle/common/utils/os/Linux.java~~ renamed +2 -4

-            package org.implab.gradle.common.utils.os;
+            package org.implab.gradle.common.core.os;
-            import org.implab.gradle.common.utils.OperatingSystem;
+            class Linux extends GenericSystem {
-            public class Linux extends GenericSystem {
                 Linux(String name, String version) {
                     super(name, version);
                 }
                 @Override
                 public String family() {
                     return OperatingSystem.LINUX_FAMILY;
                 }
             }

common/src/main/java/org/implab/gradle/common/core/os/MacOs.java ~~common/src/main/java/org/implab/gradle/common/utils/os/MacOs.java~~ renamed +2 -4

-            package org.implab.gradle.common.utils.os;
+            package org.implab.gradle.common.core.os;
-            import org.implab.gradle.common.utils.OperatingSystem;
+            class MacOs extends GenericSystem {
-            public class MacOs extends GenericSystem {
                 MacOs(String name, String version) {
                     super(name, version);
                 }
                 @Override
                 public String family() {
                     return OperatingSystem.MAC_OS_FAMILY;
                 }
             }

common/src/main/java/org/implab/gradle/common/core/os/OperatingSystem.java ~~common/src/main/java/org/implab/gradle/common/utils/OperatingSystem.java~~ renamed +1 -3

-            package org.implab.gradle.common.utils;
+            package org.implab.gradle.common.core.os;
             import java.io.File;
             import java.util.Optional;
-            import org.implab.gradle.common.utils.os.SystemResolver;
             public interface OperatingSystem {
                 public static final String WINDOWS_FAMILY = "windows";
                 public static final String LINUX_FAMILY = "linux";
                 public static final String FREE_BSD_FAMILY = "freebsd";
                 public static final String MAC_OS_FAMILY = "os x";
                 public static final String UNKNOWN_FAMILY = "unknown";
                 String family();
                 String name();
                 String version();
                 Optional<File> which(String cmd);
                 Optional<File> which(String cmd, Iterable<? extends File> paths);
                 public static OperatingSystem current() {
                     return SystemResolver.current();
                 }
             }

common/src/main/java/org/implab/gradle/common/core/os/SystemResolver.java ~~common/src/main/java/org/implab/gradle/common/utils/os/SystemResolver.java~~ renamed +3 -4

-            package org.implab.gradle.common.utils.os;
+            package org.implab.gradle.common.core.os;
-            import org.implab.gradle.common.utils.LazyValue;
+            import org.implab.gradle.common.core.lang.LazyValue;
-            import org.implab.gradle.common.utils.OperatingSystem;
-            public class SystemResolver {
+            class SystemResolver {
                 private final static LazyValue<OperatingSystem> current = new LazyValue<>(SystemResolver::resolveCurrent);
                 private static OperatingSystem resolveCurrent() {
                     var osName = System.getProperty("os.name");
                     var osVersion = System.getProperty("os.version");
                     return forName(osName, osVersion);
                 }
                 public static OperatingSystem current() {
                     return current.get();
                 }
                 public static OperatingSystem forName(String os, String version) {
                     var osName = os.toLowerCase();
                     if (osName.contains("windows")) {
                         return new Windows(osName, version);
                     } else if (osName.contains("mac os x") || osName.contains("darwin") || osName.contains("osx")) {
                         return new MacOs(osName, version);
                     } else if (osName.contains("linux")) {
                         return new Linux(osName, version);
                     } else if (osName.contains("freebsd")) {
                         return new FreeBsd(osName, version);
                     } else {
                         // Not strictly true
                         return new GenericSystem(osName, version);
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/core/os/Windows.java ~~common/src/main/java/org/implab/gradle/common/utils/os/Windows.java~~ renamed +1 -3

-            package org.implab.gradle.common.utils.os;
+            package org.implab.gradle.common.core.os;
             import java.io.File;
             import java.util.function.Function;
             import java.util.stream.Stream;
-            import org.implab.gradle.common.utils.OperatingSystem;
             class Windows extends GenericSystem {
                 private Stream<String> exeSuffixes = Stream.of(".cmd", ".bat", ".exe");
                 Windows(String name, String version) {
                     super(name, version);
                 }
                 @Override
                 public String family() {
                     return OperatingSystem.WINDOWS_FAMILY;
                 }
                 @Override
                 protected Function<File, Stream<File>> candidates(String cmd) {
                     return base -> exeSuffixes.map(suffix -> new File(base, cmd + suffix));
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/dsl/RedirectFromSpec.java ~~common/src/main/java/org/implab/gradle/common/dsl/RedirectFromSpec.java~~ renamed +3 -3

-            package org.implab.gradle.common.dsl;
+            package org.implab.gradle.common.exec.dsl;
             import java.io.File;
             import java.io.InputStream;
             import java.util.Optional;
             import java.util.function.Supplier;
             import org.gradle.api.provider.Provider;
             import org.gradle.util.Configurable;
-            import org.implab.gradle.common.exec.RedirectFrom;
+            import org.implab.gradle.common.core.lang.Closures;
-            import org.implab.gradle.common.utils.Closures;
+            import org.implab.gradle.common.exec.runtime.RedirectFrom;
             import groovy.lang.Closure;
             public class RedirectFromSpec implements Configurable<RedirectFromSpec> {
                 private Supplier<RedirectFrom> streamRedirect;
                 public boolean isRedirected() {
                     return streamRedirect != null;
                 }
                 public Optional<RedirectFrom> getRedirection() {
                     return streamRedirect != null ? Optional.ofNullable(streamRedirect.get()) : Optional.empty();
                 }
                 public void fromFile(File file) {
                     streamRedirect = () -> RedirectFrom.file(file);
                 }
                 public void fromFile(Provider<File> fileProvider) {
                     streamRedirect = fileProvider.map(RedirectFrom::file)::getOrNull;
                 }
                 public void fromStream(InputStream stream) {
                     streamRedirect = () -> RedirectFrom.stream(stream);
                 }
                 public void fromStream(Provider<InputStream> streamProvider) {
                     streamRedirect = streamProvider.map(RedirectFrom::stream)::getOrNull;
                 }
                 public void from(Object input) {
                     if (input instanceof Provider<?> inputProvider) {
                         streamRedirect = inputProvider.map(RedirectFrom::any)::get;
                     } else {
                         streamRedirect = () -> RedirectFrom.any(input);
                     }
                 }
                 public void empty() {
                     streamRedirect = () -> null;
                 }
                 @Override
                 public RedirectFromSpec configure(Closure cl) {
                     Closures.apply(cl, this);
                     return this;
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/dsl/RedirectToSpec.java ~~common/src/main/java/org/implab/gradle/common/dsl/RedirectToSpec.java~~ renamed +3 -3

-            package org.implab.gradle.common.dsl;
+            package org.implab.gradle.common.exec.dsl;
             import java.io.File;
             import java.io.OutputStream;
             import java.util.Optional;
             import java.util.function.Consumer;
             import java.util.function.Supplier;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.eclipse.jdt.annotation.Nullable;
             import org.gradle.api.provider.Provider;
             import org.gradle.util.Configurable;
-            import org.implab.gradle.common.exec.RedirectTo;
+            import org.implab.gradle.common.core.lang.Closures;
-            import org.implab.gradle.common.utils.Closures;
+            import org.implab.gradle.common.exec.runtime.RedirectTo;
             import groovy.lang.Closure;
             @NonNullByDefault
             public class RedirectToSpec implements Configurable<RedirectToSpec> {
                 private Supplier<RedirectTo> streamRedirect;
                 public boolean isRedirected() {
                     return getRedirection().isPresent();
                 }
                 public Optional<RedirectTo> getRedirection() {
                     return streamRedirect != null ? Optional.ofNullable(streamRedirect.get()) : Optional.empty();
                 }
                 public @Nullable RedirectTo getRedirectionOrNull() {
                     return streamRedirect != null ? streamRedirect.get() : null;
                 }
                 public void toFile(File file) {
                     streamRedirect = () -> RedirectTo.file(file);
                 }
                 public void toFile(Provider<File> fileProvider) {
                     streamRedirect = fileProvider.map(RedirectTo::file)::getOrNull;
                 }
                 public void toStream(OutputStream stream) {
                     streamRedirect = () -> RedirectTo.stream(stream);
                 }
                 public void toStream(Provider<OutputStream> streamProvider) {
                     streamRedirect = streamProvider.map(RedirectTo::stream)::getOrNull;
                 }
                 public void to(Object output) {
                     if (output instanceof Provider<?> outputProvider) {
                         streamRedirect = outputProvider.map(RedirectTo::any)::get;
                     } else {
                         streamRedirect = () -> RedirectTo.any(output);
                     }
                 }
                 public void eachLine(Consumer<String> consumer) {
                     streamRedirect = () -> RedirectTo.eachLine(consumer);
                 }
                 public void allText(Consumer<String> consumer) {
                     streamRedirect = () -> RedirectTo.allText(consumer);
                 }
                 public void discard() {
                     streamRedirect = () -> null;
                 }
                 @Override
                 public RedirectToSpec configure(Closure cl) {
                     Closures.apply(cl, this);
                     return this;
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/dsl/TaskCommandSpecMixin.java ~~common/src/main/java/org/implab/gradle/common/dsl/TaskCommandSpecMixin.java~~ renamed +2 -2

-            package org.implab.gradle.common.dsl;
+            package org.implab.gradle.common.exec.dsl;
             import java.util.stream.Stream;
             import org.gradle.api.provider.ListProperty;
-            import org.implab.gradle.common.utils.Properties;
+            import org.implab.gradle.common.core.gradle.Properties;
             public interface TaskCommandSpecMixin {
                 ListProperty<String> getCommandLine();
                 default void commandLine(Object arg0, Object... args) {
                     getCommandLine().empty();
                     Properties.mergeList(
                             getCommandLine(),
                             () -> Stream.concat(Stream.of(arg0), Stream.of(args)).iterator(),
                             Object::toString);
                 }
                 default void args(Object arg0, Object... args) {
                     Properties.mergeList(
                             getCommandLine(),
                             () -> Stream.concat(Stream.of(arg0), Stream.of(args)).iterator(),
                             Object::toString);
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/dsl/TaskEnvSpecMixin.java ~~common/src/main/java/org/implab/gradle/common/dsl/TaskEnvSpecMixin.java~~ renamed +3 -3

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

common/src/main/java/org/implab/gradle/common/exec/dsl/TaskPipeSpecMixin.java ~~common/src/main/java/org/implab/gradle/common/dsl/TaskPipeSpecMixin.java~~ renamed +1 -1

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

common/src/main/java/org/implab/gradle/common/exec/model/CommandArgumentsBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/CommandArgumentsBuilder.java~~ renamed +2 -2

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.model;
             import static java.util.Objects.requireNonNull;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
-            import org.implab.gradle.common.utils.Values;
+            import org.implab.gradle.common.core.lang.Values;
             @NonNullByDefault
             public interface CommandArgumentsBuilder<S extends CommandArgumentsBuilder<S>> {
                 S self();
                 default S flag(String name, boolean value) {
                     requireNonNull(name, "Parameter name cannot be null");
                     if (value)
                         addArguments(name);
                     return self();
                 }
                 default S param(String name, String value) {
                     requireNonNull(name, "Parameter name cannot be null");
                     requireNonNull(value, "Parameter value cannot be null");
                     if (value != null && value.length() > 0)
                         addArguments(name, value);
                     return self();
                 }
                 default S param(String name, Optional<String> value) {
                     value.ifPresent(v -> param(name, v));
                     return self();
                 }
                 /** Adds the specified arguments to this builder */
                 S addArguments(String... args);
                 default S addArguments(Iterable<String> args) {
                     for (String arg : args)
                         addArguments(arg);
                     return self();
                 }
                 /** Replaces arguments in the builder with the specified one. */
                 default S arguments(String... args) {
                     return arguments(Values.iterable(args));
                 }
                 /** Replaces arguments in the builder with the specified one. */
                 S arguments(Iterable<String> args);
             }

common/src/main/java/org/implab/gradle/common/exec/model/CommandBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/CommandBuilder.java~~ renamed +2 -2

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.model;
             import java.io.File;
             import org.eclipse.jdt.annotation.NonNullByDefault;
-            import org.implab.gradle.common.utils.Values;
+            import org.implab.gradle.common.core.lang.Values;
             /** Command builder interface, used to specify the executable and parameters */
             @NonNullByDefault
             public interface CommandBuilder extends CommandArgumentsBuilder<CommandBuilder> {
                 @Override
                 default CommandBuilder self() {
                     return this;
                 }
                 /** Sets the executable, the parameters are left intact. */
                 CommandBuilder executable(String executable);
                 default CommandBuilder executable(File executable) {
                     executable(executable.toString());
                     return this;
                 }
                 /**
                  * Sets the specified executable and parameters, old executable and parameters
                  * are discarded.
                  */
                 default CommandBuilder commandLine(String executable, String... args) {
                     return executable(executable)
                             .arguments(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;
                 }
                 default CommandBuilder from(CommandSpec commandSpec) {
                     return executable(commandSpec.executable())
                             .arguments(commandSpec.arguments());
                 }
                 CommandSpec build();
             }

common/src/main/java/org/implab/gradle/common/exec/model/CommandSpec.java ~~common/src/main/java/org/implab/gradle/common/exec/CommandSpec.java~~ renamed +1 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.model;
             import java.util.List;
             import java.util.stream.Stream;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             @NonNullByDefault
             public interface CommandSpec {
                 String executable();
                 List<String> arguments();
                 default List<String> commandLine() {
                     return Stream.concat(Stream.of(executable()), arguments().stream()).toList();
                 }
                 public static CommandBuilder builder() {
                     return new CommandSpecRecord.Builder();
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/model/CommandSpecRecord.java ~~common/src/main/java/org/implab/gradle/common/exec/CommandSpecRecord.java~~ renamed +1 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.model;
             import java.util.List;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import static java.util.Objects.requireNonNull;
             import java.util.ArrayList;
             @NonNullByDefault
             public record CommandSpecRecord(String executable, List<String> arguments) implements CommandSpec {
                 static class Builder implements CommandBuilder {
                     private String executable;
                     private List<String> arguments = new ArrayList<>();
                     @Override
                     public CommandBuilder executable(String executable) {
                         requireNonNull(executable, "cmd can't be null");
                         this.executable = executable;
                         return this;
                     }
                     @Override
                     public CommandBuilder arguments(Iterable<String> args) {
                         requireNonNull(args, "Args must not be null");
                         arguments.clear();
                         for (var arg : args)
                             arguments.add(arg);
                         return this;
                     }
                     @Override
                     public CommandBuilder addArguments(String... args) {
                         for (var arg : args)
                             arguments.add(requireNonNull(arg, "arguments element shouldn't be null"));
                         return this;
                     }
                     @Override
                     public CommandSpec build() {
                         requireNonNull(executable, "Executable must be specified");
                         return new CommandSpecRecord(executable, arguments);
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/model/EnvironmentSpec.java ~~common/src/main/java/org/implab/gradle/common/exec/EnvironmentSpec.java~~ renamed +1 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.model;
             import java.io.File;
             import java.util.Map;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             @NonNullByDefault
             public interface EnvironmentSpec {
                 boolean inheritEnvironment();
                 Map<String,String> environment();
                 Optional<File> workingDirectory();
             }

common/src/main/java/org/implab/gradle/common/exec/model/PipeSpec.java ~~common/src/main/java/org/implab/gradle/common/exec/PipeSpec.java~~ renamed +4 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.model;
+            import org.implab.gradle.common.exec.runtime.RedirectFrom;
+            import org.implab.gradle.common.exec.runtime.RedirectTo;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             /**
              * The execution shell uses this specification when starting
              * a new process. The shell may check for the specified
              * redirections and apply them when launching the process.
              * The exact moment they are applied is at the shell’s discretion.
              */
             @NonNullByDefault
             public interface PipeSpec {
                 Optional<RedirectTo> stdout();
                 Optional<RedirectTo> stderr();
                 Optional<RedirectFrom> stdin();
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/AbstractExecBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/AbstractExecBuilder.java~~ renamed +3 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.util.HashMap;
             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 org.implab.gradle.common.exec.model.EnvironmentSpec;
+            import org.implab.gradle.common.exec.model.PipeSpec;
             import java.io.File;
             import java.io.IOException;
             import static java.util.Objects.requireNonNull;
             /** Command line builder */
             @NonNullByDefault
             public abstract class AbstractExecBuilder<CS> implements ShellExec {
                 private boolean inheritEnvironment = true;
                 private final Map<String, String> environment = new HashMap<>();
                 private @Nullable File directory;
                 private RedirectFrom inputRedirect;
                 private RedirectTo outputRedirect;
                 private RedirectTo errorRedirect;
                 private final CS command;
                 protected AbstractExecBuilder(CS command) {
                     this.command = command;
                 }
                 /** Sets the working directory */
                 @Override
                 public ShellExec workingDirectory(File directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory;
                     return this;
                 }
                 @Override
                 public ShellExec workingDirectory(Optional<? extends File> directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory.orElse(null);
                     return this;
                 }
                 @Override
                 public ShellExec inheritEnvironment(boolean inherit) {
                     this.inheritEnvironment = inherit;
                     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 ShellExec putEnvironment(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 ShellExec 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 ShellExec stdin(RedirectFrom from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from;
                     return this;
                 }
                 @Override
                 public ShellExec 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 ShellExec stdout(RedirectTo out) {
                     requireNonNull(out, "out parameter can't be null");
                     outputRedirect = out;
                     return this;
                 }
                 @Override
                 public ShellExec 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 ShellExec stderr(RedirectTo err) {
                     requireNonNull(err, "err parameter can't be null");
                     errorRedirect = err;
                     return this;
                 }
                 @Override
                 public ShellExec stderr(Optional<? extends RedirectTo> to) {
                     requireNonNull(to, "from parameter can't be null");
                     errorRedirect = to.orElse(null);
                     return this;
                 }
                 @Override
                 public ShellExec from(PipeSpec pipeSpec) {
                     ShellExec.super.from(pipeSpec);
                     return this;
                 }
                 @Override
                 public ShellExec from(EnvironmentSpec environmentSpec) {
                     ShellExec.super.from(environmentSpec);
                     return this;
                 }
                 /** Implement this function to */
                 protected abstract CompletableFuture<Integer> startInternal(
                         CS command,
                         EnvironmentSpec environment,
                         PipeSpec redirect) 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> exec() throws IOException {
                     return startInternal(
                             command,
                             new SelfEnvironmentSpec(),
                             new SelfPipeSpec());
                 }
                 private class SelfEnvironmentSpec implements EnvironmentSpec {
                     @Override
                     public boolean inheritEnvironment() {
                         return inheritEnvironment;
                     }
                     @Override
                     public Map<String, String> environment() {
                         return environment;
                     }
                     @Override
                     public Optional<File> workingDirectory() {
                         return Optional.ofNullable(directory);
                     }
                 }
                 private class SelfPipeSpec implements PipeSpec {
                     @Override
                     public Optional<RedirectTo> stdout() {
                         return Optional.ofNullable(outputRedirect);
                     }
                     @Override
                     public Optional<RedirectTo> stderr() {
                         return Optional.ofNullable(errorRedirect);
                     }
                     @Override
                     public Optional<RedirectFrom> stdin() {
                         return Optional.ofNullable(inputRedirect);
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/EchoExecBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/EchoExecBuilder.java~~ renamed +4 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.io.ByteArrayInputStream;
             import java.io.IOException;
             import java.nio.charset.StandardCharsets;
             import java.util.concurrent.CompletableFuture;
             import java.util.stream.Collectors;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.implab.gradle.common.exec.model.CommandSpec;
+            import org.implab.gradle.common.exec.model.EnvironmentSpec;
+            import org.implab.gradle.common.exec.model.PipeSpec;
             @NonNullByDefault
             class EchoExecBuilder extends AbstractExecBuilder<CommandSpec> {
                 private final boolean echoToStderr;
                 public EchoExecBuilder(CommandSpec command, boolean echoToStderr) {
                     super(command);
                     this.echoToStderr = echoToStderr;
                 }
                 @Override
                 protected CompletableFuture<Integer> startInternal(
                         CommandSpec command,
                         EnvironmentSpec environment,
                         PipeSpec redirect) throws IOException {
                     var outputRedirect = echoToStderr ? redirect.stderr() : redirect.stdout();
                     return outputRedirect
                             .map(to -> {
                                 var bytes = String
                                         .format(
                                                 "exec: %s",
                                                 command.commandLine().stream().collect(Collectors.joining(" ")))
                                         .getBytes(StandardCharsets.UTF_8);
                                 return to.redirect(new ByteArrayInputStream(bytes))
                                         .thenApply((x) -> 0);
                             })
                             .orElse(CompletableFuture.completedFuture(0));
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/EnvironmentBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/EnvironmentBuilder.java~~ renamed +2 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.io.File;
             import java.util.Map;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.implab.gradle.common.exec.model.EnvironmentSpec;
             @NonNullByDefault
             public interface EnvironmentBuilder {
                 /** Sets the specified environment variable */
                 EnvironmentBuilder putEnvironment(String envVar, String value);
                 /** Replaces environment with the supplied one */
                 EnvironmentBuilder environment(Map<String, ? extends String> env);
                 /**
                  * Enables or disables environment inheritance for the child process
                  */
                 EnvironmentBuilder inheritEnvironment(boolean inherit);
                 /** Specifies the working directory */
                 EnvironmentBuilder workingDirectory(File directory);
                 /** Specifies the working directory */
                 EnvironmentBuilder workingDirectory(Optional<? extends File> directory);
                 /** Copies the supplied environment to this one */
                 default EnvironmentBuilder from(EnvironmentSpec environmentSpec) {
                     return environment(environmentSpec.environment())
                         .workingDirectory(environmentSpec.workingDirectory());
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/PipeBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/PipeBuilder.java~~ renamed +2 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.implab.gradle.common.exec.model.PipeSpec;
             @NonNullByDefault
             public interface PipeBuilder {
                 PipeBuilder stdin(RedirectFrom from);
                 PipeBuilder stdin(Optional<? extends RedirectFrom> from);
                 PipeBuilder stdout(RedirectTo to);
                 PipeBuilder stdout(Optional<? extends RedirectTo> to);
                 PipeBuilder stderr(RedirectTo to);
                 PipeBuilder stderr(Optional<? extends RedirectTo> to);
                 default PipeBuilder from(PipeSpec pipeSpec) {
                     return stdin(pipeSpec.stdin())
                             .stdout(pipeSpec.stdout())
                             .stderr(pipeSpec.stderr());
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/RedirectFrom.java ~~common/src/main/java/org/implab/gradle/common/exec/RedirectFrom.java~~ renamed +1 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.io.File;
             import java.io.FileInputStream;
             import java.io.InputStream;
             import java.io.OutputStream;
             import java.util.concurrent.CompletableFuture;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             /**
              * Describes how to redirect input streams. This interface is used to configure
              * lazy redirection. {@link #redirect(OutputStream)} is called when the process
              * is started. Before the process is started the redirection isn't invoked and
              * no resources are allocated or used.
              */
             @NonNullByDefault
             public interface RedirectFrom {
                 CompletableFuture<Void> redirect(OutputStream to);
                 /**
                  * Read file contents and redirect it to the output stream.
                  */
                 public static RedirectFrom file(final File file) {
                     return to -> CompletableFuture.runAsync(() -> {
                         try (var from = new FileInputStream(file); to) {
                             from.transferTo(to);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
                 public static RedirectFrom stream(final InputStream from) {
                     return to -> CompletableFuture.runAsync(() -> {
                         try (from; to) {
                             from.transferTo(to);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
                 public static RedirectFrom any(final Object output) {
                     if (output instanceof File f) {
                         return file(f);
                     } else if (output instanceof InputStream stm) {
                         return stream(stm);
                     } else if (output instanceof RedirectFrom self) {
                         return self;
                     } else {
                         throw new IllegalArgumentException("The specified argument type isn't supported: " + output.getClass());
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/RedirectTo.java ~~common/src/main/java/org/implab/gradle/common/exec/RedirectTo.java~~ renamed +2 -2

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.io.File;
             import java.io.FileOutputStream;
             import java.io.InputStream;
             import java.io.OutputStream;
             import java.util.Scanner;
             import java.util.concurrent.CompletableFuture;
             import java.util.function.Consumer;
             import java.util.stream.Collectors;
             import java.util.stream.Stream;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             /**
              * Redirection specification for the {@link InputStream}. Redirection is invoked
              * when the {@link InputStream} becomes available, for example, on process
              * start. Before the process is started the redirection isn't invoked and no
              * resources are allocated or used.
              */
             @NonNullByDefault
             public interface RedirectTo {
                 CompletableFuture<Void> redirect(InputStream from);
                 public interface StringConsumer extends Consumer<String> {
                     default void complete() {
                     }
                 }
                 /** Creates a redirect to the specified consumer */
                 public static RedirectTo eachLine(final Consumer<String> consumer) {
                     return consumer(new StringConsumer() {
                         @Override
                         public void accept(String s) {
                             consumer.accept(s);
                         }
                     });
                 }
                 public static RedirectTo allText(final Consumer<String> consumer) {
                     return consumer(new StringConsumer() {
                         final Stream.Builder<String> builder = Stream.builder();
                         @Override
                         public void accept(String s) {
                             builder.accept(s);
                         }
                         @Override
                         public void complete() {
                             consumer.accept(builder.build().collect(Collectors.joining("\n")));
                         }
                     });
                 }
                 /** Creates a redirect to the specified consumer */
                 public static RedirectTo consumer(final StringConsumer consumer) {
                     return (src) -> CompletableFuture.runAsync(() -> {
                         try (Scanner sc = new Scanner(src)) {
                             while (sc.hasNextLine()) {
                                 consumer.accept(sc.nextLine());
                             }
                             consumer.complete();
                         }
                     });
                 }
                 /**
                  * Creates a redirect to the specified file. There will be opened the output
                  * stream in this redirection and original stream will be transferred to this
                  * this output stream.
                  */
                 public static RedirectTo file(final File file) {
                     return src -> CompletableFuture.runAsync(() -> {
                         try (src; OutputStream out = new FileOutputStream(file)) {
                             src.transferTo(out);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
                 /** Creates a redirect to the specified output stream. */
                 public static RedirectTo stream(final OutputStream dest) {
                     return src -> CompletableFuture.runAsync(() -> {
                         try (dest; src) {
                             src.transferTo(dest);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
                 /**
                  * Creates the redirection to the specified destination, actual type of
                  * redirection will be determined from the type of the output object.
                  */
                 public static RedirectTo any(final Object output) {
                     if (output instanceof StringConsumer fn) {
                         return consumer(s -> fn.accept(s));
                     } else if (output instanceof File f) {
                         return file(f);
                     } else if (output instanceof OutputStream stm) {
                         return stream(stm);
                     } else if (output instanceof RedirectTo self) {
                         return self;
                     } else {
                         throw new IllegalArgumentException("The specified argument type isn't supported: " + output.getClass());
                     }
                 }
-            }
  No newline at end of file

common/src/main/java/org/implab/gradle/common/exec/runtime/Shell.java ~~common/src/main/java/org/implab/gradle/common/exec/Shell.java~~ renamed +2 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.implab.gradle.common.exec.model.CommandSpec;
             @NonNullByDefault
             public interface Shell {
                 ShellExec create(CommandSpec spec);
                 default ShellTool tool(String executable) {
                     return new ShellTool(executable, this);
                 }
                 /** Creates a new shell to start processes using ProcessBuilder. */
                 static Shell system() {
                     return spec -> new SystemExecBuilder(spec);
                 }
                 /** Creates a stub shell which echoes the specified command line. */
                 static Shell echo() {
                     return spec -> new EchoExecBuilder(spec, false);
                 }
                 /** Creates a stub shell which echoes the specified command line. */
                 static Shell echoStderr() {
                     return spec -> new EchoExecBuilder(spec, false);
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/ShellExec.java ~~common/src/main/java/org/implab/gradle/common/exec/ShellExec.java~~ renamed +2 -2

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.io.IOException;
             import java.util.ArrayList;
             import java.util.List;
             import java.util.concurrent.CompletableFuture;
             import org.eclipse.jdt.annotation.NonNullByDefault;
-            import org.implab.gradle.common.utils.Exceptions;
+            import org.implab.gradle.common.core.lang.Exceptions;
             @NonNullByDefault
             public interface ShellExec extends PipeBuilder, EnvironmentBuilder {
                 default CompletableFuture<List<String>> readAllLines() throws IOException {
                     List<String> lines = new ArrayList<>();
                     stdout(RedirectTo.consumer(lines::add));
                     return exec()
                         .thenAccept(Exceptions.unchecked(this::assertExitCode))
                         .thenApply(v -> lines);
                 }
                 default CompletableFuture<String> readAllText() throws IOException {
                     List<String> lines = new ArrayList<>();
                     stdout(RedirectTo.consumer(lines::add));
                     return exec()
                             .thenAccept(Exceptions.unchecked(this::assertExitCode))
                             .thenApply(v -> String.join("\n", lines));
                 }
                 default void assertExitCode(Integer code) throws IOException {
                     if (code != 0)
                         throw new IOException(String.format("The process is terminated with code %d", code));
                 }
                 CompletableFuture<Integer> exec() throws IOException;
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/ShellTool.java ~~common/src/main/java/org/implab/gradle/common/exec/ShellTool.java~~ renamed +3 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
+            import org.implab.gradle.common.exec.model.CommandArgumentsBuilder;
+            import org.implab.gradle.common.exec.model.CommandSpec;
             @NonNullByDefault
             public class ShellTool {
                 private final Shell shell;
                 private final String executable;
                 ShellTool(String executable, Shell shell) {
                     this.shell = shell;
                     this.executable = executable;
                 }
                 public ShellExec arguments(String... args) {
                     return shell.create(CommandSpec.builder()
                             .executable(executable)
                             .arguments(args)
                             .build());
                 }
                 public ShellExec arguments(Iterable<String> args) {
                     return shell.create(CommandSpec.builder()
                             .executable(executable)
                             .arguments(args)
                             .build());
                 }
                 public ShellExec arguments(Action<CommandArgumentsBuilder<?>> args) {
                     var builder = CommandSpec.builder()
                             .executable(executable);
                     args.execute(builder);
                     return shell.create(builder.build());
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/runtime/SystemExecBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/SystemExecBuilder.java~~ renamed +4 -1

-            package org.implab.gradle.common.exec;
+            package org.implab.gradle.common.exec.runtime;
             import java.io.IOException;
             import java.lang.ProcessBuilder.Redirect;
             import java.util.ArrayList;
             import java.util.concurrent.CompletableFuture;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.implab.gradle.common.exec.model.CommandSpec;
+            import org.implab.gradle.common.exec.model.EnvironmentSpec;
+            import org.implab.gradle.common.exec.model.PipeSpec;
             @NonNullByDefault
             class SystemExecBuilder extends AbstractExecBuilder<CommandSpec> {
                 SystemExecBuilder(CommandSpec command) {
                     super(command);
                 }
                 @Override
                 protected CompletableFuture<Integer> startInternal(
                         CommandSpec command,
                         EnvironmentSpec environment,
                         PipeSpec redirect) throws IOException {
                     var builder = new ProcessBuilder(command.commandLine());
                     environment.workingDirectory().ifPresent(builder::directory);
                     // if the env isn't inherited we need to clear it
                     if (!environment.inheritEnvironment())
                         builder.environment().clear();
                     builder.environment().putAll(environment.environment());
                     var tasks = new ArrayList<CompletableFuture<?>>();
                     if (!redirect.stdout().isPresent())
                         builder.redirectOutput(Redirect.DISCARD);
                     if (!redirect.stderr().isPresent())
                         builder.redirectError(Redirect.DISCARD);
                     // run process
                     var proc = builder.start();
                     tasks.add(proc.onExit());
                     redirect.stdin().map(from -> from.redirect(proc.getOutputStream())).ifPresent(tasks::add);
                     redirect.stdout().map(to -> to.redirect(proc.getInputStream())).ifPresent(tasks::add);
                     redirect.stderr().map(to -> to.redirect(proc.getErrorStream())).ifPresent(tasks::add);
                     return CompletableFuture
                             .allOf(tasks.toArray(new CompletableFuture<?>[0]))
                             .thenApply(t -> proc.exitValue());
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/tasks/AbstractShellExecTask.java ~~common/src/main/java/org/implab/gradle/common/tasks/AbstractShellExecTask.java~~ renamed +10 -10

-            package org.implab.gradle.common.tasks;
+            package org.implab.gradle.common.exec.tasks;
             import java.io.IOException;
             import java.util.Map;
             import java.util.Optional;
             import java.util.concurrent.ExecutionException;
             import org.gradle.api.DefaultTask;
             import org.gradle.api.file.DirectoryProperty;
             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.RedirectFromSpec;
+            import org.implab.gradle.common.core.lang.Exceptions;
-            import org.implab.gradle.common.dsl.RedirectToSpec;
+            import org.implab.gradle.common.core.lang.Values;
-            import org.implab.gradle.common.dsl.TaskEnvSpecMixin;
+            import org.implab.gradle.common.exec.dsl.RedirectFromSpec;
-            import org.implab.gradle.common.dsl.TaskPipeSpecMixin;
+            import org.implab.gradle.common.exec.dsl.RedirectToSpec;
-            import org.implab.gradle.common.exec.RedirectTo;
+            import org.implab.gradle.common.exec.dsl.TaskEnvSpecMixin;
-            import org.implab.gradle.common.exec.ShellExec;
+            import org.implab.gradle.common.exec.dsl.TaskPipeSpecMixin;
-            import org.implab.gradle.common.utils.Exceptions;
+            import org.implab.gradle.common.exec.runtime.RedirectTo;
-            import org.implab.gradle.common.utils.Values;
+            import org.implab.gradle.common.exec.runtime.ShellExec;
             public abstract class AbstractShellExecTask
                     extends DefaultTask
                     implements TaskPipeSpecMixin, TaskEnvSpecMixin {
                 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();
                 /**
                  * 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;
                 }
                 protected abstract ShellExec execBuilder();
                 protected Optional<RedirectTo> conventionalStderr() {
                     return Optional.of(RedirectTo.eachLine(getLogger()::error));
                 }
                 protected Optional<RedirectTo> conventionalStdout() {
                     return Optional.of(RedirectTo.eachLine(getLogger()::info));
                 }
                 @TaskAction
                 public final void run() throws IOException, InterruptedException, ExecutionException {
                     // create new shell process
                     var execBuilder = execBuilder();
                     // configure environment
                     execBuilder
                             .workingDirectory(Values.optional(getWorkingDirectory().getAsFile()))
                             .environment(getEnvironment().getOrElse(Map.of()));
                     // configure redirects
                     execBuilder
                             .stdout(getStdout().getRedirection().or(this::conventionalStdout))
                             .stderr(getStderr().getRedirection().or(this::conventionalStderr))
                             .stdin(getStdin().getRedirection());
                     // execute
                     execBuilder.exec()
                             .thenAccept(Exceptions.unchecked(this::assertExitCode))
                             .join();
                 }
                 protected void assertExitCode(Integer code) throws IOException {
                     if (code != 0)
                         throw new IOException(String.format("The process is terminated with code %s", code));
                 }
-            }
  No newline at end of file

common/src/main/java/org/implab/gradle/common/exec/tasks/ShellExecTask.java ~~common/src/main/java/org/implab/gradle/common/tasks/ShellExecTask.java~~ renamed +5 -5

-            package org.implab.gradle.common.tasks;
+            package org.implab.gradle.common.exec.tasks;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.Property;
             import org.gradle.api.tasks.Internal;
-            import org.implab.gradle.common.dsl.TaskCommandSpecMixin;
+            import org.implab.gradle.common.exec.dsl.TaskCommandSpecMixin;
-            import org.implab.gradle.common.exec.CommandSpec;
+            import org.implab.gradle.common.exec.model.CommandSpec;
-            import org.implab.gradle.common.exec.Shell;
+            import org.implab.gradle.common.exec.runtime.Shell;
-            import org.implab.gradle.common.exec.ShellExec;
+            import org.implab.gradle.common.exec.runtime.ShellExec;
             public abstract class ShellExecTask
                     extends AbstractShellExecTask
                     implements TaskCommandSpecMixin {
                 @Internal
                 public abstract Property<Shell> getShell();
                 @Internal
                 @Override
                 public abstract ListProperty<String> getCommandLine();
                 @Override
                 protected ShellExec execBuilder() {
                     return getShell().get()
                             .create(CommandSpec.builder()
                                     .commandLine(getCommandLine().get())
                                     .build());
                 }
             }

common/src/main/java/org/implab/gradle/common/json/core/Json.java ~~common/src/main/java/org/implab/gradle/common/json/Json.java~~ renamed +2 -2

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.core;
             import java.io.File;
             import java.io.IOException;
             import java.util.Map;
             import java.util.function.Consumer;
             import java.util.function.Function;
-            import org.implab.gradle.common.utils.LazyValue;
+            import org.implab.gradle.common.core.lang.LazyValue;
             import com.fasterxml.jackson.annotation.JsonInclude.Include;
             import com.fasterxml.jackson.core.JsonProcessingException;
             import com.fasterxml.jackson.core.type.TypeReference;
             import com.fasterxml.jackson.core.util.DefaultIndenter;
             import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
             import com.fasterxml.jackson.databind.JsonMappingException;
             import com.fasterxml.jackson.databind.ObjectMapper;
             import com.fasterxml.jackson.databind.SerializationFeature;
             import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
             import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
             public class Json {
                 private final static LazyValue<ObjectMapper> mapper = new LazyValue<>(Json::createMapper);
                 private static ObjectMapper createMapper() {
                     DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
                     prettyPrinter.indentArraysWith(DefaultIndenter.SYSTEM_LINEFEED_INSTANCE);
                     return new ObjectMapper()
                             .registerModule(new Jdk8Module())
                             .registerModule(new JavaTimeModule())
                             .setSerializationInclusion(Include.NON_EMPTY)
                             .enable(SerializationFeature.INDENT_OUTPUT)
                             .setDefaultPrettyPrinter(prettyPrinter);
                 }
                 public static ObjectMapper jsonMapper() {
                     return mapper.get();
                 }
                 public static Consumer<Object> fileWriter(File file) {
                     return value -> {
                         try {
                             jsonMapper().writeValue(file, value);
                         } catch (IOException e) {
                             throw new SerializationException(e);
                         }
                     };
                 }
                 public static void write(File file, Object value) {
                     try {
                         jsonMapper().writeValue(file, value);
                     } catch (IOException e) {
                         throw new SerializationException(e);
                     }
                 }
                 public static String stringify(Object value) {
                     try {
                         return jsonMapper().writeValueAsString(value);
                     } catch (JsonProcessingException e) {
                         throw new SerializationException(e);
                     }
                 }
                 public static <T> T parse(String json, Class<T> clazz) {
                     try {
                         return jsonMapper().readValue(json, clazz);
                     } catch (JsonProcessingException e) {
                         throw new SerializationException(e);
                     }
                 }
                 public static <T> T parse(String json, TypeReference<T> type) {
                     try {
                         return jsonMapper().readValue(json, type);
                     } catch (JsonProcessingException e) {
                         throw new SerializationException(e);
                     }
                 }
                 public static <V> Map<String, V> parseMap(String json, Class<V> clazz) {
                     return parse(json, new TypeReference<>() {
                     });
                 }
                 public static <V> Function<String, Map<String, V>> mapParser(Class<V> clazz) {
                     return json -> parseMap(json, clazz);
                 }
                 public static <T> T read(File file, TypeReference<T> type) {
                     try {
                         return jsonMapper().readValue(file, type);
                     } catch (IOException e) {
                         throw new SerializationException(e);
                     }
                 }
                 public static <V> Map<String, V> readMap(File file, Class<V> clazz) {
                     return read(file, new TypeReference<>() {
                     });
                 }
                 public static <T> T updateValue(T target, Object source) {
                     try {
                         return jsonMapper().updateValue(target, source);
                     } catch (JsonMappingException e) {
                         throw new SerializationException(e);
                     }
                 }
                 public static <T> T convertValue(Object source, Class<T> clazz) {
                     var mapper = jsonMapper();
                     var buf = mapper.getSerializerProvider().bufferForValueConversion(jsonMapper());
                     try {
                         mapper.writeValue(buf, source);
                         return mapper.readValue(buf.asParser(), clazz);
                     } catch (IOException e) {
                         throw new SerializationException(e);
                     }
                 }
                 public static class SerializationException extends RuntimeException {
                     public SerializationException() {
                     }
                     public SerializationException(String message) {
                         super(message);
                     }
                     public SerializationException(Throwable cause) {
                         super(cause);
                     }
                     public SerializationException(String message, Throwable cause) {
                         super(message, cause);
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/json/core/MapImportSpec.java ~~common/src/main/java/org/implab/gradle/common/json/MapImportSpec.java~~ renamed +3 -3

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.core;
             import java.util.Arrays;
             import java.util.LinkedHashSet;
             import java.util.Set;
             import java.util.function.Predicate;
             import org.gradle.api.Action;
-            import org.implab.gradle.common.utils.Closures;
+            import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             /**
              * Простая include/exclude-маска по ключам верхнего уровня.
              */
             public class MapImportSpec {
                 private final Set<String> includes = new LinkedHashSet<>();
                 private final Set<String> excludes = new LinkedHashSet<>();
                 public void include(String... keys) {
                     includes.addAll(Arrays.asList(keys));
                 }
                 public void exclude(String... keys) {
                     excludes.addAll(Arrays.asList(keys));
                 }
                 public Set<String> getIncludes() {
                     return includes;
                 }
                 public Set<String> getExcludes() {
                     return excludes;
                 }
                 public boolean hasIncludes() {
                     return !includes.isEmpty();
                 }
                 public boolean isExcluded(String key) {
                     return excludes.contains(key);
                 }
                 public boolean isIncluded(String key) {
                     return !hasIncludes() || includes.contains(key);
                 }
                 public boolean matches(String key) {
                     return isIncluded(key) && !isExcluded(key);
                 }
                 public Predicate<String> toPredicate() {
                     return this::matches;
                 }
                 public static Predicate<String> buildPredicate(Action<? super MapImportSpec> action) {
                     var spec = new MapImportSpec();
                     action.execute(spec);
                     return spec.toPredicate();
                 }
                 public static Predicate<String> buildPredicate(Closure<?> closure) {
                     return buildPredicate(Closures.action(closure));
                 }
-            }
  No newline at end of file

common/src/main/java/org/implab/gradle/common/json/dsl/DefaultJsonArraySpec.java ~~common/src/main/java/org/implab/gradle/common/json/DefaultJsonArraySpec.java~~ renamed +2 -2

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.dsl;
             import org.gradle.api.provider.Provider;
             import java.util.ArrayList;
             import java.util.Collections;
             import java.util.List;
             public class DefaultJsonArraySpec implements JsonArraySpec {
                 private final List<Object> values = new ArrayList<>();
                 @Override
                 public void add(Object value) {
                     if (value instanceof Provider<?>) {
                         throw new IllegalArgumentException(
                             "Providers are not allowed inside JSON arrays; " +
                             "use top-level metadata.set(\"key\", provider) instead."
                         );
                     }
                     values.add(value);
                 }
                 public List<Object> toList() {
                     return Collections.unmodifiableList(values);
                 }
-            }
  No newline at end of file

common/src/main/java/org/implab/gradle/common/json/dsl/DefaultJsonObjectSpec.java ~~common/src/main/java/org/implab/gradle/common/json/DefaultJsonObjectSpec.java~~ renamed +2 -2

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.dsl;
             import org.gradle.api.provider.Provider;
             import java.util.Collections;
             import java.util.LinkedHashMap;
             import java.util.Map;
             public class DefaultJsonObjectSpec implements GroovyObjectSpec {
                 private final Map<String, Object> values = new LinkedHashMap<>();
                 @Override
                 public void set(String key, Object value) {
                     if (value instanceof Provider<?>) {
                         throw new IllegalArgumentException(
                                 "Providers are not allowed inside nested JSON objects; " +
                                         "use top-level metadata.set(\"" + key + "\", provider) instead.");
                     }
                     values.put(key, value);
                 }
                 public Map<String, Object> toMap() {
                     return Collections.unmodifiableMap(values);
                 }
-            }
  No newline at end of file

common/src/main/java/org/implab/gradle/common/json/dsl/GroovyObjectSpec.java ~~common/src/main/java/org/implab/gradle/common/json/GroovyObjectSpec.java~~ renamed +1 -1

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.dsl;
             import java.util.Arrays;
             import groovy.lang.Closure;
             import groovy.lang.MissingMethodException;
             public interface GroovyObjectSpec extends JsonObjectSpec {
                 default void propertyMissing(String name, Object value) {
                     set(name, value);
                 }
                 default Object methodMissing(String name, Object args) {
                     Object[] arr = (Object[]) args;
                     // author { ... }, repository { ... }
                     if (arr.length == 1 && arr[0] instanceof Closure<?>) {
                         DefaultJsonObjectSpec spec = new DefaultJsonObjectSpec();
                         Closure<?> cl = (Closure<?>) arr[0];
                         cl.setDelegate(spec);
                         cl.setResolveStrategy(Closure.DELEGATE_FIRST);
                         cl.call();
                         set(name, spec.toMap());
                         return null;
                     } else {
                         boolean hasClosure = Arrays.stream(arr)
                                 .anyMatch(a -> a instanceof Closure<?>);
                         if (!hasClosure) {
                             set(name, Arrays.asList(arr));
                             return null;
                         }
                     }
                     throw new MissingMethodException(name, getClass(), arr);
                 }
             }

common/src/main/java/org/implab/gradle/common/json/dsl/JsonArraySpec.java ~~common/src/main/java/org/implab/gradle/common/json/JsonArraySpec.java~~ renamed +2 -2

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.dsl;
             import org.gradle.api.Action;
             public interface JsonArraySpec {
                 void add(Object value);
                 default void obj(Action<? super JsonObjectSpec> action) {
                     DefaultJsonObjectSpec child = new DefaultJsonObjectSpec();
                     action.execute(child);
                     add(child.toMap());
                 }
                 default void arr(Action<? super JsonArraySpec> action) {
                     DefaultJsonArraySpec child = new DefaultJsonArraySpec();
                     action.execute(child);
                     add(child.toList());
                 }
-            }
  No newline at end of file

common/src/main/java/org/implab/gradle/common/json/dsl/JsonMapSpec.java ~~common/src/main/java/org/implab/gradle/common/json/JsonMapSpec.java~~ renamed +2 -1

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.dsl;
             import java.io.File;
             import org.gradle.api.Action;
             import org.gradle.api.file.RegularFile;
             import org.gradle.api.provider.Provider;
+            import org.implab.gradle.common.json.core.MapImportSpec;
             public interface JsonMapSpec extends GroovyObjectSpec {
                 void from(File file, Action<? super MapImportSpec> action);
                 default void from(File file) {
                     from(file, spec -> {
                     });
                 }
                 void from(Provider<RegularFile> fileProvider, Action<? super MapImportSpec> action);
                 default void from(Provider<RegularFile> fileProvider) {
                     from(fileProvider, spec -> {
                     });
                 }
             }

common/src/main/java/org/implab/gradle/common/json/dsl/JsonObjectSpec.java ~~common/src/main/java/org/implab/gradle/common/json/JsonObjectSpec.java~~ renamed +2 -2

-            package org.implab.gradle.common.json;
+            package org.implab.gradle.common.json.dsl;
             import org.gradle.api.Action;
             public interface JsonObjectSpec {
                 void set(String key, Object value);
                 default void obj(String key, Action<? super JsonObjectSpec> action) {
                     DefaultJsonObjectSpec child = new DefaultJsonObjectSpec();
                     action.execute(child);
                     set(key, child.toMap());
                 }
                 default void arr(String key, Action<? super JsonArraySpec> action) {
                     DefaultJsonArraySpec child = new DefaultJsonArraySpec();
                     action.execute(child);
                     set(key, child.toList());
                 }
-            }
  No newline at end of file

common/src/main/java/org/implab/gradle/common/json/tasks/WriteJson.java ~~common/src/main/java/org/implab/gradle/common/tasks/WriteJson.java~~ renamed +6 -7

-            package org.implab.gradle.common.tasks;
+            package org.implab.gradle.common.json.tasks;
             import java.util.LinkedHashMap;
             import java.util.Map;
             import java.util.Objects;
             import java.util.function.Predicate;
             import java.util.stream.Collectors;
             import javax.inject.Inject;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.DefaultTask;
             import org.gradle.api.file.RegularFile;
             import org.gradle.api.file.RegularFileProperty;
             import org.gradle.api.provider.MapProperty;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.provider.ProviderFactory;
             import org.gradle.api.tasks.Input;
             import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.Optional;
             import org.gradle.api.tasks.OutputFile;
-            import org.gradle.api.tasks.SkipWhenEmpty;
             import org.gradle.api.tasks.TaskAction;
-            import org.implab.gradle.common.json.MapImportSpec;
+            import org.implab.gradle.common.core.gradle.Properties;
-            import org.implab.gradle.common.json.Json;
+            import org.implab.gradle.common.core.lang.Closures;
-            import org.implab.gradle.common.json.JsonObjectSpec;
+            import org.implab.gradle.common.json.core.Json;
-            import org.implab.gradle.common.utils.Closures;
+            import org.implab.gradle.common.json.core.MapImportSpec;
-            import org.implab.gradle.common.utils.Properties;
+            import org.implab.gradle.common.json.dsl.JsonObjectSpec;
             import groovy.lang.Closure;
             /**
              * A Gradle task that writes JSON content to a file.
              *
              * This task allows you to build up a JSON object through various methods and
              * write it to a file.
              * You can add content directly, import from other JSON files, or merge in map
              * data with optional filtering.
              *
              * <h3>Usage Example:</h3>
              *
              * <pre>
              * tasks.register('generateConfig', WriteJson) {
              *     outputFile = file('build/config.json')
              *     content {
              *         version = '1.0.0'
              *         name = 'myapp'
              *     }
              *     from file('src/base-config.json')
              *     putAll providers.provider { ['debug': true] }
              * }
              * </pre>
              *
              * <h3>Properties:</h3>
              * <ul>
              * <li><strong>content</strong> - A map of string keys to object values that
              * will be serialized to JSON</li>
              * <li><strong>outputFile</strong> - The file where the JSON will be
              * written</li>
              * </ul>
              *
              * <h3>Methods:</h3>
              * <ul>
              * <li><strong>content()</strong> - Configure content using a closure or
              * action</li>
              * <li><strong>from()</strong> - Import JSON content from a file with optional
              * key filtering</li>
              * <li><strong>putAll()</strong> - Merge a map provider with optional key
              * filtering</li>
              * </ul>
              *
              * @since 1.0
              */
             @NonNullByDefault
             public abstract class WriteJson extends DefaultTask {
                 private final ProviderFactory providers;
                 private final JsonObjectSpec contentSpec = new JsonObjectSpec() {
                     @Override
                     public void set(String key, Object value) {
                         Properties.putMapEntry(getContent(), key, value);
                     }
                 };
                 @Input
                 @Optional
                 public abstract MapProperty<String, Object> getContent();
                 @OutputFile
                 public abstract RegularFileProperty getOutputFile();
                 @Internal
                 public Provider<String> getJson() {
                     return getContent().map(Json::stringify);
                 }
                 @Inject
                 public WriteJson(ProviderFactory providers) {
                     this.providers = providers;
                 }
                 public void content(Action<? super JsonObjectSpec> configure) {
                     configure.execute(contentSpec);
                 }
                 public void content(Closure<?> configure) {
                     Closures.apply(configure, contentSpec);
                 }
                 public void from(RegularFile file, Closure<?> configure) {
                     importContents(file, MapImportSpec.buildPredicate(configure));
                 }
                 public void from(RegularFile file, Action<? super MapImportSpec> configure) {
                     importContents(file, MapImportSpec.buildPredicate(configure));
                 }
                 public void from(RegularFile file) {
                     importContents(file, x -> true);
                 }
                 public void from(Provider<RegularFile> file, Closure<?> configure) {
                     importContents(file, MapImportSpec.buildPredicate(configure));
                 }
                 public void from(Provider<RegularFile> file, Action<? super MapImportSpec> configure) {
                     importContents(file, MapImportSpec.buildPredicate(configure));
                 }
                 public void from(Provider<RegularFile> file) {
                     importContents(file, x -> true);
                 }
                 public void putAll(Provider<Map<String, Object>> mapProvider, Action<? super MapImportSpec> configure) {
                     importMap(mapProvider, MapImportSpec.buildPredicate(configure));
                 }
                 public void putAll(Provider<Map<String, Object>> mapProvider, Closure<?> configure) {
                     importMap(mapProvider, MapImportSpec.buildPredicate(configure));
                 }
                 public void putAll(Provider<Map<String, Object>> mapProvider) {
                     importMap(mapProvider, x -> true);
                 }
                 private void importContents(Provider<RegularFile> file, Predicate<String> keyPredicate) {
                     var jsonProvider = providers.fileContents(file).getAsText()
                             .map(Json.mapParser(Object.class)::apply);
                     importMap(jsonProvider, keyPredicate);
                 }
                 private void importContents(RegularFile file, Predicate<String> keyPredicate) {
                     var jsonProvider = providers.fileContents(file).getAsText()
                             .map(Json.mapParser(Object.class)::apply);
                     importMap(jsonProvider, keyPredicate);
                 }
                 private void importMap(Provider<Map<String, Object>> mapProvider, Predicate<? super String> keyPredicate) {
                     var filteredProvider = mapProvider.map(v -> v.entrySet().stream()
                             .filter(pair -> keyPredicate.test(pair.getKey()) && Objects.nonNull(pair.getValue()))
                             .collect(Collectors.toMap(
                                     Map.Entry::getKey,
                                     Map.Entry::getValue,
                                     (a, b) -> b,
                                     LinkedHashMap::new)));
                     getContent().putAll(filteredProvider);
                 }
                 @TaskAction
                 public void run() {
                     var data = getContent().getOrElse(Map.of());
                     var file = getOutputFile().getAsFile().get();
                     Json.write(file, data);
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/GenericSourceSet.java ~~common/src/main/java/org/implab/gradle/common/files/GenericSourceSet.java~~ renamed +103 -31

-            package org.implab.gradle.common.files;
+            package org.implab.gradle.common.sources;
             import java.io.File;
             import java.nio.file.Paths;
             import java.util.HashSet;
+            import java.util.LinkedHashMap;
             import java.util.List;
+            import java.util.Map;
             import java.util.Objects;
             import java.util.Set;
             import java.util.concurrent.Callable;
+            import java.util.function.Function;
             import java.util.stream.Collectors;
             import javax.inject.Inject;
+            import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Named;
             import org.gradle.api.NamedDomainObjectContainer;
+            import org.gradle.api.Task;
+            import org.gradle.api.file.ConfigurableFileCollection;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.FileCollection;
             import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.file.SourceDirectorySet;
-            import org.gradle.api.logging.Logger;
-            import org.gradle.api.logging.Logging;
             import org.gradle.api.model.ObjectFactory;
+            import org.gradle.api.tasks.TaskProvider;
             import org.gradle.util.Configurable;
-            import org.implab.gradle.common.utils.Closures;
+            import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
+            /**
+             * A configurable source set abstraction with named output roles.
+             *
+             * <p>
+             * Each instance aggregates multiple {@link SourceDirectorySet source sets}
+             * under a shared name and exposes typed outputs that must be declared up front.
+             * Default locations are {@code src/<name>} for sources and
+             * {@code build/<name>} for outputs, both of which can be customized via the
+             * exposed {@link DirectoryProperty} setters.
+             * </p>
+             *
+             * <p>
+             * Outputs are grouped by roles to make task wiring explicit. A role must be
+             * declared with {@link #declareRoles(String, String...)} (or the synonym
+             * {@link #declareOutputs(String, String...)}) before files can be registered
+             * against it. Attempting to register or retrieve an undeclared role results in
+             * {@link InvalidUserDataException}.
+             * </p>
+             */
             public abstract class GenericSourceSet
                     implements Named, Configurable<GenericSourceSet> {
-                private final Logger logger = Logging.getLogger(GenericSourceSet.class);
                 private final String name;
                 private final NamedDomainObjectContainer<SourceDirectorySet> sourceDirectorySets;
-                private final NamedDomainObjectContainer<GenericSourceSetOutput> outputs;
+                private final Map<String, ConfigurableFileCollection> outputs;
                 private final FileCollection allOutputs;
                 private final FileCollection allSourceDirectories;
                 private final ObjectFactory objects;
-                private final Set<String> declaredOutputs = new HashSet<>();
+                private final Set<String> declaredRoles = new HashSet<>();
                 @Inject
                 public GenericSourceSet(String name, ObjectFactory objects, ProjectLayout layout) {
                     this.name = name;
                     this.objects = objects;
                     sourceDirectorySets = objects.domainObjectContainer(
                             SourceDirectorySet.class,
                             this::createSourceDirectorySet);
-                    outputs = objects.domainObjectContainer(GenericSourceSetOutput.class);
+                    outputs = new LinkedHashMap<>();
                     allSourceDirectories = objects.fileCollection().from(sourceDirectoriesProvider());
                     allOutputs = objects.fileCollection().from(outputsProvider());
-                    outputs.addRule("Register a declared set on demand", this::registerOutputOnDemand);
                     getSourceSetDir().convention(layout
                             .getProjectDirectory()
                             .dir(Paths.get("src", name).toString()));
                     getOutputsDir().convention(layout
                             .getBuildDirectory()
                             .dir(name));
                 }
                 @Override
                 public String getName() {
                     return name;
                 }
+                /**
+                 * Base directory for this source set. Defaults to {@code src/<name>} under
+                 * the project directory.
+                 */
                 public abstract DirectoryProperty getSourceSetDir();
+                /**
+                 * Base directory for outputs of this source set. Defaults to
+                 * {@code build/<name>}.
+                 */
                 public abstract DirectoryProperty getOutputsDir();
+                /**
+                 * The container of {@link SourceDirectorySet} instances that belong to this
+                 * logical source set.
+                 */
                 public NamedDomainObjectContainer<SourceDirectorySet> getSets() {
                     return sourceDirectorySets;
                 }
-                public NamedDomainObjectContainer<GenericSourceSetOutput> getOutputs() {
+                /**
-                    return outputs;
+                 * All registered outputs grouped across roles.
+                 */
                 public FileCollection getAllOutputs() {
                     return allOutputs;
                 }
+                /**
+                 * All source directories from every contained {@link SourceDirectorySet}.
+                 */
                 public FileCollection getAllSourceDirectories() {
                     return allSourceDirectories;
                 }
-                public FileCollection output(String name) {
+                /**
-                    return getOutputs().getAt(name).getFileCollection();
+                 * Returns the file collection for the specified output role, creating it
+                 * if necessary.
+                 *
+                 * @throws InvalidUserDataException if the role was not declared
+                 */
+                public ConfigurableFileCollection output(String name) {
+                    requireDeclaredRole(name);
+                    return outputs.computeIfAbsent(name, key -> objects.fileCollection());
                 }
-                public void declareOutputs(String name, String... extra) {
+                /**
-                    declaredOutputs.add(Objects.requireNonNull(name, "declareOutputs: The output name cannot be null"));
+                 * Declares allowed output roles. Roles must be declared before registering
+                 * files under them.
+                 */
+                public void declareRoles(String name, String... extra) {
+                    declaredRoles.add(Objects.requireNonNull(name, "declareRoles: The output name cannot be null"));
                     for (var x : extra)
-                        declaredOutputs.add(Objects.requireNonNull(x, "declareOutputs: The output name cannot be null"));
+                        declaredRoles.add(Objects.requireNonNull(x, "declareRoles: The output name cannot be null"));
                 }
-                @Override
+                /**
-                public GenericSourceSet configure(@SuppressWarnings("rawtypes") Closure configure) {
+                 * Alias for {@link #declareRoles(String, String...)} kept for DSL clarity.
-                    Closures.apply(configure, this);
+                 */
-                    return this;
+                public void declareOutputs(String name, String... extra) {
+                    declareRoles(name, extra);
+                }
+                /**
+                 * Registers files produced elsewhere under the given role.
+                 */
+                public void registerOutput(String name, Object... files) {
+                    output(name).from(files);
                 }
-                private void registerOutputOnDemand(String outputName) {
+                /**
-                    logger.info("SourceSet '{}': registerOutputOnDemand '{}'", name, outputName);
+                 * Registers output files produced by a task, using a mapper to extract the
+                 * output from the task. The task will be added as a build dependency of this
+                 * output.
+                 */
+                public <T extends Task> void registerOutput(String name, TaskProvider<T> task,
+                        Function<? super T, ?> mapper) {
+                    output(name).from(task.map(mapper::apply))
+                            .builtBy(task);
+                }
-                    if (declaredOutputs.contains(outputName))
+                /**
-                        outputs.register(outputName);
+                 * Applies a Groovy closure to this source set, enabling DSL-style
+                 * configuration.
+                 */
+                @Override
+                public GenericSourceSet configure(Closure configure) {
+                    Closures.apply(configure, this);
+                    return this;
                 }
                 private SourceDirectorySet createSourceDirectorySet(String name) {
                     return objects.sourceDirectorySet(name, name);
                 }
+                private void requireDeclaredRole(String roleName) {
+                    if (!declaredRoles.contains(roleName)) {
+                        throw new InvalidUserDataException(
+                                "Output role '" + roleName + "' is not declared for source set '" + name + "'");
+                    }
+                }
                 private Callable<List<? extends FileCollection>> outputsProvider() {
-                    return () -> outputs.stream()
+                    return () -> outputs.values().stream().toList();
-                            .map(GenericSourceSetOutput::getFileCollection)
-                            .toList();
                 }
                 private Callable<Set<File>> sourceDirectoriesProvider() {
                     return () -> sourceDirectorySets.stream()
                             .flatMap(x -> x.getSrcDirs().stream())
                             .collect(Collectors.toSet());
                 }
             }

common/src/main/java/org/implab/gradle/common/sources/SourcesPlugin.java ~~common/src/main/java/org/implab/gradle/common/SourcesPlugin.java~~ renamed +2 -3

-            package org.implab.gradle.common;
+            package org.implab.gradle.common.sources;
             import org.gradle.api.Action;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.logging.Logger;
             import org.gradle.api.logging.Logging;
             import org.gradle.api.tasks.Copy;
             import org.gradle.api.tasks.Delete;
             import org.gradle.api.tasks.TaskContainer;
             import org.gradle.api.tasks.TaskProvider;
             import org.gradle.language.base.plugins.LifecycleBasePlugin;
-            import org.implab.gradle.common.files.GenericSourceSet;
+            import org.implab.gradle.common.core.lang.Strings;
-            import org.implab.gradle.common.utils.Strings;
             /**
              * This plugin creates a {@code sources} extension which is
              * a container for {@link GenericSourceSet}.
              *
              */
             public abstract class SourcesPlugin implements Plugin<Project> {
                 private final Logger logger = Logging.getLogger(SourcesPlugin.class);
                 private final String POLICY_NAME = "SourcesPolicy";
                 private final String EXTENSION_NAME = "sources";
                 @Override
                 public void apply(Project target) {
                     target.getPlugins().apply(LifecycleBasePlugin.class);
                     var sources = target.getObjects().domainObjectContainer(GenericSourceSet.class);
                     var tasks = target.getTasks();
                     var clean = tasks.named(LifecycleBasePlugin.CLEAN_TASK_NAME);
                     target.getExtensions().add(EXTENSION_NAME, sources);
                     sources.configureEach(configureSourceSet(tasks, clean));
                 }
                 private Action<GenericSourceSet> configureSourceSet(TaskContainer tasks, TaskProvider<?> clean) {
                     return sourceSet -> {
                         var name = sourceSet.getName();
                         logger.info("{}: Processing source set '{}'", POLICY_NAME, name);
                         var taskName = "clean" + Strings.capitalize(sourceSet.getName());
                         logger.info("{}: Register task '{}' of type [{}]", POLICY_NAME, taskName, Copy.class.getTypeName());
                         var task = tasks.register(taskName, Delete.class, self -> {
                             self.delete(sourceSet.getOutputsDir());
                         });
                         clean.configure(self -> {
                             self.dependsOn(task);
                         });
                     };
                 }
             }

common/src/main/java/org/implab/gradle/common/files/GenericSourceSetOutput.java removed 0 -46

	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