implab/gradle-common Commit - r49:e7554f6ac360

WIP Added ArtifactAssemblyBridge to wire variants with slot assemblies

cin -

r49:e7554f6ac360 default

parent child

Context file:

r49:e7554f6ac360

Collapse all files

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyBridge.java created 644 +54 0

@@ -0,0 +1,54
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import org.eclipse.jdt.annotation.NonNullByDefault;
	4	import org.gradle.api.Action;
	5	import org.implab.gradle.variants.artifacts.ArtifactAssemblies;
	6	import org.implab.gradle.variants.artifacts.ArtifactSlot;
	7	import org.implab.gradle.variants.artifacts.OutgoingVariant;
	8
	9	/**
	10	* Связывает описание исходящих конфигураций gradle и сборку содержимого слотов
	11	* из {@link ArtifactAssemblies}
	12	*/
	13	@NonNullByDefault
	14	public class ArtifactAssemblyBridge implements Action<OutgoingVariant> {
	15
	16	private final ArtifactAssemblies resolver;
	17
	18	public ArtifactAssemblyBridge(ArtifactAssemblies resolver) {
	19	this.resolver = resolver;
	20	}
	21
	22	@Override
	23	public void execute(OutgoingVariant outgoingVariant) {
	24	var slots = outgoingVariant.getSlots();
	25	var primarySlotProvider = outgoingVariant.getPrimarySlot();
	26	var variant = outgoingVariant.getVariant();
	27
	28	// связываем конфигурацию
	29	outgoingVariant.configure(configuration -> {
	30	var primarySlot = primarySlotProvider.get();
	31	var outgoing = configuration.getOutgoing();
	32
	33	// связываем основной вариант конфигурации
	34	resolver.when(
	35	new ArtifactSlot(variant, primarySlot),
	36	assembly -> outgoing.artifact(assembly.getArtifact()));
	37
	38	// для всех объявленных слотов
	39	slots.all(slot -> {
	40	// кроме основного
	41	if (slot.equals(primarySlot))
	42	return;
	43
	44	// связываем артефакты
	45	resolver.when(
	46	new ArtifactSlot(variant, slot),
	47	assembly -> outgoing.getVariants()
	48	.register(slot.getName())
	49	.configure(cv -> cv.artifact(assembly.getArtifact())));
	50	});
	51	});
	52	}
	53
	54	}

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/SlotInputsAssembler.java created 644 +55 0

@@ -0,0 +1,55
	1	package org.implab.gradle.variants.artifacts.internal;
	2
	3	import java.util.Collection;
	4	import java.util.Set;
	5	import java.util.function.Consumer;
	6	import java.util.function.Function;
	7
	8	import org.implab.gradle.variants.artifacts.ArtifactSlot;
	9	import org.implab.gradle.variants.core.VariantsView;
	10	import org.implab.gradle.variants.sources.CompileUnit;
	11	import org.implab.gradle.variants.sources.VariantSourcesContext;
	12
	13	public class SlotInputsAssembler implements SlotContributionVisitor {
	14
	15	VariantsView variantView;
	16	VariantSourcesContext sources;
	17	ArtifactSlot artifactSlot;
	18
	19	Set<SlotInputKey> seen;
	20
	21	@Override
	22	public void visit(DirectContribution contribution) {
	23	contribute(
	24	SlotInputKey.newUniqueKey("Direct input for " + artifactSlot),
	25	contribution.input());
	26	}
	27
	28	@Override
	29	public void visit(VariantOutputsContribution contribution) {
	30	sources.getCompileUnits().getUnitsForVariant(artifactSlot.variant()).stream()
	31	}
	32
	33	@Override
	34	public void visit(RoleOutputsContribution contribution) {
	35	// TODO Auto-generated method stub
	36	throw new UnsupportedOperationException("Unimplemented method 'visit'");
	37	}
	38
	39	@Override
	40	public void visit(LayerOutputsContribution contribution) {
	41	// TODO Auto-generated method stub
	42	throw new UnsupportedOperationException("Unimplemented method 'visit'");
	43	}
	44
	45	private void contribute(SlotInputKey key, Object input) {
	46
	47	}
	48
	49	private Function<CompileUnit, Object> resolveOutputs(Collection<? extends String> outputs) {
	50	return unit -> {
	51
	52	};
	53	}
	54
	55	}

