Merge from master

extensions/git/src/api/api1.ts

@@ -0,0 +1,208 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Model } from '../model';
+import { Repository as BaseRepository, Resource } from '../repository';
+import { InputBox, Git, API, Repository, Remote, RepositoryState, Branch, Ref, Submodule, Commit, Change, RepositoryUIState, Status } from './git';
+import { Event, SourceControlInputBox, Uri, SourceControl } from 'vscode';
+import { mapEvent } from '../util';
+
+class ApiInputBox implements InputBox {
+	set value(value: string) { this._inputBox.value = value; }
+	get value(): string { return this._inputBox.value; }
+	constructor(private _inputBox: SourceControlInputBox) { }
+}
+
+export class ApiChange implements Change {
+
+	get uri(): Uri { return this.resource.resourceUri; }
+	get originalUri(): Uri { return this.resource.original; }
+	get renameUri(): Uri | undefined { return this.resource.renameResourceUri; }
+	get status(): Status { return this.resource.type; }
+
+	constructor(private readonly resource: Resource) { }
+}
+
+export class ApiRepositoryState implements RepositoryState {
+
+	get HEAD(): Branch | undefined { return this._repository.HEAD; }
+	get refs(): Ref[] { return [...this._repository.refs]; }
+	get remotes(): Remote[] { return [...this._repository.remotes]; }
+	get submodules(): Submodule[] { return [...this._repository.submodules]; }
+	get rebaseCommit(): Commit | undefined { return this._repository.rebaseCommit; }
+
+	get mergeChanges(): Change[] { return this._repository.mergeGroup.resourceStates.map(r => new ApiChange(r)); }
+	get indexChanges(): Change[] { return this._repository.indexGroup.resourceStates.map(r => new ApiChange(r)); }
+	get workingTreeChanges(): Change[] { return this._repository.workingTreeGroup.resourceStates.map(r => new ApiChange(r)); }
+
+	readonly onDidChange: Event<void> = this._repository.onDidRunGitStatus;
+
+	constructor(private _repository: BaseRepository) { }
+}
+
+export class ApiRepositoryUIState implements RepositoryUIState {
+
+	get selected(): boolean { return this._sourceControl.selected; }
+
+	readonly onDidChange: Event<void> = mapEvent<boolean, void>(this._sourceControl.onDidChangeSelection, () => null);
+
+	constructor(private _sourceControl: SourceControl) { }
+}
+
+export class ApiRepository implements Repository {
+
+	readonly rootUri: Uri = Uri.file(this._repository.root);
+	readonly inputBox: InputBox = new ApiInputBox(this._repository.inputBox);
+	readonly state: RepositoryState = new ApiRepositoryState(this._repository);
+	readonly ui: RepositoryUIState = new ApiRepositoryUIState(this._repository.sourceControl);
+
+	constructor(private _repository: BaseRepository) { }
+
+	apply(patch: string, reverse?: boolean): Promise<void> {
+		return this._repository.apply(patch, reverse);
+	}
+
+	getConfigs(): Promise<{ key: string; value: string; }[]> {
+		return this._repository.getConfigs();
+	}
+
+	getConfig(key: string): Promise<string> {
+		return this._repository.getConfig(key);
+	}
+
+	setConfig(key: string, value: string): Promise<string> {
+		return this._repository.setConfig(key, value);
+	}
+
+	getObjectDetails(treeish: string, path: string): Promise<{ mode: string; object: string; size: number; }> {
+		return this._repository.getObjectDetails(treeish, path);
+	}
+
+	detectObjectType(object: string): Promise<{ mimetype: string, encoding?: string }> {
+		return this._repository.detectObjectType(object);
+	}
+
+	buffer(ref: string, filePath: string): Promise<Buffer> {
+		return this._repository.buffer(ref, filePath);
+	}
+
+	show(ref: string, path: string): Promise<string> {
+		return this._repository.show(ref, path);
+	}
+
+	getCommit(ref: string): Promise<Commit> {
+		return this._repository.getCommit(ref);
+	}
+
+	clean(paths: string[]) {
+		return this._repository.clean(paths.map(p => Uri.file(p)));
+	}
+
+	diff(cached?: boolean) {
+		return this._repository.diff(cached);
+	}
+
+	diffWithHEAD(path: string): Promise<string> {
+		return this._repository.diffWithHEAD(path);
+	}
+
+	diffWith(ref: string, path: string): Promise<string> {
+		return this._repository.diffWith(ref, path);
+	}
+
+	diffIndexWithHEAD(path: string): Promise<string> {
+		return this._repository.diffIndexWithHEAD(path);
+	}
+
+	diffIndexWith(ref: string, path: string): Promise<string> {
+		return this._repository.diffIndexWith(ref, path);
+	}
+
+	diffBlobs(object1: string, object2: string): Promise<string> {
+		return this._repository.diffBlobs(object1, object2);
+	}
+
+	diffBetween(ref1: string, ref2: string, path: string): Promise<string> {
+		return this._repository.diffBetween(ref1, ref2, path);
+	}
+
+	hashObject(data: string): Promise<string> {
+		return this._repository.hashObject(data);
+	}
+
+	createBranch(name: string, checkout: boolean, ref?: string | undefined): Promise<void> {
+		return this._repository.branch(name, checkout, ref);
+	}
+
+	deleteBranch(name: string, force?: boolean): Promise<void> {
+		return this._repository.deleteBranch(name, force);
+	}
+
+	getBranch(name: string): Promise<Branch> {
+		return this._repository.getBranch(name);
+	}
+
+	setBranchUpstream(name: string, upstream: string): Promise<void> {
+		return this._repository.setBranchUpstream(name, upstream);
+	}
+
+	getMergeBase(ref1: string, ref2: string): Promise<string> {
+		return this._repository.getMergeBase(ref1, ref2);
+	}
+
+	status(): Promise<void> {
+		return this._repository.status();
+	}
+
+	checkout(treeish: string): Promise<void> {
+		return this._repository.checkout(treeish);
+	}
+
+	addRemote(name: string, url: string): Promise<void> {
+		return this._repository.addRemote(name, url);
+	}
+
+	removeRemote(name: string): Promise<void> {
+		return this._repository.removeRemote(name);
+	}
+
+	fetch(remote?: string | undefined, ref?: string | undefined): Promise<void> {
+		return this._repository.fetch(remote, ref);
+	}
+
+	pull(): Promise<void> {
+		return this._repository.pull();
+	}
+
+	push(remoteName?: string, branchName?: string, setUpstream: boolean = false): Promise<void> {
+		return this._repository.pushTo(remoteName, branchName, setUpstream);
+	}
+}
+
+export class ApiGit implements Git {
+
+	get path(): string { return this._model.git.path; }
+
+	constructor(private _model: Model) { }
+}
+
+export class ApiImpl implements API {
+
+	readonly git = new ApiGit(this._model);
+
+	get onDidOpenRepository(): Event<Repository> {
+		return mapEvent(this._model.onDidOpenRepository, r => new ApiRepository(r));
+	}
+
+	get onDidCloseRepository(): Event<Repository> {
+		return mapEvent(this._model.onDidCloseRepository, r => new ApiRepository(r));
+	}
+
+	get repositories(): Repository[] {
+		return this._model.repositories.map(r => new ApiRepository(r));
+	}
+
+	constructor(private _model: Model) { }
+}

