implab/gradle-common Commit - r50:ca3982e55d9e

WIP variant artifacts DSL, FilePaths traits

cin -

r50:ca3982e55d9e default

parent child

Context file:

r50:ca3982e55d9e

Collapse all files

common/src/main/java/org/implab/gradle/common/core/lang/FilePaths.java created 644 +75 0

@@ -0,0 +1,75
	1	package org.implab.gradle.common.core.lang;
	2
	3	import java.nio.file.Path;
	4	import java.nio.file.Paths;
	5	import java.util.LinkedList;
	6	import java.util.List;
	7	import java.util.Set;
	8	import java.util.function.BiConsumer;
	9	import java.util.function.BinaryOperator;
	10	import java.util.function.Function;
	11	import java.util.function.Supplier;
	12	import java.util.stream.Collector;
	13	import java.util.stream.Stream;
	14
	15	public final class FilePaths {
	16	private static PathCollector defaultPathCollector = new PathCollector();
	17
	18	private FilePaths() {
	19	}
	20
	21	public static String cat(String fist, String... extra) {
	22	return catPath(fist, extra).toString();
	23	}
	24
	25	public static Path catPath(String first, String ...extra) {
	26	return Stream.concat(Stream.of(first), Stream.of(extra))
	27	.collect(asPath());
	28	}
	29
	30	public static Collector<String, List<String>, Path> asPath() {
	31	return defaultPathCollector;
	32	}
	33
	34	static class PathCollector implements Collector<String, List<String>, Path> {
	35
	36	private final Function<String, String> sanitizer;
	37
	38	public PathCollector() {
	39	sanitizer = Strings::sanitizeFileName;
	40	}
	41
	42	@Override
	43	public BiConsumer<List<String>, String> accumulator() {
	44	return (components, item) -> components.add(sanitizer.apply(item));
	45	}
	46
	47	@Override
	48	public Set<Characteristics> characteristics() {
	49	return Set.of();
	50	}
	51
	52	@Override
	53	public BinaryOperator<List<String>> combiner() {
	54	return (first, extra) -> {
	55	first.addAll(extra);
	56	return first;
	57	};
	58	}
	59
	60	@Override
	61	public Function<List<String>, Path> finisher() {
	62	return components -> Paths.get(
	63	components.get(0),
	64	components.subList(1, components.size())
	65	.toArray(String[]::new));
	66
	67	}
	68
	69	@Override
	70	public Supplier<List<String>> supplier() {
	71	return () -> new LinkedList<>();
	72	}
	73
	74	}
	75	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactConfigurationHandler.java created 644 +100 0

@@ -0,0 +1,100
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import java.util.HashMap;
	4	import java.util.Map;
	5
	6	import org.gradle.api.Action;
	7	import org.gradle.api.file.Directory;
	8	import org.gradle.api.file.DirectoryProperty;
	9	import org.gradle.api.model.ObjectFactory;
	10	import org.gradle.api.provider.Provider;
	11	import org.gradle.api.tasks.Copy;
	12	import org.gradle.api.tasks.TaskContainer;
	13	import org.gradle.language.base.plugins.LifecycleBasePlugin;
	14	import org.implab.gradle.common.core.lang.FilePaths;
	15	import org.implab.gradle.common.core.lang.Strings;
	16	import org.implab.gradle.variants.artifacts.ArtifactAssemblyRegistry;
	17	import org.implab.gradle.variants.artifacts.ArtifactSlot;
	18	import org.implab.gradle.variants.artifacts.OutgoingVariant;
	19	import org.implab.gradle.variants.artifacts.VariantArtifactsSpec;
	20	import org.implab.gradle.variants.sources.CompileUnitsView;
	21	import org.implab.gradle.variants.sources.RoleProjectionsView;
	22	import org.implab.gradle.variants.sources.SourceSetMaterializer;
	23
	24	public class ArtifactConfigurationHandler {
	25	private final ArtifactAssemblyRegistry registry;
	26
	27	private final CompileUnitsView compileUnitsView;
	28
	29	private final RoleProjectionsView roleProjectionsView;
	30
	31	private final SourceSetMaterializer sourceSetMaterializer;
	32
	33	private final Map<ArtifactSlot, SlotContributionVisitor> visitors = new HashMap<>();
	34
	35	private final ObjectFactory objectFactory;
	36
	37	private final DirectoryProperty assembliesDirectory;
	38
	39	private final TaskContainer tasks;
	40
	41	public ArtifactConfigurationHandler(
	42	ArtifactAssemblyRegistry registry,
	43	CompileUnitsView compileUnitsView,
	44	RoleProjectionsView roleProjectionsView,
	45	SourceSetMaterializer sourceSetMaterializer,
	46	ObjectFactory objectFactory,
	47	TaskContainer tasks) {
	48	this.registry = registry;
	49	this.compileUnitsView = compileUnitsView;
	50	this.roleProjectionsView = roleProjectionsView;
	51	this.sourceSetMaterializer = sourceSetMaterializer;
	52	this.objectFactory = objectFactory;
	53	this.assembliesDirectory = objectFactory.directoryProperty();
	54	this.tasks = tasks;
	55	}
	56
	57	public SlotContributionVisitor slotAssembler(ArtifactSlot artifactSlot) {
	58	return visitors.computeIfAbsent(artifactSlot, this::newVisitor);
	59	}
	60
	61	public void configureVariant(OutgoingVariant outgoingVariant, Action<? super VariantArtifactsSpec> action) {
	62	var spec = new DefaultVariantArtifactSpec(outgoingVariant, objectFactory, this);
	63
	64	action.execute(spec);
	65	}
	66
	67	private SlotContributionVisitor newVisitor(ArtifactSlot artifactSlot) {
	68	var fileCollection = objectFactory.fileCollection();
	69	var outputDirectory = outputDirectory(artifactSlot);
	70
	71	var task = tasks.register(assembleTaskName(artifactSlot), Copy.class, copy -> {
	72	copy.setGroup(LifecycleBasePlugin.BUILD_GROUP);
	73	copy.into(outputDirectory);
	74	copy.from(fileCollection);
	75	});
	76
	77	// регистрируется задача и арефакт сборки слота
	78	registry.register(artifactSlot, task, t -> outputDirectory);
	79
	80	return new SlotInputsAssembler(
	81	artifactSlot,
	82	fileCollection,
	83	compileUnitsView,
	84	roleProjectionsView,
	85	sourceSetMaterializer);
	86	}
	87
	88	private String assembleTaskName(ArtifactSlot artifactSlot) {
	89	return "assemble"
	90	+ Strings.capitalize(artifactSlot.variant().getName())
	91	+ Strings.capitalize(artifactSlot.slot().getName());
	92	}
	93
	94	private Provider<Directory> outputDirectory(ArtifactSlot artifactSlot) {
	95	return assembliesDirectory.dir(
	96	FilePaths.cat(
	97	artifactSlot.variant().getName(),
	98	artifactSlot.slot().getName()));
	99	}
	100	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultVariantArtifactSpec.java created 644 +51 0

@@ -0,0 +1,51
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import org.gradle.api.Action;
	4	import org.gradle.api.model.ObjectFactory;
	5	import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
	6	import org.implab.gradle.variants.artifacts.ArtifactSlot;
	7	import org.implab.gradle.variants.artifacts.OutgoingVariant;
	8	import org.implab.gradle.variants.artifacts.Slot;
	9	import org.implab.gradle.variants.artifacts.VariantArtifactsSpec;
	10
	11	class DefaultVariantArtifactSpec implements VariantArtifactsSpec {
	12
	13	private final ObjectFactory objectFactory;
	14	private final ArtifactConfigurationHandler assemblyBuilder;
	15
	16	private final OutgoingVariant outgoingVariant;
	17
	18	DefaultVariantArtifactSpec(
	19	OutgoingVariant outgoingVariant,
	20	ObjectFactory objectFactory,
	21	ArtifactConfigurationHandler assemblyBuilder) {
	22	this.objectFactory = objectFactory;
	23	this.assemblyBuilder = assemblyBuilder;
	24	this.outgoingVariant = outgoingVariant;
	25	}
	26
	27	@Override
	28	public void slot(String name, Action<? super ArtifactAssemblySpec> action) {
	29	var slot = outgoingVariant.getSlots().maybeCreate(name);
	30
	31	configureSlot(slot, action);
	32	}
	33
	34	@Override
	35	public void primarySlot(String name, Action<? super ArtifactAssemblySpec> action) {
	36	var slot = outgoingVariant.getSlots().maybeCreate(name);
	37	outgoingVariant.getPrimarySlot().set(slot);
	38
	39	configureSlot(slot, action);
	40	}
	41
	42	private void configureSlot(Slot slot, Action<? super ArtifactAssemblySpec> action) {
	43	var artifactSlot = new ArtifactSlot(outgoingVariant.getVariant(), slot);
	44
	45	var inputsAssembler = assemblyBuilder.slotAssembler(artifactSlot);
	46
	47	var spec = new DefaultArtifactAssemblySpec(objectFactory, inputsAssembler.consumer());
	48	action.execute(spec);
	49	}
	50
	51	}

common/src/main/java/org/implab/gradle/common/core/lang/Strings.java +79 0

             package org.implab.gradle.common.core.lang;
+            import java.util.function.Consumer;
+            import java.util.function.Function;
             import java.util.regex.Pattern;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.provider.Provider;
             @NonNullByDefault
             public class Strings {
+                private static final boolean[] ALLOWED_FILE_NAME_CHAR = new boolean[128];
+                private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();
                 private static final Pattern firstLetter = Pattern.compile("^\\w");
                 private static final Pattern INVALID_NAME_CHAR = Pattern.compile("[^A-Za-z0-9_.-]");
+                static {
+                    for (char c = '0'; c <= '9'; c++)
+                        ALLOWED_FILE_NAME_CHAR[c] = true;
+                    for (char c = 'A'; c <= 'Z'; c++)
+                        ALLOWED_FILE_NAME_CHAR[c] = true;
+                    for (char c = 'a'; c <= 'z'; c++)
+                        ALLOWED_FILE_NAME_CHAR[c] = true;
+                    ALLOWED_FILE_NAME_CHAR['.'] = true;
+                    ALLOWED_FILE_NAME_CHAR['_'] = true;
+                    ALLOWED_FILE_NAME_CHAR['-'] = true;
+                }
                 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 void argumentNotNullOrBlank(String value, String argumentName) {
                     if (value == null || value.trim().length() == 0)
                         throw new IllegalArgumentException(String.format("Argument %s can't be null or blank", argumentName));
                 }
                 public static String requireNonBlank(String value) {
                     argumentNotNullOrBlank(value, "value");
                     return value;
                 }
+                public static String requireNonEmpty(String value) {
+                    argumentNotNullOrEmpty(value, "value");
+                    return value;
+                }
                 public static String sanitizeName(String value) {
                     return INVALID_NAME_CHAR.matcher(value).replaceAll("_");
                 }
+                public static String sanitizeFileName(String value) {
+                    int length = value.length();
+                    for (int i = 0; i < length; i++) {
+                        char c = value.charAt(i);
+                        if (c >= ALLOWED_FILE_NAME_CHAR.length || !ALLOWED_FILE_NAME_CHAR[c])
+                            return sanitizeFileName(value, i);
+                    }
+                    return value;
+                }
                 public static String asString(Object value) {
                     if (value == null)
                         return null;
                     if (value instanceof Provider<?> provider)
                         return asString(provider.get());
                     else
                         return value.toString();
                 }
+                private static String sanitizeFileName(String value, int invalidIndex) {
+                    int length = value.length();
+                    StringBuilder out = new StringBuilder(length + 16);
+                    out.append(value, 0, invalidIndex);
+                    for (int i = invalidIndex; i < length; i++) {
+                        char c = value.charAt(i);
+                        if (c < ALLOWED_FILE_NAME_CHAR.length && ALLOWED_FILE_NAME_CHAR[c]) {
+                            out.append(c);
+                        } else if (Character.isHighSurrogate(c) && i + 1 < length && Character.isLowSurrogate(value.charAt(i + 1))) {
+                            appendUrlEncodedUtf8(out, Character.toCodePoint(c, value.charAt(++i)));
+                        } else if (Character.isSurrogate(c)) {
+                            appendUrlEncodedUtf8(out, 0xFFFD);
+                        } else {
+                            appendUrlEncodedUtf8(out, c);
                         }
+                    }
+                    return out.toString();
+                }
+                private static void appendUrlEncodedUtf8(StringBuilder out, int codePoint) {
+                    if (codePoint <= 0x7F) {
+                        appendUrlEncodedByte(out, codePoint);
+                    } else if (codePoint <= 0x7FF) {
+                        appendUrlEncodedByte(out, 0xC0 | (codePoint >>> 6));
+                        appendUrlEncodedByte(out, 0x80 | (codePoint & 0x3F));
+                    } else if (codePoint <= 0xFFFF) {
+                        appendUrlEncodedByte(out, 0xE0 | (codePoint >>> 12));
+                        appendUrlEncodedByte(out, 0x80 | ((codePoint >>> 6) & 0x3F));
+                        appendUrlEncodedByte(out, 0x80 | (codePoint & 0x3F));
+                    } else {
+                        appendUrlEncodedByte(out, 0xF0 | (codePoint >>> 18));
+                        appendUrlEncodedByte(out, 0x80 | ((codePoint >>> 12) & 0x3F));
+                        appendUrlEncodedByte(out, 0x80 | ((codePoint >>> 6) & 0x3F));
+                        appendUrlEncodedByte(out, 0x80 | (codePoint & 0x3F));
+                    }
+                }
+                private static void appendUrlEncodedByte(StringBuilder out, int value) {
+                    out.append('%');
+                    out.append(HEX_DIGITS[(value >>> 4) & 0x0F]);
+                    out.append(HEX_DIGITS[value & 0x0F]);
+                }
+            }

variants/src/main/java/org/implab/gradle/variants/VariantArtifactsPlugin.java +5 -2

             package org.implab.gradle.variants;
             import org.gradle.api.Action;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblyRegistry;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
             import org.implab.gradle.variants.artifacts.OutgoingVariantsContext;
             import org.implab.gradle.variants.artifacts.VariantArtifactsExtension;
             import org.implab.gradle.variants.artifacts.VariantArtifactsSpec;
             import org.implab.gradle.variants.artifacts.internal.ArtifactAssemblyBridge;
+            import org.implab.gradle.variants.artifacts.internal.DefaultVariantArtifactSpec;
             import org.implab.gradle.variants.artifacts.internal.OutgoingRegistry;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsExtension;
             public abstract class VariantArtifactsPlugin implements Plugin<Project> {
                 @Override
                 public void apply(Project target) {
                     var extensions = target.getExtensions();
                     var objects = target.getObjects();
                     var providers = target.getProviders();
                     var configurations = target.getConfigurations();
                     var tasks = target.getTasks();
                     // Apply the main VariantsPlugin to ensure the core variant model is available.
                     target.getPlugins().apply(VariantsPlugin.class);
                     // Access the VariantsExtension to configure variant sources.
                     var variantsExtension = extensions.getByType(VariantsExtension.class);
                     var outgoing = new OutgoingRegistry(configurations, objects, providers);
                     var assemblies = new ArtifactAssemblyRegistry(objects, tasks);
+                    // wire artifact assemblies to configuration variants
                     var assembliesBridge = new ArtifactAssemblyBridge(assemblies);
                     var deferred = new Deferred<OutgoingVariantsContext>();
                     deferred.whenResolved(context -> context.all(assembliesBridge));
                     variantsExtension.whenFinalized(variants -> {
                     });
                     var variantArtifacts = new VariantArtifactsExtension() {
                         @Override
                         public void variant(String variantName, Action<? super VariantArtifactsSpec> action) {
-                            deferred.whenResolved(context -> registry.configureVariant(
+                            deferred.whenResolved(context -> {
-                                    objects.named(Variant.class, variantName), action));
+                                new DefaultVariantArtifactSpec();
+                            });
                         }
                         @Override
                         public void whenFinalized(Action<? super OutgoingVariantsContext> action) {
                             deferred.whenResolved(registry -> action.execute(registry.variantsContext()));
                         }
                         @Override
                         public void whenOutgoingVariant(Action<? super OutgoingConfigurationSpec> action) {
                             deferred.whenResolved(registry -> registry.configureOutgoing(action));
                         }
                         @Override
                         public void whenOutgoingSlot(Action<? super OutgoingArtifactSlotSpec> action) {
                             deferred.whenResolved(registry -> registry.configureOutgoingSlot(action));
                         }
                     };
                     extensions.add(VariantArtifactsExtension.class, "variantArtifacts", variantArtifacts);
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssembly.java 0 -6

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Task;
-            import org.gradle.api.file.FileCollection;
             import org.gradle.api.file.FileSystemLocation;
             import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.TaskProvider;
             /**
              * Materialized body of an {@link ArtifactSlot}.
              *
              * <p>
              * An assembly is a stateful build object obtained on demand from
              * {@link ArtifactAssemblies#require(ArtifactSlot)}. It describes how the
              * slot artifact is produced and
              * where that single published artifact will appear.
              */
             public interface ArtifactAssembly {
                 /**
                  * Returns the published artifact produced for the slot.
                  *
                  * <p>
                  * A slot is expected to produce exactly one artifact represented by one file or
                  * one directory.
                  *
                  * @return provider of the produced artifact location
                  */
                 Provider<? extends FileSystemLocation> getArtifact();
                 /**
                  * Returns the task that assembles the slot artifact.
                  *
                  * @return provider of the assembly task
                  */
                 TaskProvider<? extends Task> getAssemblyTask();
-                /**
-                 * File collection, contains {@link #getArtifact()} and build dependency on
-                 * {@link #getAssemblyTask()}. This is a conventional property.
-                 */
-                FileCollection getFileCollection();
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblyRegistry.java +3 -40

             package org.implab.gradle.variants.artifacts;
             import java.util.LinkedHashMap;
             import java.util.Map;
             import java.util.Optional;
             import java.util.function.Function;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.gradle.api.Task;
-            import org.gradle.api.file.Directory;
-            import org.gradle.api.file.FileCollection;
             import org.gradle.api.file.FileSystemLocation;
-            import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Provider;
-            import org.gradle.api.tasks.Copy;
-            import org.gradle.api.tasks.TaskContainer;
             import org.gradle.api.tasks.TaskProvider;
-            import org.gradle.language.base.plugins.LifecycleBasePlugin;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.internal.ReplayableQueue;
             @NonNullByDefault
             public class ArtifactAssemblyRegistry implements ArtifactAssemblies {
-                private final ObjectFactory objects;
-                private final TaskContainer tasks;
                 private final Map<ArtifactSlot, Deferred<ArtifactAssembly>> assembliesBySlots = new LinkedHashMap<>();
                 private final ReplayableQueue<ArtifactAssembly> assemblies = new ReplayableQueue<>();
-                public ArtifactAssemblyRegistry(ObjectFactory objects, TaskContainer tasks) {
+                public ArtifactAssemblyRegistry() {
-                    this.objects = objects;
-                    this.tasks = tasks;
-                public ArtifactAssembly register(
-                        ArtifactSlot slot,
-                        String taskName,
-                        Provider<Directory> outputDirectory,
-                        FileCollection sources) {
-                    var task = tasks.register(taskName, Copy.class, copy -> {
-                        copy.setGroup(LifecycleBasePlugin.BUILD_GROUP);
-                        copy.into(outputDirectory);
-                        copy.from(sources);
-                    });
-                    return register(slot, task, t -> outputDirectory);
                 }
                 public <T extends Task> ArtifactAssembly register(
                         ArtifactSlot slot,
                         TaskProvider<T> task,
                         Function<? super T, ? extends Provider<? extends FileSystemLocation>> mapOutputArtifact) {
                     var deferred = getDeferred(slot);
                     if (deferred.resolved()) {
                         throw new InvalidUserDataException("Artifact assembly '" + slot + "' is already registered");
                     }
                     var outputArtifact = task.flatMap(mapOutputArtifact::apply);
-                    var output = objects.fileCollection()
+                    var assembly = new Assembly(outputArtifact, task);
-                            .from(outputArtifact)
-                            .builtBy(task);
-                    var assembly = new Assembly(outputArtifact, task, output);
                     deferred.resolve(assembly);
                     assemblies.add(assembly);
                     return assembly;
                 }
                 @Override
                 public Optional<ArtifactAssembly> find(ArtifactSlot slot) {
                     // to prevent creation of map entries on lookup use the map directly
                     var deferred = assembliesBySlots.get(slot);
                     return deferred != null && deferred.resolved()
                             ? Optional.of(deferred.value())
                             : Optional.empty();
                 }
                 @Override
                 public void when(ArtifactSlot slot, Action<? super ArtifactAssembly> action) {
                     getDeferred(slot).whenResolved(action::execute);
                 }
                 @Override
                 public void all(Action<? super ArtifactAssembly> action) {
                     assemblies.forEach(action::execute);
                 }
                 private Deferred<ArtifactAssembly> getDeferred(ArtifactSlot slot) {
                     return assembliesBySlots.computeIfAbsent(slot, k -> new Deferred<>());
                 }
                 static class Assembly implements ArtifactAssembly {
                     private final Provider<? extends FileSystemLocation> artifact;
                     private final TaskProvider<? extends Task> task;
-                    private final FileCollection fileCollection;
-                    Assembly(Provider<? extends FileSystemLocation> artifact, TaskProvider<? extends Task> task,
+                    Assembly(Provider<? extends FileSystemLocation> artifact, TaskProvider<? extends Task> task) {
-                            FileCollection fileCollection) {
                         this.artifact = artifact;
                         this.task = task;
-                        this.fileCollection = fileCollection;
                     }
                     @Override
                     public Provider<? extends FileSystemLocation> getArtifact() {
                         return artifact;
                     }
                     @Override
                     public TaskProvider<? extends Task> getAssemblyTask() {
                         return task;
                     }
-                    @Override
-                    public FileCollection getFileCollection() {
-                        return fileCollection;
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultArtifactAssemblySpec.java ~~variants/src/main/java/org/implab/gradle/variants/artifacts/internal/BoundArtifactAssemblySpec.java~~ renamed +8 -13

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.HashSet;
-            import java.util.LinkedList;
-            import java.util.List;
             import java.util.Set;
             import java.util.function.Consumer;
             import java.util.stream.Stream;
             import org.gradle.api.Action;
             import org.gradle.api.model.ObjectFactory;
             import org.implab.gradle.common.core.lang.Strings;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.artifacts.OutputSelectionSpec;
             /**
              * Реализация DSL модели, строит набор {@link SlotContribution}. При построении набора
              * правила и корректность не проверяются. По окончании использования клиент
              * вызывает метод {@link #process(Consumer)} для обработки результатов.
              *
              */
-            final class BoundArtifactAssemblySpec implements ArtifactAssemblySpec {
+            final class DefaultArtifactAssemblySpec implements ArtifactAssemblySpec {
-                private final List<SlotContribution> contributions = new LinkedList<>();
+                private final Consumer<? super SlotContribution> consumer;
                 private final ObjectFactory objectFactory;
-                BoundArtifactAssemblySpec(ObjectFactory objectFactory) {
+                DefaultArtifactAssemblySpec(ObjectFactory objectFactory, Consumer<? super SlotContribution> consumer) {
+                    this.consumer = consumer;
                     this.objectFactory = objectFactory;
                 }
                 @Override
                 public void from(Object artifact) {
-                    contributions.add(new DirectContribution(artifact));
+                    consumer.accept(new DirectContribution(artifact));
                 }
                 @Override
                 public void fromVariant(Action<? super OutputSelectionSpec> action) {
-                    contributions.add(new VariantOutputsContribution(outputs(action)));
+                    consumer.accept(new VariantOutputsContribution(outputs(action)));
                 }
                 @Override
                 public void fromRole(String roleName, Action<? super OutputSelectionSpec> action) {
-                    contributions.add(new RoleOutputsContribution(
+                    consumer.accept(new RoleOutputsContribution(
                             objectFactory.named(Role.class, roleName),
                             outputs(action)));
                 }
                 @Override
                 public void fromLayer(String layerName, Action<? super OutputSelectionSpec> action) {
-                    contributions.add(new LayerOutputsContribution(
+                    consumer.accept(new LayerOutputsContribution(
                             objectFactory.named(Layer.class, layerName),
                             outputs(action)));
                 }
-                void process(Consumer<? super SlotContribution> consumer) {
-                    contributions.forEach(consumer);
                 private static Set<String> outputs(Action<? super OutputSelectionSpec> action) {
                     var spec = new OutputsSetSpec();
                     action.execute(spec);
                     return spec.outputs();
                 }
                 private static class OutputsSetSpec implements OutputSelectionSpec {
                     private final Set<String> outputs = new HashSet<>();
                     @Override
                     public void output(String name, String... extra) {
                         Stream.concat(Stream.of(name), Stream.of(extra))
                             .map(Strings::requireNonBlank)
                             .forEach(outputs::add);
                     }
                     Set<String> outputs() {
                         return Set.copyOf(outputs);
                     }
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/SlotInputsAssembler.java +61 -20

@@ -1,55 +1,96
1	package org.implab.gradle.variants.artifacts.internal;	1	package org.implab.gradle.variants.artifacts.internal;
2		2
3	import java.util.~~Collection~~;	3	import java.util.HashSet;
4	import java.util.Set;	4	import java.util.Set;
5	import java.util.function.Consumer;
6	import java.util.function.Function;
7		5
		6	import org.gradle.api.file.ConfigurableFileCollection;
8	import org.implab.gradle.variants.artifacts.ArtifactSlot;	7	import org.implab.gradle.variants.artifacts.ArtifactSlot;
9	import org.implab.gradle.variants.core.VariantsView;
10	import org.implab.gradle.variants.sources.CompileUnit;	8	import org.implab.gradle.variants.sources.CompileUnit;
11	import org.implab.gradle.variants.sources.~~VariantSourcesContext~~;	9	import org.implab.gradle.variants.sources.CompileUnitsView;
		10	import org.implab.gradle.variants.sources.RoleProjectionsView;
		11	import org.implab.gradle.variants.sources.SourceSetMaterializer;
12		12
		13	/**
		14	* Сборщик входящих элементов из разных источников {@link SlotContribution}.
		15	* Хранит {@link ConfigurableFileCollection} и добавляет в него новые элементы,
		16	* при этом делается дедупликация по {@link SlotInputKey}.
		17	*
		18	*/
13	public class SlotInputsAssembler implements SlotContributionVisitor {	19	public class SlotInputsAssembler implements SlotContributionVisitor {
14		20
15	VariantsView variantView;	21	// sources context
16	VariantSourcesContext sources;	22	private final CompileUnitsView compileUnitsView;
17	ArtifactSlot artifactSlot;	23
		24	private final RoleProjectionsView roleProjectionsView;
		25
		26	private final SourceSetMaterializer sourceSetMaterializer;
		27
		28	// artifact slot for this assembly
		29	private final ArtifactSlot artifactSlot;
		30
		31	// content for this assembly
		32	private final ConfigurableFileCollection artifactInputs;
18		33
19	Set<SlotInputKey> seen;	34	// seen inputs, used for deduplication
		35	private final Set<SlotInputKey> seen = new HashSet<>();
		36
		37	public SlotInputsAssembler(
		38	ArtifactSlot artifactSlot,
		39	ConfigurableFileCollection artifactInputs,
		40	CompileUnitsView compileUnitsView,
		41	RoleProjectionsView roleProjectionsView,
		42	SourceSetMaterializer sourceSetMaterializer) {
		43	this.compileUnitsView = compileUnitsView;
		44	this.roleProjectionsView = roleProjectionsView;
		45	this.sourceSetMaterializer = sourceSetMaterializer;
		46	this.artifactSlot = artifactSlot;
		47	this.artifactInputs = artifactInputs;
		48	}
20		49
21	@Override	50	@Override
22	public void visit(DirectContribution contribution) {	51	public void visit(DirectContribution contribution) {
23	contribute(	52	contribute(
24	SlotInputKey.newUniqueKey("Direct input for " + artifactSlot),	53	SlotInputKey.newUniqueKey("Direct input for " + artifactSlot),
25	contribution.input());	54	contribution.input());
26	}	55	}
27		56
28	@Override	57	@Override
29	public void visit(VariantOutputsContribution contribution) {	58	public void visit(VariantOutputsContribution contribution) {
30	~~sources~~.~~getC~~ompileUnits().getUnitsForVariant(artifactSlot.variant()).~~stream~~()	59	var units = compileUnitsView.getUnitsForVariant(artifactSlot.variant());
		60	contributeCompileUnits(units, contribution.outputs());
31	}	61	}
32		62
33	@Override	63	@Override
34	public void visit(RoleOutputsContribution contribution) {	64	public void visit(RoleOutputsContribution contribution) {
35	// TODO Auto-generated method stub	65	var roleProjection = roleProjectionsView.requireProjection(artifactSlot.variant(),
36	throw new UnsupportedOperationException("Unimplemented method 'visit'");	66	contribution.role());
		67	var units = roleProjectionsView.getUnits(roleProjection);
		68
		69	contributeCompileUnits(units, contribution.outputs());
		70
37	}	71	}
38		72
39	@Override	73	@Override
40	public void visit(LayerOutputsContribution contribution) {	74	public void visit(LayerOutputsContribution contribution) {
41	// TODO Auto-generated method stub	75	var unit = compileUnitsView.requireUnit(artifactSlot.variant(), contribution.layer());
42	throw new UnsupportedOperationException("Unimplemented method 'visit'");	76	contributeCompileUnits(Set.of(unit), contribution.outputs());
43	}	77	}
44		78
45	private void contribute(SlotInputKey key, Object input) {	79	private void contributeCompileUnits(Set<CompileUnit> units, Set<String> outputs) {
46		80	units.stream()
		81	// expand variant compile units, make (compileUnit, outputName) pairs
		82	.flatMap(unit -> outputs.stream()
		83	.map(output -> new CompileUnitOutputKey(unit, output)))
		84	.forEach(key -> contribute(
		85	key,
		86	sourceSetMaterializer.getSourceSet(key.unit())
		87	.map(s -> s.output(key.outputName()))));
47	}	88	}
48		89
49	private Function<CompileUnit, Object> resolveOutputs(Collection<? extends String> outputs) {	90	private void contribute(SlotInputKey key, Object resolvedInput) {
50	return unit -> {	91	if (!seen.add(key))
51		92	return;
52	};	93	artifactInputs.from(resolvedInput);
53	}	94	}
54		95
55	}	96	}

variants/src/main/java/org/implab/gradle/variants/sources/RoleProjectionsView.java +1 -1

             package org.implab.gradle.variants.sources;
             import java.util.HashMap;
             import java.util.Map;
             import java.util.Objects;
             import java.util.Optional;
             import java.util.Set;
             import java.util.stream.Collectors;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             public final class RoleProjectionsView {
                 private final VariantsView variants;
                 private final Map<Variant, Set<RoleProjection>> projectionsByVariant = new HashMap<>();
                 private RoleProjectionsView(VariantsView variants) {
                     this.variants = variants;
                 }
                 public Set<RoleProjection> getProjections() {
                     return variants.getEntries().stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Set<RoleProjection> getProjectionsForVariant(Variant variant) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     return projectionsByVariant.computeIfAbsent(variant, key -> variants
                             .getEntriesForVariant(variant).stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet()));
                 }
                 public Set<RoleProjection> getProjectionsForRole(Role role) {
                     Objects.requireNonNull(role, "Role can't be null");
                     return variants.getEntriesForRole(role).stream()
                             .map(RoleProjection::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
                 public Optional<RoleProjection> findProjection(Variant variant, Role role) {
                     Objects.requireNonNull(variant, "Variant can't be null");
                     Objects.requireNonNull(role, "Role can't be null");
                     return variants.getEntriesForVariant(variant).stream()
                             .filter(entry -> entry.role().equals(role))
                             .map(RoleProjection::of)
                             .findAny();
                 }
                 public boolean contains(Variant variant, Role role) {
                     return findProjection(variant, role).isPresent();
                 }
                 public Set<CompileUnit> getUnits(RoleProjection projection) {
                     Objects.requireNonNull(projection, "Role projection can't be null");
                     return variants.getEntriesForVariant(projection.variant()).stream()
                             .filter(entry -> entry.role().equals(projection.role()))
                             .map(CompileUnit::of)
                             .collect(Collectors.toUnmodifiableSet());
                 }
-                public RoleProjection getProjection(Variant variant, Role role) {
+                public RoleProjection requireProjection(Variant variant, Role role) {
                     return findProjection(variant, role)
                             .orElseThrow(() -> new IllegalArgumentException(
                                     "Role projection for variant '" + variant.getName()
                                             + "' and role '" + role.getName() + "' not found"));
                 }
                 public Set<Layer> getLayers(RoleProjection projection) {
                     return getUnits(projection).stream()
                             .map(CompileUnit::layer)
                             .collect(java.util.stream.Collectors.toUnmodifiableSet());
                 }
                 public static RoleProjectionsView of(VariantsView variantsView) {
                     return new RoleProjectionsView(variantsView);
                 }
             }

variants/src/test/java/org/implab/gradle/variants/sources/RoleProjectionsViewTest.java +3 -3

             package org.implab.gradle.variants.sources;
             import static org.junit.jupiter.api.Assertions.assertEquals;
             import static org.junit.jupiter.api.Assertions.assertThrows;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.lang.reflect.Constructor;
             import java.util.Set;
             import org.implab.gradle.variants.core.Layer;
             import org.implab.gradle.variants.core.Role;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             import org.implab.gradle.variants.core.VariantsView.VariantRoleLayer;
             import org.junit.jupiter.api.Test;
             class RoleProjectionsViewTest {
                 @Test
                 void exposesRoleProjectionsAndTheirCompileUnits() {
                     var browser = new TestVariant("browser");
                     var main = new TestLayer("main");
                     var test = new TestLayer("test");
                     var production = new TestRole("production");
                     var qa = new TestRole("test");
                     var view = view(
                             Set.of(main, test),
                             Set.of(production, qa),
                             Set.of(browser),
                             Set.of(
                                     new VariantRoleLayer(browser, production, main),
                                     new VariantRoleLayer(browser, qa, main),
                                     new VariantRoleLayer(browser, qa, test)));
                     var projections = RoleProjectionsView.of(view);
-                    var productionProjection = projections.getProjection(browser, production);
+                    var productionProjection = projections.requireProjection(browser, production);
-                    var qaProjection = projections.getProjection(browser, qa);
+                    var qaProjection = projections.requireProjection(browser, qa);
                     assertEquals(Set.of(productionProjection, qaProjection), projections.getProjections());
                     assertEquals(Set.of(productionProjection, qaProjection), projections.getProjectionsForVariant(browser));
                     assertEquals(Set.of(qaProjection), projections.getProjectionsForRole(qa));
                     assertEquals(Set.of(new CompileUnit(browser, main)), projections.getUnits(productionProjection));
                     assertEquals(Set.of(new CompileUnit(browser, main), new CompileUnit(browser, test)), projections.getUnits(qaProjection));
                     assertEquals(Set.of(main, test), projections.getLayers(qaProjection));
                     assertTrue(projections.contains(browser, production));
                 }
                 @Test
                 void rejectsMissingProjectionLookup() {
                     var browser = new TestVariant("browser");
                     var node = new TestVariant("node");
                     var main = new TestLayer("main");
                     var production = new TestRole("production");
                     var view = view(
                             Set.of(main),
                             Set.of(production),
                             Set.of(browser, node),
                             Set.of(new VariantRoleLayer(browser, production, main)));
                     var projections = RoleProjectionsView.of(view);
-                    var ex = assertThrows(IllegalArgumentException.class, () -> projections.getProjection(node, production));
+                    var ex = assertThrows(IllegalArgumentException.class, () -> projections.requireProjection(node, production));
                     assertTrue(ex.getMessage().contains("Role projection for variant 'node' and role 'production' not found"));
                 }
                 private static VariantsView view(
                         Set<Layer> layers,
                         Set<Role> roles,
                         Set<Variant> variants,
                         Set<VariantRoleLayer> entries) {
                     try {
                         Constructor<VariantsView> ctor = VariantsView.class.getDeclaredConstructor(
                                 Set.class,
                                 Set.class,
                                 Set.class,
                                 Set.class);
                         ctor.setAccessible(true);
                         return ctor.newInstance(layers, roles, variants, entries);
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to create VariantsView fixture", e);
                     }
                 }
                 private record TestVariant(String value) implements Variant {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestLayer(String value) implements Layer {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
                 private record TestRole(String value) implements Role {
                     @Override
                     public String getName() {
                         return value;
                     }
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

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

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