design_notes.md +14 0

             # design notes
             ## core model
             - OutgoingRegistry (Variant)
               исходящая конфигурация
               - [provider] configuration
               - [container, live] slots
                 набор вариантов (слотов)
               - [property] primarySlot
             - AssemblyRegistry (Varaint, Slot)
               содержимое слота может быть добавлено после появления слота в OutgoingRegistry
               - assembleTask
                 - inputs
                   - compile unit output (CompileUnit, String)
                   - direct object (task, file collection, etc.)
                 - artifact: directory
               - customTask
                 - artifact: FileSystemLocation
             ## extension
             - adapter
               - whenFinalized
             - dsl
               - variant(name)
                 - slot(name)
                 - from***
               - whenFinalized
               - whenOutgoingConfiguration
               - whenOutgoingSlot
+            outgoing = outgoings.maybeCreate(variant)
+            slot = outgoings.slots.maybeCreate(slotName)
+            assembly = assemblies.register(variantSlot, task, mapOutput)
+            outgoing.configure(configuration -> {
+                slots.all(slot -> {
+                    assemblies.when(variant, slot) { assembly ->
+                        configuration.variants.create(slot.name) {
+                            artifact(assembly.artifact)
+                        }
+                    }
+                });
+            });
  No newline at end of file

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

             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.OutgoingArtifactSlotSpec;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
