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

@@ -29,3 +29,17
29	- whenFinalized	29	- whenFinalized
30	- whenOutgoingConfiguration	30	- whenOutgoingConfiguration
31	- whenOutgoingSlot	31	- whenOutgoingSlot
		32
		33	outgoing = outgoings.maybeCreate(variant)
		34
		35	slot = outgoings.slots.maybeCreate(slotName)
		36	assembly = assemblies.register(variantSlot, task, mapOutput)
		37	outgoing.configure(configuration -> {
		38	slots.all(slot -> {
		39	assemblies.when(variant, slot) { assembly ->
		40	configuration.variants.create(slot.name) {
		41	artifact(assembly.artifact)
		42	}
		43	}
		44	});
		45	}); No newline at end of file

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

             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;
                     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 whenFinalized(Action<? super VariantArtifactsContext> action) {
+                        public void whenFinalized(Action<? super OutgoingVariantsContext> action) {
                             deferred.whenResolved(registry -> action.execute(registry.variantsContext()));
                         }

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblies.java +21 0

@@ -3,6 +3,7 package org.implab.gradle.variants.artif
3	import java.util.Optional;	3	import java.util.Optional;
4		4
5	import org.eclipse.jdt.annotation.NonNullByDefault;	5	import org.eclipse.jdt.annotation.NonNullByDefault;
		6	import org.gradle.api.Action;
6	import org.gradle.api.InvalidUserDataException;	7	import org.gradle.api.InvalidUserDataException;
7		8
8	/**	9	/**
@@ -29,5 +30,25 public interface ArtifactAssemblies {
29	.orElseThrow(() -> new InvalidUserDataException("Artifact assembly '" + slot + "' isn't registered"));	30	.orElseThrow(() -> new InvalidUserDataException("Artifact assembly '" + slot + "' isn't registered"));
30	}	31	}
31		32
		33	/**
		34	* Регистрирует обработчик на конкретный слот. Если слот еще не зарегистрирован,
		35	* то обработчик будет добавлен в очередь и будет вызван при регистрации слота.
		36	* Порядок и точный момент вызова обработчиков не определен.
		37	*
		38	* @param slot Слот на который нужно зарегистрировать обработчик
		39	* @param action Обработчик
		40	*/
		41	void when(ArtifactSlot slot, Action<? super ArtifactAssembly> action);
		42
		43	/**
		44	* Регистрирует глобальный обработчик, который будет вызван для всех слотов.
		45	* Обработчик будет вызван как для уже зарегистрированных слотов так и для тех,
		46	* которые будут зарегистрированы в будущем.
		47	*
		48	* @param action Обработчик
		49	*/
		50	void all(Action<? super ArtifactAssembly> action);
		51
		52	/** Ищет зарегистрированный слот */
32	Optional<ArtifactAssembly> find(ArtifactSlot slot);	53	Optional<ArtifactAssembly> find(ArtifactSlot slot);
33	}	54	}

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

             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.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;
                 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 {

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

              * 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.
                  *

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 конфигурация
                  */
                 /**
                  * Провайдер зарегистрированной конфигурации
                  */
-                NamedDomainObjectProvider<Configuration> getOutgoingConfiguration();
+                NamedDomainObjectProvider<Configuration> getConfiguration();
+                default void configure(Action<? super Configuration> action) {
+                    getConfiguration().configure(action);
+                }
                 /**
                  * Слоты конфигурации, данная коллекция живая, используется для

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

              * Контекст работы с вариантами публикации, становится доступным после
              * финализации модели вариантов. Фактически является живой моделью
              */
-            public interface VariantArtifactsContext {
+            public interface OutgoingVariantsContext {
                 /**
                  * Зафиксированное представление о вариантах на основе которого адаптеры могут
                 /**
                  * 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"));
                 }

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

                  *
                  * @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));
                  *
                  * @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

             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;
                 }
                 @Override
-                public NamedDomainObjectProvider<Configuration> getOutgoingConfiguration() {
+                public NamedDomainObjectProvider<Configuration> getConfiguration() {
                     return configurationProvider;
                 }

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;
                     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) {
                     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

              * }</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