extensions/git/src/api/extension.ts

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Model } from '../model';
+import { GitExtension, Repository, API } from './git';
+import { ApiRepository, ApiImpl } from './api1';
+import { Event, EventEmitter } from 'vscode';
+import { latchEvent } from '../util';
+
+export function deprecated(_target: any, key: string, descriptor: any): void {
+	if (typeof descriptor.value !== 'function') {
+		throw new Error('not supported');
+	}
+
+	const fn = descriptor.value;
+	descriptor.value = function () {
+		console.warn(`Git extension API method '${key}' is deprecated.`);
+		return fn.apply(this, arguments);
+	};
+}
+
+export class GitExtensionImpl implements GitExtension {
+
+	enabled: boolean = false;
+
+	private _onDidChangeEnablement = new EventEmitter<boolean>();
+	readonly onDidChangeEnablement: Event<boolean> = latchEvent(this._onDidChangeEnablement.event);
+
+	private _model: Model | undefined = undefined;
+
+	set model(model: Model | undefined) {
+		this._model = model;
+
+		this.enabled = !!model;
+		this._onDidChangeEnablement.fire(this.enabled);
+	}
+
+	constructor(model?: Model) {
+		if (model) {
+			this.enabled = true;
+			this._model = model;
+		}
+	}
+
+	@deprecated
+	async getGitPath(): Promise<string> {
+		if (!this._model) {
+			throw new Error('Git model not found');
+		}
+
+		return this._model.git.path;
+	}
+
+	@deprecated
+	async getRepositories(): Promise<Repository[]> {
+		if (!this._model) {
+			throw new Error('Git model not found');
+		}
+
+		return this._model.repositories.map(repository => new ApiRepository(repository));
+	}
+
+	getAPI(version: number): API {
+		if (!this._model) {
+			throw new Error('Git model not found');
+		}
+
+		if (version !== 1) {
+			throw new Error(`No API version ${version} found.`);
+		}
+
+		return new ApiImpl(this._model);
+	}
+}