-            import org.implab.gradle.variants.artifacts.VariantArtifactsContext;
+            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.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);
-                    var deferred = new Deferred<VariantArtifactsContext>();
+                    var assembliesBridge = new ArtifactAssemblyBridge(assemblies);
+                    var deferred = new Deferred<OutgoingVariantsContext>();
+                    deferred.whenResolved(context -> context.all(assembliesBridge));
                     variantsExtension.whenFinalized(variants -> {
-                        deferred.resolve(new VariantArtifactsRegistry(variants));
                     });
                     var variantArtifacts = new VariantArtifactsExtension() {
                         @Override
                         public void variant(String variantName, Action<? super VariantArtifactsSpec> action) {
                             deferred.whenResolved(context -> registry.configureVariant(
                                     objects.named(Variant.class, variantName), action));
                         }
                         @Override
-                        public void whenFinalized(Action<? super VariantArtifactsContext> action) {
+                        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/ArtifactAssemblies.java +21 0

             package org.implab.gradle.variants.artifacts;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
+            import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             /**
              * Resolves stateful slot assemblies from cheap slot identities.
              *
              * <p>
              * The returned assembly is a materialized build-model handle. It may expose
              * lazy Gradle providers, but
              * it is no longer an identity object suitable for replayable discovery.
              */
             @NonNullByDefault
             public interface ArtifactAssemblies {
                 /**
                  * Resolves the assembly for the given slot.
                  *
                  * <p>
                  * This call materializes the build-facing body of the slot from its identity.
                  *
                  * @param slot slot identity inside a variant outgoing contract
                  * @return assembly handle for the slot
                  */
                 default ArtifactAssembly require(ArtifactSlot slot) {
                     return find(slot)
                             .orElseThrow(() -> new InvalidUserDataException("Artifact assembly '" + slot + "' isn't registered"));
                 }
+                /**
+                 * Регистрирует обработчик на конкретный слот. Если слот еще не зарегистрирован,
+                 * то обработчик будет добавлен в очередь и будет вызван при регистрации слота.
+                 * Порядок и точный момент вызова обработчиков не определен.
+                 *
+                 * @param slot   Слот на который нужно зарегистрировать обработчик
+                 * @param action Обработчик
+                 */
+                void when(ArtifactSlot slot, Action<? super ArtifactAssembly> action);
+                /**
+                 * Регистрирует глобальный обработчик, который будет вызван для всех слотов.
+                 * Обработчик будет вызван как для уже зарегистрированных слотов так и для тех,
+                 * которые будут зарегистрированы в будущем.
+                 *
+                 * @param action Обработчик
+                 */
+                void all(Action<? super ArtifactAssembly> action);
+                /** Ищет зарегистрированный слот */
                 Optional<ArtifactAssembly> find(ArtifactSlot slot);
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblyRegistry.java +31 -6

             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, ArtifactAssembly> assemblies = new LinkedHashMap<>();
+                private final Map<ArtifactSlot, Deferred<ArtifactAssembly>> assembliesBySlots = new LinkedHashMap<>();
+                private final ReplayableQueue<ArtifactAssembly> assemblies = new ReplayableQueue<>();
                 public ArtifactAssemblyRegistry(ObjectFactory objects, TaskContainer tasks) {
                     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>> mapOutputDirectory) {
+                        Function<? super T, ? extends Provider<? extends FileSystemLocation>> mapOutputArtifact) {
-                    if (assemblies.containsKey(slot)) {
+                    var deferred = getDeferred(slot);
+                    if (deferred.resolved()) {
                         throw new InvalidUserDataException("Artifact assembly '" + slot + "' is already registered");
                     }
-                    var outputArtifact = task.flatMap(t -> mapOutputDirectory.apply(t));
+                    var outputArtifact = task.flatMap(mapOutputArtifact::apply);
                     var output = objects.fileCollection()
                             .from(outputArtifact)
                             .builtBy(task);
                     var assembly = new Assembly(outputArtifact, task, output);
-                    assemblies.put(slot, assembly);
+                    deferred.resolve(assembly);
+                    assemblies.add(assembly);
                     return assembly;
                 }
                 @Override
                 public Optional<ArtifactAssembly> find(ArtifactSlot slot) {
-                    return Optional.ofNullable(assemblies.get(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,
                             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/OutgoingConfigurationSlotSpec.java ~~variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingArtifactSlotSpec.java~~ renamed +1 -1

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
             import org.gradle.api.Task;
             import org.gradle.api.attributes.AttributeContainer;
             import groovy.lang.Closure;
             import org.implab.gradle.common.core.lang.Closures;
             /**
              * Materialized outgoing publication state of a single slot.
              *
              * <p>This type is a DSL facade to represent already created publication-facing state. Slot-specific
              * publication tweaks should be applied here rather than through {@link OutgoingConfigurationSpec}, which
              * is limited to the root outgoing configuration of the variant.
              */
-            public interface OutgoingArtifactSlotSpec {
+            public interface OutgoingConfigurationSlotSpec {
                 /**
                  * Returns the published slot identity.
                  *
                  * @return slot identity
                  */
                 ArtifactSlot getArtifactSlot();
                 /**
                  * Returns the assembly backing the published slot.
                  *
                  * @return slot assembly
                  */
                 ArtifactAssembly getAssembly();
                 /**
                  * Returns whether this slot is the primary outgoing artifact set of the variant.
                  *
                  * @return {@code true} for the primary slot
                  */
                 boolean isPrimary();
                 /**
                  * Configures the task producing the slot artifact.
                  *
                  * @param action task configuration action
                  */
                 void assemblyTask(Action<? super Task> action);
                 default void assemblyTask(Closure<?> closure) {
                     assemblyTask(Closures.action(closure));
                 }
                 /**
                  * Configures attributes of this slot publication.
                  *
                  * @param action artifact attribute configuration action
                  */
                 void artifactAttributes(Action<? super AttributeContainer> action);
                 default void artifactAttributes(Closure<?> closure) {
                     artifactAttributes(Closures.action(closure));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariant.java ~~variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingConfiguration.java~~ renamed +15 -3

             package org.implab.gradle.variants.artifacts;
+            import org.gradle.api.Action;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.provider.Property;
             import org.implab.gradle.variants.core.Variant;
-            /** Описывает исходящую конфигурацию варианта */
+            /**
-            public interface OutgoingConfiguration {
+             * Описывает исходящую конфигурацию варианта
+             *
+             * Задает связь между моделью вариантов и моделью конфигураций gradle через
+             * свойство {@link #getConfiguration()}. Также задает отдельную ось слотов
+             * публикации, но не задает правил связывания этих слотов с самой конфигурацией
+             * и их содержимым. Самый простой вариант это {@link ArtifactAssemblies}.
+             */
+            public interface OutgoingVariant {
                 /**
                  * Исходный вариант для которого строится Outgoing конфигурация
                  */
                 Variant getVariant();
                 /**
                  * Провайдер зарегистрированной конфигурации
                  */
-                NamedDomainObjectProvider<Configuration> getOutgoingConfiguration();
+                NamedDomainObjectProvider<Configuration> getConfiguration();
+                default void configure(Action<? super Configuration> action) {
+                    getConfiguration().configure(action);
+                }
                 /**
                  * Слоты конфигурации, данная коллекция живая, используется для
                  * получения информации об объявленных слотах, но эти слоты не
                  * обязаны быть сконфигурированы, т.е. это только Identity.
                  *
                  * @see {@link ArtifactSlot}
                  */
                 NamedDomainObjectContainer<Slot> getSlots();
                 /**
                  * Основной набор артефактов (primary variant) для исходящей конфигурации
                  *
                  * <p>
                  * Если в свойстве {@link #getSlots()} есть только один слой, то по конвенции он
                  * считается также основным.
                  */
                 Property<Slot> getPrimarySlot();
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariantsContext.java ~~variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsContext.java~~ renamed +4 -4

             package org.implab.gradle.variants.artifacts;
             import java.util.Optional;
             import org.gradle.api.Action;
             import org.gradle.api.InvalidUserDataException;
             import org.implab.gradle.variants.core.Variant;
             import org.implab.gradle.variants.core.VariantsView;
             /**
              * Контекст работы с вариантами публикации, становится доступным после
              * финализации модели вариантов. Фактически является живой моделью
              */
-            public interface VariantArtifactsContext {
+            public interface OutgoingVariantsContext {
                 /**
                  * Зафиксированное представление о вариантах на основе которого адаптеры могут
                  * конфигурировать артефакты и исходящие конфигурации
                  */
                 VariantsView getVariants();
                 ArtifactAssemblies getAssemblies();
                 /**
                  * Replayable hook для всех объявленных конфигураций
                  */
-                void all(Action<? super OutgoingConfiguration> action);
+                void all(Action<? super OutgoingVariant> action);
-                Optional<OutgoingConfiguration> findOutgoing(Variant variant);
+                Optional<OutgoingVariant> findOutgoing(Variant variant);
-                default OutgoingConfiguration requireOutgoing(Variant variant) {
+                default OutgoingVariant requireOutgoing(Variant variant) {
                     return findOutgoing(variant)
                             .orElseThrow(() -> new InvalidUserDataException("Outgoing variant '" + variant + "' isn't registered"));
                 }
                 ArtifactAssemblyRules slotRules(ArtifactSlot slot);
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsExtension.java +2 -2

             package org.implab.gradle.variants.artifacts;
             import org.gradle.api.Action;
             import org.implab.gradle.common.core.lang.Closures;
             import groovy.lang.Closure;
             /**
              * Project-level DSL entry point for declaring outgoing artifacts per variant.
              *
              * <p>A variant represents one external outgoing contract. Slots declared inside a variant represent
              * artifact sets within that contract. One slot is expected to materialize to one published artifact.
              */
             public interface VariantArtifactsExtension {
                 /**
                  * Configures artifact slots of the named variant.
                  *
                  * @param variantName variant name
                  * @param action variant artifact declaration
                  */
                 void variant(String variantName, Action<? super VariantArtifactsSpec> action);
                 default void variant(String variantName, Closure<?> closure) {
                     variant(variantName, Closures.action(closure));
                 }
                 /**
                  * Registers a callback invoked with the finalized artifact model.
                  *
                  * @param action finalized-model callback
                  */
-                void whenFinalized(Action<? super VariantArtifactsContext> action);
+                void whenFinalized(Action<? super OutgoingVariantsContext> action);
                 default void whenFinalized(Closure<?> closure) {
                     whenFinalized(Closures.action(closure));
                 }
                 /**
                  * Registers a callback invoked for each materialized root outgoing configuration.
                  *
                  * @param action variant-level outgoing configuration callback
                  */
                 void whenOutgoingVariant(Action<? super OutgoingConfigurationSpec> action);
                 default void whenOutgoingVariant(Closure<?> closure) {
                     whenOutgoingVariant(Closures.action(closure));
                 }
                 /**
                  * Registers a callback invoked for each materialized outgoing slot publication.
                  *
                  * @param action slot-level outgoing publication callback
                  */
-                void whenOutgoingSlot(Action<? super OutgoingArtifactSlotSpec> action);
+                void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action);
                 default void whenOutgoingSlot(Closure<?> closure) {
                     whenOutgoingSlot(Closures.action(closure));
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/DefaultOutgoingConfiguration.java +3 -3

             package org.implab.gradle.variants.artifacts.internal;
             import org.gradle.api.NamedDomainObjectContainer;
             import org.gradle.api.NamedDomainObjectProvider;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Property;
             import org.gradle.api.provider.ProviderFactory;
             import org.gradle.api.provider.Provider;
-            import org.implab.gradle.variants.artifacts.OutgoingConfiguration;
+            import org.implab.gradle.variants.artifacts.OutgoingVariant;
             import org.implab.gradle.variants.artifacts.Slot;
             import org.implab.gradle.variants.core.Variant;
-            class DefaultOutgoingConfiguration implements OutgoingConfiguration {
+            class DefaultOutgoingConfiguration implements OutgoingVariant {
                 private final Variant variant;
                 private final NamedDomainObjectProvider<Configuration> configurationProvider;
                 private final NamedDomainObjectContainer<Slot> slots;
                 private final Property<Slot> primarySlot;
                 public DefaultOutgoingConfiguration(
                         Variant variant,
                         NamedDomainObjectProvider<Configuration> configurationProvider,
                         ObjectFactory objectFactory,
                         ProviderFactory providerFactory) {
                     this.variant = variant;
                     this.configurationProvider = configurationProvider;
                     this.slots = objectFactory.domainObjectContainer(Slot.class);
                     this.primarySlot = objectFactory.property(Slot.class)
                             .convention(providerFactory
                                     .provider(this::primarySlotConvention)
                                     .flatMap(x -> x));
                 }
                 @Override
                 public Property<Slot> getPrimarySlot() {
                     return primarySlot;
                 }
                 @Override
                 public Variant getVariant() {
                     return variant;
                 }
                 @Override
-                public NamedDomainObjectProvider<Configuration> getOutgoingConfiguration() {
+                public NamedDomainObjectProvider<Configuration> getConfiguration() {
                     return configurationProvider;
                 }
                 @Override
                 public NamedDomainObjectContainer<Slot> getSlots() {
                     return slots;
                 }
                 private Provider<Slot> primarySlotConvention() {
                     return slots.size() == 1 ? slots.named(slots.getNames().first()) : null;
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/OutgoingRegistry.java +16 -5

             package org.implab.gradle.variants.artifacts.internal;
             import java.util.LinkedHashMap;
+            import java.util.LinkedList;
+            import java.util.List;
             import java.util.Map;
             import java.util.Optional;
+            import java.util.function.Consumer;
             import org.gradle.api.artifacts.ConfigurationContainer;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.ProviderFactory;
-            import org.implab.gradle.variants.artifacts.OutgoingConfiguration;
+            import org.implab.gradle.variants.artifacts.OutgoingVariant;
             import org.implab.gradle.variants.core.Variant;
             public class OutgoingRegistry {
                 private final Map<Variant, DefaultOutgoingConfiguration> outgoingByVariant = new LinkedHashMap<>();
+                private final List<Consumer<? super DefaultOutgoingConfiguration>> hooks = new LinkedList<>();
                 private final ConfigurationContainer configurations;
                 private final ObjectFactory objects;
                 private final ProviderFactory providers;
                 public OutgoingRegistry(ConfigurationContainer configurations, ObjectFactory objects, ProviderFactory providers) {
                     this.configurations = configurations;
                     this.objects = objects;
                     this.providers = providers;
                 }
-                public Optional<OutgoingConfiguration> findOutgoing(Variant variant) {
+                public Optional<OutgoingVariant> findOutgoing(Variant variant) {
                     return Optional.ofNullable(outgoingByVariant.get(variant));
                 }
-                public OutgoingConfiguration maybeCreate(Variant variant) {
+                public OutgoingVariant maybeCreate(Variant variant) {
-                    return outgoingByVariant.computeIfAbsent(variant, this::newOutgoingConfiguration);
+                    var outgoing = outgoingByVariant.computeIfAbsent(variant, this::newOutgoingConfiguration);
+                    hooks.forEach(hook -> hook.accept(outgoing));
+                    return outgoing;
+                }
+                public void all(Consumer<? super OutgoingVariant> action) {
+                    outgoingByVariant.values().forEach(action);
+                    hooks.add(action);
                 }
                 private DefaultOutgoingConfiguration newOutgoingConfiguration(Variant variant) {
                     var configuration = configurations.register(outgoingConfigurationName(variant));
                     return new DefaultOutgoingConfiguration(variant, configuration, objects, providers);
                 }
-                String outgoingConfigurationName(Variant variant) {
+                private String outgoingConfigurationName(Variant variant) {
                     return variant.getName() + "Elements";
                 }
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/package-info.java +2 -2

             /**
              * Variant-scoped outgoing artifacts.
              *
              * <p>This package models the external artifact contract of a project in terms of variant-local slots.
              * A variant represents one outgoing contract, while a slot represents one artifact set inside that
              * contract.
              *
              * <p>The model intentionally separates cheap identity objects from stateful build objects:
              *
              * <ul>
              * <li>{@link org.implab.gradle.variants.artifacts.ArtifactSlot} identifies a published slot inside a
              * variant;</li>
              * <li>{@link org.implab.gradle.variants.artifacts.ArtifactAssembly} is the lazily materialized body of
              * that slot.</li>
              * </ul>
              *
              * <p>Each slot is expected to materialize to exactly one published artifact: either one file or one
              * directory. Internal build topology such as roles may participate in slot assembly rules, but does not
              * belong to external artifact identity.
              *
              * <p>Typical usage:
              *
              * <pre>{@code
              * variantArtifacts {
              *     variant("browser") {
              *         primarySlot("runtime") {
              *             fromRole("main") { output("js") }
              *         }
              *         slot("sources") {
              *             fromLayer("main") { output("sources") }
              *         }
              *     }
              * }
              * }</pre>
              *
              * <p>After finalization, slot identities can be observed through
-             * {@link org.implab.gradle.variants.artifacts.VariantArtifactsContext#getSlots()}, while slot bodies are
+             * {@link org.implab.gradle.variants.artifacts.OutgoingVariantsContext#getSlots()}, while slot bodies are
              * obtained on demand through
-             * {@link org.implab.gradle.variants.artifacts.VariantArtifactsContext#getAssemblies()}.
+             * {@link org.implab.gradle.variants.artifacts.OutgoingVariantsContext#getAssemblies()}.
              */
             package org.implab.gradle.variants.artifacts;

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