implab/gradle-common Commit - r55:a06b08ec0a7f

variants: stabilize artifact slot materialization

cin -

r55:a06b08ec0a7f default

parent child

Context file:

r55:a06b08ec0a7f

Collapse all files

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

                         // wire artifact assemblies to configuration variants
                         var assembliesBridge = new ArtifactAssemblyBinder(assemblies);
                         var primarySlotConvention = new SingleSlotConvention(providers);
-                        var materializationHandler = new MaterializationPolicyHandler();
+                        var materializationHandler = new MaterializationPolicyHandler(objects);
                         // bind slot assemblies to outgoing variants
                         outgoing.configureEach(assembliesBridge::execute);

variants/src/main/java/org/implab/gradle/variants/artifacts/ArtifactAssemblies.java +6 -1

                  */
                 void configureEach(Action<? super ArtifactAssembly> action);
-                /** Ищет зарегистрированный слот */
+                /**
+                 * Finds a registered assembly for the given slot identity.
+                 *
+                 * @param slot slot identity inside a variant outgoing contract
+                 * @return registered assembly, if the slot body has already been materialized
+                 */
                 Optional<ArtifactAssembly> find(ArtifactSlot slot);
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingConfigurationSpec.java +1 -1

              * Materialized root outgoing configuration of a variant.
              *
              * <p>This is a variant-level publication hook. Slot-specific publication state is exposed separately via