extensions/git/src/api/git.d.ts

@@ -0,0 +1,217 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Uri, SourceControlInputBox, Event, CancellationToken } from 'vscode';
+
+export interface Git {
+	readonly path: string;
+}
+
+export interface InputBox {
+	value: string;
+}
+
+export const enum RefType {
+	Head,
+	RemoteHead,
+	Tag
+}
+
+export interface Ref {
+	readonly type: RefType;
+	readonly name?: string;
+	readonly commit?: string;
+	readonly remote?: string;
+}
+
+export interface UpstreamRef {
+	readonly remote: string;
+	readonly name: string;
+}
+
+export interface Branch extends Ref {
+	readonly upstream?: UpstreamRef;
+	readonly ahead?: number;
+	readonly behind?: number;
+}
+
+export interface Commit {
+	readonly hash: string;
+	readonly message: string;
+	readonly parents: string[];
+}
+
+export interface Submodule {
+	readonly name: string;
+	readonly path: string;
+	readonly url: string;
+}
+
+export interface Remote {
+	readonly name: string;
+	readonly fetchUrl?: string;
+	readonly pushUrl?: string;
+	readonly isReadOnly: boolean;
+}
+
+export const enum Status {
+	INDEX_MODIFIED,
+	INDEX_ADDED,
+	INDEX_DELETED,
+	INDEX_RENAMED,
+	INDEX_COPIED,
+
+	MODIFIED,
+	DELETED,
+	UNTRACKED,
+	IGNORED,
+
+	ADDED_BY_US,
+	ADDED_BY_THEM,
+	DELETED_BY_US,
+	DELETED_BY_THEM,
+	BOTH_ADDED,
+	BOTH_DELETED,
+	BOTH_MODIFIED
+}
+
+export interface Change {
+
+	/**
+	 * Returns either `originalUri` or `renameUri`, depending
+	 * on whether this change is a rename change. When
+	 * in doubt always use `uri` over the other two alternatives.
+	 */
+	readonly uri: Uri;
+	readonly originalUri: Uri;
+	readonly renameUri: Uri | undefined;
+	readonly status: Status;
+}
+
+export interface RepositoryState {
+	readonly HEAD: Branch | undefined;
+	readonly refs: Ref[];
+	readonly remotes: Remote[];
+	readonly submodules: Submodule[];
+	readonly rebaseCommit: Commit | undefined;
+
+	readonly mergeChanges: Change[];
+	readonly indexChanges: Change[];
+	readonly workingTreeChanges: Change[];
+
+	readonly onDidChange: Event<void>;
+}
+
+export interface RepositoryUIState {
+	readonly selected: boolean;
+	readonly onDidChange: Event<void>;
+}
+
+export interface Repository {
+
+	readonly rootUri: Uri;
+	readonly inputBox: InputBox;
+	readonly state: RepositoryState;
+	readonly ui: RepositoryUIState;
+
+	getConfigs(): Promise<{ key: string; value: string; }[]>;
+	getConfig(key: string): Promise<string>;
+	setConfig(key: string, value: string): Promise<string>;
+
+	getObjectDetails(treeish: string, path: string): Promise<{ mode: string, object: string, size: number }>;
+	detectObjectType(object: string): Promise<{ mimetype: string, encoding?: string }>;
+	buffer(ref: string, path: string): Promise<Buffer>;
+	show(ref: string, path: string): Promise<string>;
+	getCommit(ref: string): Promise<Commit>;
+
+	clean(paths: string[]): Promise<void>;
+
+	apply(patch: string, reverse?: boolean): Promise<void>;
+	diff(cached?: boolean): Promise<string>;
+	diffWithHEAD(path: string): Promise<string>;
+	diffWith(ref: string, path: string): Promise<string>;
+	diffIndexWithHEAD(path: string): Promise<string>;
+	diffIndexWith(ref: string, path: string): Promise<string>;
+	diffBlobs(object1: string, object2: string): Promise<string>;
+	diffBetween(ref1: string, ref2: string, path: string): Promise<string>;
+
+	hashObject(data: string): Promise<string>;
+
+	createBranch(name: string, checkout: boolean, ref?: string): Promise<void>;
+	deleteBranch(name: string, force?: boolean): Promise<void>;
+	getBranch(name: string): Promise<Branch>;
+	setBranchUpstream(name: string, upstream: string): Promise<void>;
+
+	getMergeBase(ref1: string, ref2: string): Promise<string>;
+
+	status(): Promise<void>;
+	checkout(treeish: string): Promise<void>;
+
+	addRemote(name: string, url: string): Promise<void>;
+	removeRemote(name: string): Promise<void>;
+
+	fetch(remote?: string, ref?: string): Promise<void>;
+	pull(): Promise<void>;
+	push(remoteName?: string, branchName?: string, setUpstream?: boolean): Promise<void>;
+}
+
+export interface API {
+	readonly git: Git;
+	readonly repositories: Repository[];
+	readonly onDidOpenRepository: Event<Repository>;
+	readonly onDidCloseRepository: Event<Repository>;
+}
+
+export interface GitExtension {
+
+	readonly enabled: boolean;
+	readonly onDidChangeEnablement: Event<boolean>;
+
+	/**
+	 * Returns a specific API version.
+	 *
+	 * Throws error if git extension is disabled. You can listed to the
+	 * [GitExtension.onDidChangeEnablement](#GitExtension.onDidChangeEnablement) event
+	 * to know when the extension becomes enabled/disabled.
+	 *
+	 * @param version Version number.
+	 * @returns API instance
+	 */
+	getAPI(version: 1): API;
+}
+
+export const enum GitErrorCodes {
+	BadConfigFile = 'BadConfigFile',
+	AuthenticationFailed = 'AuthenticationFailed',
+	NoUserNameConfigured = 'NoUserNameConfigured',
+	NoUserEmailConfigured = 'NoUserEmailConfigured',
+	NoRemoteRepositorySpecified = 'NoRemoteRepositorySpecified',
+	NotAGitRepository = 'NotAGitRepository',
+	NotAtRepositoryRoot = 'NotAtRepositoryRoot',
+	Conflict = 'Conflict',
+	StashConflict = 'StashConflict',
+	UnmergedChanges = 'UnmergedChanges',
+	PushRejected = 'PushRejected',
+	RemoteConnectionError = 'RemoteConnectionError',
+	DirtyWorkTree = 'DirtyWorkTree',
+	CantOpenResource = 'CantOpenResource',
+	GitNotFound = 'GitNotFound',
+	CantCreatePipe = 'CantCreatePipe',
+	CantAccessRemote = 'CantAccessRemote',
+	RepositoryNotFound = 'RepositoryNotFound',
+	RepositoryIsLocked = 'RepositoryIsLocked',
+	BranchNotFullyMerged = 'BranchNotFullyMerged',
+	NoRemoteReference = 'NoRemoteReference',
+	InvalidBranchName = 'InvalidBranchName',
+	BranchAlreadyExists = 'BranchAlreadyExists',
+	NoLocalChanges = 'NoLocalChanges',
+	NoStashFound = 'NoStashFound',
+	LocalChangesOverwritten = 'LocalChangesOverwritten',
+	NoUpstreamBranch = 'NoUpstreamBranch',
+	IsInSubmodule = 'IsInSubmodule',
+	WrongCase = 'WrongCase',
+	CantLockRef = 'CantLockRef',
+	CantRebaseMultipleBranches = 'CantRebaseMultipleBranches',
+}