Extract remote source provider registry into the vscode.git-base extension (#137656)

extensions/github/src/extension.ts

@@ -3,43 +3,94 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Disposable, ExtensionContext, extensions } from 'vscode';
+import { commands, Disposable, ExtensionContext, extensions } from 'vscode';
 import { GithubRemoteSourceProvider } from './remoteSourceProvider';
 import { GitExtension } from './typings/git';
 import { registerCommands } from './commands';
 import { GithubCredentialProviderManager } from './credentialProvider';
 import { dispose, combinedDisposable } from './util';
 import { GithubPushErrorHandler } from './pushErrorHandler';
+import { GitBaseExtension } from './typings/git-base';
+import { GithubRemoteSourcePublisher } from './remoteSourcePublisher';
 
 export function activate(context: ExtensionContext): void {
+	context.subscriptions.push(initializeGitBaseExtension());
+	context.subscriptions.push(initializeGitExtension());
+}
+
+function initializeGitBaseExtension(): Disposable {
 	const disposables = new Set<Disposable>();
-	context.subscriptions.push(combinedDisposable(disposables));
 
-	const init = () => {
+	const initialize = () => {
 		try {
-			const gitAPI = gitExtension.getAPI(1);
+			const gitBaseAPI = gitBaseExtension.getAPI(1);
 
-			disposables.add(registerCommands(gitAPI));
-			disposables.add(gitAPI.registerRemoteSourceProvider(new GithubRemoteSourceProvider(gitAPI)));
-			disposables.add(new GithubCredentialProviderManager(gitAPI));
-			disposables.add(gitAPI.registerPushErrorHandler(new GithubPushErrorHandler()));
-		} catch (err) {
+			disposables.add(gitBaseAPI.registerRemoteSourceProvider(new GithubRemoteSourceProvider()));
+		}
+		catch (err) {
 			console.error('Could not initialize GitHub extension');
 			console.warn(err);
 		}
 	};
 
-	const onDidChangeGitExtensionEnablement = (enabled: boolean) => {
+	const onDidChangeGitBaseExtensionEnablement = (enabled: boolean) => {
 		if (!enabled) {
 			dispose(disposables);
 			disposables.clear();
 		} else {
-			init();
+			initialize();
 		}
 	};
 
+	const gitBaseExtension = extensions.getExtension<GitBaseExtension>('vscode.git-base')!.exports;
+	disposables.add(gitBaseExtension.onDidChangeEnablement(onDidChangeGitBaseExtensionEnablement));
+	onDidChangeGitBaseExtensionEnablement(gitBaseExtension.enabled);
 
-	const gitExtension = extensions.getExtension<GitExtension>('vscode.git')!.exports;
-	context.subscriptions.push(gitExtension.onDidChangeEnablement(onDidChangeGitExtensionEnablement));
-	onDidChangeGitExtensionEnablement(gitExtension.enabled);
+	return combinedDisposable(disposables);
+}
+
+function initializeGitExtension(): Disposable {
+	const disposables = new Set<Disposable>();
+
+	let gitExtension = extensions.getExtension<GitExtension>('vscode.git');
+
+	const initialize = () => {
+		gitExtension!.activate()
+			.then(extension => {
+				const onDidChangeGitExtensionEnablement = (enabled: boolean) => {
+					if (enabled) {
+						const gitAPI = extension.getAPI(1);
+
+						disposables.add(registerCommands(gitAPI));
+						disposables.add(new GithubCredentialProviderManager(gitAPI));
+						disposables.add(gitAPI.registerPushErrorHandler(new GithubPushErrorHandler()));
+						disposables.add(gitAPI.registerRemoteSourcePublisher(new GithubRemoteSourcePublisher(gitAPI)));
+
+						commands.executeCommand('setContext', 'git-base.gitEnabled', true);
+					} else {
+						dispose(disposables);
+						disposables.clear();
+					}
+				};
+
+				disposables.add(extension.onDidChangeEnablement(onDidChangeGitExtensionEnablement));
+				onDidChangeGitExtensionEnablement(extension.enabled);
+			});
+	};
+
+	if (gitExtension) {
+		initialize();
+	} else {
+		const disposable = extensions.onDidChange(() => {
+			if (!gitExtension && extensions.getExtension<GitExtension>('vscode.git')) {
+				gitExtension = extensions.getExtension<GitExtension>('vscode.git');
+				initialize();
+
+				dispose(disposable);
+			}
+		});
+		disposables.add(disposable);
+	}
+
+	return combinedDisposable(disposables);
 }

extensions/github/src/remoteSourceProvider.ts

@@ -3,10 +3,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { API as GitAPI, RemoteSourceProvider, RemoteSource, Repository } from './typings/git';
+import { RemoteSourceProvider, RemoteSource } from './typings/git-base';
 import { getOctokit } from './auth';
 import { Octokit } from '@octokit/rest';
-import { publishRepository } from './publish';
 
 function parse(url: string): { owner: string, repo: string } | undefined {
 	const match = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\.git/i.exec(url)
@@ -30,8 +29,6 @@ export class GithubRemoteSourceProvider implements RemoteSourceProvider {
 
 	private userReposCache: RemoteSource[] = [];
 
-	constructor(private gitAPI: GitAPI) { }
-
 	async getRemoteSources(query?: string): Promise<RemoteSource[]> {
 		const octokit = await getOctokit();
 
@@ -108,8 +105,4 @@ export class GithubRemoteSourceProvider implements RemoteSourceProvider {
 
 		return branches.sort((a, b) => a === defaultBranch ? -1 : b === defaultBranch ? 1 : 0);
 	}
-
-	publishRepository(repository: Repository): Promise<void> {
-		return publishRepository(this.gitAPI, repository);
-	}
 }

extensions/github/src/remoteSourcePublisher.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { publishRepository } from './publish';
+import { API as GitAPI, RemoteSourcePublisher, Repository } from './typings/git';
+
+export class GithubRemoteSourcePublisher implements RemoteSourcePublisher {
+	readonly name = 'GitHub';
+	readonly icon = 'github';
+
+	constructor(private gitAPI: GitAPI) { }
+
+	publishRepository(repository: Repository): Promise<void> {
+		return publishRepository(this.gitAPI, repository);
+	}
+}

extensions/github/src/typings/git-base.d.ts

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, Event, ProviderResult, Uri } from 'vscode';
+export { ProviderResult } from 'vscode';
+
+export interface API {
+	registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable;
+	pickRemoteSource(options: PickRemoteSourceOptions): Promise<string | PickRemoteSourceResult | undefined>;
+}
+
+export interface GitBaseExtension {
+
+	readonly enabled: boolean;
+	readonly onDidChangeEnablement: Event<boolean>;
+
+	/**
+	 * Returns a specific API version.
+	 *
+	 * Throws error if git-base extension is disabled. You can listed to the
+	 * [GitBaseExtension.onDidChangeEnablement](#GitBaseExtension.onDidChangeEnablement)
+	 * event to know when the extension becomes enabled/disabled.
+	 *
+	 * @param version Version number.
+	 * @returns API instance
+	 */
+	getAPI(version: 1): API;
+}
+
+export interface PickRemoteSourceOptions {
+	readonly providerLabel?: (provider: RemoteSourceProvider) => string;
+	readonly urlLabel?: string;
+	readonly providerName?: string;
+	readonly branch?: boolean; // then result is PickRemoteSourceResult
+}
+
+export interface PickRemoteSourceResult {
+	readonly url: string;
+	readonly branch?: string;
+}
+
+export interface RemoteSource {
+	readonly name: string;
+	readonly description?: string;
+	readonly url: string | string[];
+}
+
+export interface RemoteSourceProvider {
+	readonly name: string;
+	/**
+	 * Codicon name
+	 */
+	readonly icon?: string;
+	readonly supportsQuery?: boolean;
+
+	getBranches?(url: string): ProviderResult<string[]>;
+	getRemoteSources(query?: string): ProviderResult<RemoteSource[]>;
+}

extensions/github/src/typings/git.d.ts

@@ -216,6 +216,12 @@ export interface RemoteSourceProvider {
 	publishRepository?(repository: Repository): Promise<void>;
 }
 
+export interface RemoteSourcePublisher {
+	readonly name: string;
+	readonly icon?: string; // codicon name
+	publishRepository(repository: Repository): Promise<void>;
+}
+
 export interface Credentials {
 	readonly username: string;
 	readonly password: string;
@@ -243,6 +249,7 @@ export interface API {
 	getRepository(uri: Uri): Repository | null;
 	init(root: Uri): Promise<Repository | null>;
 
+	registerRemoteSourcePublisher(publisher: RemoteSourcePublisher): Disposable;
 	registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable;
 	registerCredentialsProvider(provider: CredentialsProvider): Disposable;
 	registerPushErrorHandler(handler: PushErrorHandler): Disposable;