-             * {@link OutgoingArtifactSlotSpec}.
+             * {@link OutgoingConfigurationSlotSpec}.
              */
             public interface OutgoingConfigurationSpec {
                 /**

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariant.java +27 -14

             import org.implab.gradle.variants.core.Variant;
             /**
-             * Описывает исходящую конфигурацию варианта
+             * Plugin model object for one variant-level outgoing contract.
              *
-             * Задает связь между моделью вариантов и моделью конфигураций gradle через
+             * <p>An outgoing variant connects a core {@link Variant} identity with the lazy
-             * свойство {@link #getConfiguration()}. Также задает отдельную ось слотов
+             * Gradle consumable configuration registered for that variant. It also exposes a
-             * публикации, но не задает правил связывания этих слотов с самой конфигурацией
+             * live container of slot identities. Slot identities are only declarations and do
-             * и их содержимым. Самый простой вариант это {@link ArtifactAssemblies}.
+             * not imply that a Gradle outgoing artifact variant or an {@link ArtifactAssembly}
+             * has been materialized.
              */
             public interface OutgoingVariant {
                 /**
-                 * Исходный вариант для которого строится Outgoing конфигурация
+                 * Returns the variant that owns this outgoing contract.
+                 *
+                 * @return variant identity
                  */
                 Variant getVariant();
                 /**
-                 * Провайдер зарегистрированной конфигурации
+                 * Returns the provider of the registered consumable outgoing configuration.
+                 *
+                 * @return outgoing configuration provider
                  */
                 NamedDomainObjectProvider<? extends Configuration> getConfiguration();
+                /**
+                 * Configures the registered outgoing configuration.
+                 *
+                 * @param action configuration action
+                 */
                 default void configureOutgoing(Action<? super Configuration> action) {
                     getConfiguration().configure(action);
                 }
                 /**
-                 * Слоты конфигурации, данная коллекция живая, используется для
+                 * Returns the live slot identity container.
-                 * получения информации об объявленных слотах, но эти слоты не
-                 * обязаны быть сконфигурированы, т.е. это только Identity.
+                 * <p>This collection is intended for discovery and selection. Slot presence does
+                 * not guarantee that the slot has a configured assembly body or a materialized
+                 * Gradle outgoing artifact variant.
                  *
                  * @see {@link ArtifactSlot}
                  */
                 NamedDomainObjectContainer<Slot> getSlots();
                 /**
-                 * Основной набор артефактов (primary variant) для исходящей конфигурации
+                 * Returns the primary slot property.
                  *
-                 * <p>
+                 * <p>If exactly one slot is declared, the single-slot convention uses that slot as
-                 * Если в свойстве {@link #getSlots()} есть только один слой, то по конвенции он
+                 * the primary one. Reading this property finalizes the selected primary slot.
-                 * считается также основным.
+                 * @return primary slot property
                  */
                 Property<Slot> getPrimarySlot();
             }

variants/src/main/java/org/implab/gradle/variants/artifacts/OutgoingVariantsContext.java +54 -3

@@ -7,29 +7,80 import org.gradle.api.InvalidUserDataExc
7	import org.implab.gradle.variants.core.Variant;	7	import org.implab.gradle.variants.core.Variant;
8		8
9	/**	9	/**
10	* Контекст работы с вариантами публикации, становится доступным после	10	* Live context for declaring and observing variant outgoing publications.
11	* финализации модели вариантов. Фактически является живой моделью	11	*
		12	* <p>The context becomes available after the core variant model has been finalized.
		13	* It owns variant-level outgoing declarations, assembly lookup, and hooks for
		14	* materialized Gradle-facing publication state.
12	*/	15	*/
13	public interface OutgoingVariantsContext {	16	public interface OutgoingVariantsContext {
14		17
		18	/**
		19	* Returns the assembly lookup service.
		20	*
		21	* <p>Assemblies are stateful slot bodies resolved from cheap {@link ArtifactSlot}
		22	* identities.
		23	*
		24	* @return assembly lookup service
		25	*/
15	ArtifactAssemblies getAssemblies();	26	ArtifactAssemblies getAssemblies();
16		27
		28	/**
		29	* Configures artifact slots of the given variant.
		30	*
		31	* @param variant variant identity
		32	* @param action variant artifact declaration
		33	*/
17	void configureVariant(Variant variant, Action<? super VariantArtifactsSpec> action);	34	void configureVariant(Variant variant, Action<? super VariantArtifactsSpec> action);
18		35
19	/**	36	/**
20	* Replayable hook для всех объявленных конфигураций	37	* Registers a replayable action for declared outgoing variants.
		38	*
		39	* <p>The action receives the plugin model object, not necessarily a materialized
		40	* Gradle publication. Use {@link #whenOutgoingConfiguration(Action)} and
		41	* {@link #whenOutgoingSlot(Action)} for materialized Gradle-facing state.
		42	*
		43	* @param action outgoing variant action
21	*/	44	*/
22	void configureEach(Action<? super OutgoingVariant> action);	45	void configureEach(Action<? super OutgoingVariant> action);
23		46
		47	/**
		48	* Finds the outgoing model for the given variant.
		49	*
		50	* @param variant variant identity
		51	* @return outgoing model, if declared
		52	*/
24	Optional<OutgoingVariant> findOutgoing(Variant variant);	53	Optional<OutgoingVariant> findOutgoing(Variant variant);
25		54
		55	/**
		56	* Requires the outgoing model for the given variant.
		57	*
		58	* @param variant variant identity
		59	* @return outgoing model
		60	* @throws InvalidUserDataException if the outgoing variant is not declared
		61	*/
26	default OutgoingVariant requireOutgoing(Variant variant) {	62	default OutgoingVariant requireOutgoing(Variant variant) {
27	return findOutgoing(variant)	63	return findOutgoing(variant)
28	.orElseThrow(() -> new InvalidUserDataException("Outgoing variant '" + variant + "' isn't registered"));	64	.orElseThrow(() -> new InvalidUserDataException("Outgoing variant '" + variant + "' isn't registered"));
29	}	65	}
30		66
		67	/**
		68	* Registers a replayable action for materialized variant-level outgoing
		69	* configurations.
		70	*
		71	* @param action materialized outgoing configuration action
		72	*/
31	void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action);	73	void whenOutgoingConfiguration(Action<? super OutgoingConfigurationSpec> action);
32		74
		75	/**
		76	* Registers a replayable action for materialized slot publications.
		77	*
		78	* <p>Slot publication hooks follow the Gradle outgoing publication model. A
		79	* declared slot identity by itself does not guarantee that a slot publication has
		80	* been materialized.
		81	*
		82	* @param action materialized slot publication action
		83	*/
33	void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action);	84	void whenOutgoingSlot(Action<? super OutgoingConfigurationSlotSpec> action);
34		85
35		86

variants/src/main/java/org/implab/gradle/variants/artifacts/VariantArtifactsSpec.java 0 -2

                  *
                  * @param name slot name
                  * @param action slot declaration
-                 * @return slot identity
                  */
                 void slot(String name, Action<? super ArtifactAssemblySpec> action);
                  *
                  * @param name slot name
                  * @param action slot declaration
-                 * @return slot identity
                  */
                 void primarySlot(String name, Action<? super ArtifactAssemblySpec> action);

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyBinder.java +9 -9

             import org.implab.gradle.variants.artifacts.OutgoingVariant;
             /**
-             * Связывает описание исходящих конфигураций gradle и сборку содержимого слотов
+             * Binds materialized slot assemblies to Gradle outgoing publications.
-             * из {@link ArtifactAssemblies}
              */
             @NonNullByDefault
             public class ArtifactAssemblyBinder implements Action<OutgoingVariant> {
                     var primarySlotProvider = outgoingVariant.getPrimarySlot();
                     var variant = outgoingVariant.getVariant();
-                    // связываем конфигурацию
+                    // Bind publication state when the owning configuration is materialized.
                     outgoingVariant.configureOutgoing(configuration -> {
                         var primarySlot = primarySlotProvider.get();
                         var outgoing = configuration.getOutgoing();
-                        // связываем основной вариант конфигурации
+                        // Bind the primary artifact set to the root outgoing configuration.
                         resolver.when(
                                 new ArtifactSlot(variant, primarySlot),
                                 assembly -> outgoing.artifact(assembly.getArtifact()));
-                        // для всех объявленных слотов
+                        // Bind non-primary slots to Gradle secondary artifact variants.
                         slots.all(slot -> {
-                            // кроме основного
                             if (slot.equals(primarySlot))
                                 return;
-                            // связываем артефакты
                             resolver.when(
                                     new ArtifactSlot(variant, slot),
+                                    // Gradle artifact variants must be created while the owning
+                                    // configuration is being materialized. Lazy registration may
+                                    // otherwise be realized only after dependency resolution starts.
                                     assembly -> outgoing.getVariants()
-                                            .register(slot.getName())
+                                            .create(slot.getName())
-                                            .configure(cv -> cv.artifact(assembly.getArtifact())));
+                                            .artifact(assembly.getArtifact()));
                         });
                     });
                 }

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/ArtifactAssemblyHandler.java +13 -29

             import org.gradle.api.tasks.TaskContainer;
             import org.gradle.language.base.plugins.LifecycleBasePlugin;
             import org.implab.gradle.common.core.lang.FilePaths;
+            import org.implab.gradle.variants.artifacts.ArtifactAssembly;
             import org.implab.gradle.variants.artifacts.ArtifactAssemblySpec;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             import org.implab.gradle.variants.sources.CompileUnit;
             import org.implab.gradle.variants.sources.SourceSetMaterializer;
             /**
-             * Адаптер между фрагментами артефактов, представленными в виде
+             * Adapts slot contribution declarations to materialized {@link ArtifactAssembly}
-             * {@link SlotContribution},
+             * handles.
-             * и ArtifactAssemblyRegistry, который оперирует уже собранными
-             * {@link ArtifactAssembly}.
              *
-             * Данный класс отвечает за сборку отдельных фрагментов артефактов в единый
+             * <p>The handler creates one {@link Sync} task per {@link ArtifactSlot}. The task
-             * каталог, который затем регистрируется в ArtifactAssemblyRegistry в виде
+             * copies all collected slot inputs into a single output directory. That output
-             * {@link ArtifactAssembly}. Сборка конечного артефакта происходит при помощи
+             * directory is then registered in {@link ArtifactAssemblyRegistry} as the
-             * задачи, которая копирует все входные файлы в выходной каталог. Задача
+             * published artifact for the slot.
-             * создается для каждого {@link ArtifactSlot} и использует
-             * {@link SlotAssembly#inputs()} как источник входных данных.
              *
-             * Для сборки используется паттерн Visitor: каждый фрагмент артефакта
+             * <p>Input collection uses {@link SlotContributionVisitor}. Each contribution is
-             * представлен в виде реализации интерфейса {@link SlotContribution}, который
+             * converted to a {@link SlotInputKey}; duplicate keys are ignored so that repeated
-             * имеет метод accept, принимающий Visitor.
+             * topology-based selections do not add the same input twice.
-             * Visitor реализован во внутреннем классе {@link ContributionVisitor}, который
-             * знает, как обрабатывать каждый тип фрагмента и добавлять его в сборку.
-             * Для каждого {@link SlotContribution} создается ключ {@link SlotInputKey},
-             * который используется для дедупликации: если фрагмент с таким же ключом уже
-             * был добавлен, то он игнорируется.
              */
             @NonNullByDefault
             public class ArtifactAssemblyHandler {
                 }
                 /**
-                 * Создает сборку для указанного слота артефакта, сборка регистрируется в
+                 * Creates the assembly task for the given slot and registers its output artifact.
-                 * ArtifactAssemblyRegistry, если для слота сборка уже была зарегистрирована
-                 * кем-то еще, то возникает ошибка.
                  */
                 private SlotAssembly createSlotAssembly(ArtifactSlot artifactSlot) {
                     var assembly = new SlotAssembly();
                 }
                 /**
-                 * Собирает отдельные фрагменты артефактов в единый источник
+                 * Collects slot contributions into one {@link ConfigurableFileCollection}.
-                 * {@link ConfigurableFileCollection}.
-                 * Для фрагментов {@link SlotContribution} используется механизм дедупликации:
-                 * для каждого
-                 * водящего фрагмента создается ключ {@link SlotInputKey} и добавляются
-                 * фрагменты только
-                 * с уникальным ключом, повторы игнорируются.
                  */
                 private class ContributionVisitor implements SlotContributionVisitor {
                     // artifact slot for this assembly
                     }
                 }
-                /** Состояние для отдельного слота */
+                /** Mutable input state for one slot assembly. */
                 class SlotAssembly {
                     private final ConfigurableFileCollection inputs = objects.fileCollection();
                     private final Set<SlotInputKey> seen = new HashSet<>();

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

             import org.implab.gradle.variants.artifacts.OutputSelectionSpec;
             /**
-             * Реализация DSL модели, строит набор {@link SlotContribution}. При построении набора
+             * Default DSL facade for collecting {@link SlotContribution} declarations.
-             * правила и корректность не проверяются. По окончании использования клиент
-             * вызывает метод {@link #process(Consumer)} для обработки результатов.
              *
+             * <p>The spec does not validate topology references immediately. It translates DSL
+             * calls to contribution objects and passes them to the supplied consumer; semantic
+             * validation happens later when the assembly handler resolves contributions
+             * against the finalized source model.
              */
             @NonNullByDefault
             final class DefaultArtifactAssemblySpec implements ArtifactAssemblySpec {

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/MaterializationPolicyHandler.java +11 -6

             import org.gradle.api.Action;
             import org.gradle.api.artifacts.Configuration;
             import org.gradle.api.attributes.AttributeContainer;
-            import org.implab.gradle.internal.ReplayableQueue;
+            import org.gradle.api.model.ObjectFactory;
+            import org.implab.gradle.common.core.lang.ReplayableQueue;
             import org.implab.gradle.variants.artifacts.ArtifactSlot;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSlotSpec;
             import org.implab.gradle.variants.artifacts.OutgoingConfigurationSpec;
             import org.implab.gradle.variants.artifacts.OutgoingVariant;
+            import org.implab.gradle.variants.artifacts.Slot;
             import org.implab.gradle.variants.core.Variant;
             /**
                 private final ReplayableQueue<OutgoingConfigurationSpec> variantMaterialization = new ReplayableQueue<>();
                 private final ReplayableQueue<OutgoingConfigurationSlotSpec> slotMaterialization = new ReplayableQueue<>();
+                private final ObjectFactory objects;
-                public MaterializationPolicyHandler() {
+                public MaterializationPolicyHandler(ObjectFactory objects) {
+                    this.objects = objects;
                 }
                 @Override
                 public void execute(OutgoingVariant outgoingVariant) {
-                    var slots = outgoingVariant.getSlots();
                     var primarySlotProvider = outgoingVariant.getPrimarySlot();
                     var variant = outgoingVariant.getVariant();
-                    // связываем конфигурацию
+                    // Materialization hooks are attached to the owning outgoing configuration.
                     outgoingVariant.configureOutgoing(configuration -> {
                         var primarySlot = primarySlotProvider.get();
                         var outgoing = configuration.getOutgoing();
                         slotMaterialized(new ArtifactSlot(variant, primarySlot), true, outgoing.getAttributes());
-                        slots.forEach(slot -> {
+                        // Slot publication hooks follow materialized Gradle artifact variants,
+                        // not the live slot identity view.
+                        outgoing.getVariants().configureEach(variantConfiguration -> {
+                            var slot = objects.named(Slot.class, variantConfiguration.getName());
                             if (slot.equals(primarySlot))
                                 return;
-                            var variantConfiguration = outgoing.getVariants().getByName(slot.getName());
                             slotMaterialized(new ArtifactSlot(variant, slot), false, variantConfiguration.getAttributes());
                         });
                     });

variants/src/main/java/org/implab/gradle/variants/artifacts/internal/SingleSlotConvention.java +1 -1

                     var slots = outgoingVariant.getSlots();
                     outgoingVariant.getPrimarySlot().convention(
-                            // если есть ровно один слот, то он считается primary
+                            // If exactly one slot is declared, it becomes the primary slot.
                             providers.provider(() -> {
                                 if (slots.size() == 0)
                                     throw new InvalidUserDataException("No slots declared for " + outgoingVariant.getVariant());

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

              * }
              * }</pre>
              *
-             * <p>After finalization, slot identities can be observed through
+             * <p>After finalization, {@link org.implab.gradle.variants.artifacts.OutgoingVariant} exposes declared slot
-             * {@link org.implab.gradle.variants.artifacts.OutgoingVariantsContext#getSlots()}, while slot bodies are
+             * identities through {@code getSlots()}, while slot bodies are obtained on demand through
-             * obtained on demand through
              * {@link org.implab.gradle.variants.artifacts.OutgoingVariantsContext#getAssemblies()}.
              */
             package org.implab.gradle.variants.artifacts;

variants/src/test/java/org/implab/gradle/variants/VariantArtifactsPluginFunctionalTest.java +128 0

@@ -103,6 +103,74 class VariantArtifactsPluginFunctionalTe
103	}	103	}
104		104
105	@Test	105	@Test
		106	void gradleReferenceRegisteredSecondaryArtifactVariantIsNotRealizedBeforeResolution() throws Exception {
		107	// Gradle issue: https://github.com/gradle/gradle/issues/27441
		108	// Registered outgoing artifact variants are not realized before dependency resolution.
		109	writeFile("settings.gradle", """
		110	rootProject.name = 'gradle-reference-registered-secondary-variant'
		111	include 'producer', 'consumer'
		112	""");
		113	writeFile("producer/inputs/typesPackage", "types\n");
		114	writeFile("producer/inputs/js", "js\n");
		115	writeFile("build.gradle", """
		116	import org.gradle.api.attributes.Attribute
		117
		118	def variantAttr = Attribute.of('test.variant', String)
		119	def slotAttr = Attribute.of('test.slot', String)
		120
		121	project(':producer') {
		122	def browserElements = configurations.consumable('browserElements')
		123
		124	browserElements.configure { configuration ->
		125	configuration.attributes.attribute(variantAttr, 'browser')
		126	configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
		127	configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
		128
		129	configuration.outgoing.variants.register('js') { secondary ->
		130	secondary.attributes.attribute(slotAttr, 'js')
		131	secondary.artifact(layout.projectDirectory.file('inputs/js'))
		132	}
		133	}
		134	}
		135
		136	project(':consumer') {
		137	configurations {
		138	compileView {
		139	canBeResolved = true
		140	canBeConsumed = false
		141	canBeDeclared = true
		142	attributes {
		143	attribute(variantAttr, 'browser')
		144	attribute(slotAttr, 'typesPackage')
		145	}
		146	}
		147	}
		148
		149	dependencies {
		150	compileView project(':producer')
		151	}
		152
		153	tasks.register('probe') {
		154	doLast {
		155	def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
		156	def jsFiles = configurations.compileView.incoming.artifactView {
		157	attributes {
		158	attribute(slotAttr, 'js')
		159	}
		160	}.files.files.collect { it.name }.sort().join(',')
		161
		162	println('compileFiles=' + compileFiles)
		163	println('jsFiles=' + jsFiles)
		164	}
		165	}
		166	}
		167	""");
		168
		169	assertBuildFails("Cannot create variant 'js' after dependency configuration ':producer:browserElements' has been resolved",
		170	":consumer:probe");
		171	}
		172
		173	@Test
106	void materializesPrimaryAndSecondarySlotsAndInvokesOutgoingHooks() throws Exception {	174	void materializesPrimaryAndSecondarySlotsAndInvokesOutgoingHooks() throws Exception {
107	writeSettings("variant-artifacts-slots");	175	writeSettings("variant-artifacts-slots");
108	writeFile("inputs/base.js", "console.log('base')\n");	176	writeFile("inputs/base.js", "console.log('base')\n");
@@ -207,6 +275,66 class VariantArtifactsPluginFunctionalTe
207	}	275	}
208		276
209	@Test	277	@Test
		278	void outgoingSlotHookFollowsMaterializedGradleArtifactVariants() throws Exception {
		279	writeSettings("variant-artifacts-materialized-gradle-variant");
		280	writeFile("inputs/typesPackage", "types\n");
		281	writeFile("inputs/js", "js\n");
		282	writeBuildFile("""
		283	import org.gradle.api.attributes.Attribute
		284
		285	apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
		286
		287	def slotAttr = Attribute.of('test.slot', String)
		288
		289	variants.layers.create('main')
		290	variants.roles.create('main')
		291	variants.variant('browser') {
		292	role('main') {
		293	layers('main')
		294	}
		295	}
		296
		297	variantArtifacts {
		298	variant('browser') {
		299	primarySlot('typesPackage') {
		300	from(layout.projectDirectory.file('inputs/typesPackage'))
		301	}
		302	}
		303
		304	whenOutgoingConfiguration { publication ->
		305	publication.configuration {
		306	outgoing.variants.create('js') { secondary ->
		307	secondary.artifact(layout.projectDirectory.file('inputs/js'))
		308	}
		309	}
		310	}
		311
		312	whenOutgoingSlot { publication ->
		313	publication.artifactAttributes {
		314	attribute(slotAttr, publication.artifactSlot.slot.name)
		315	}
		316	}
		317	}
		318
		319	tasks.register('probe') {
		320	doLast {
		321	def elements = configurations.getByName('browserElements')
		322	def jsVariant = elements.outgoing.variants.getByName('js')
		323
		324	println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
		325	println('jsSlotAttr=' + jsVariant.attributes.getAttribute(slotAttr))
		326	}
		327	}
		328	""");
		329
		330	BuildResult result = runner("probe").build();
		331
		332	assertTrue(result.getOutput().contains("primarySlotAttr=typesPackage"));
		333	assertTrue(result.getOutput().contains("jsSlotAttr=js"));
		334	assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
		335	}
		336
		337	@Test
210	void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {	338	void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
211	writeSettings("variant-artifacts-single-slot");	339	writeSettings("variant-artifacts-single-slot");
212	writeBuildFile("""	340	writeBuildFile("""

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