Merge branch 'master' into issue/88294

extensions/git/src/api/api1.ts

@@ -5,7 +5,7 @@
 
 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, LogOptions, APIState } from './git';
+import { InputBox, Git, API, Repository, Remote, RepositoryState, Branch, Ref, Submodule, Commit, Change, RepositoryUIState, Status, LogOptions, APIState, CommitOptions } from './git';
 import { Event, SourceControlInputBox, Uri, SourceControl } from 'vscode';
 import { mapEvent } from '../util';
 import { toGitUri } from '../uri';
@@ -202,6 +202,10 @@ export class ApiRepository implements Repository {
 	log(options?: LogOptions): Promise<Commit[]> {
 		return this._repository.log(options);
 	}
+
+	commit(message: string, opts?: CommitOptions): Promise<void> {
+		return this._repository.commit(message, opts);
+	}
 }
 
 export class ApiGit implements Git {

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

@@ -122,6 +122,14 @@ export interface LogOptions {
 	readonly maxEntries?: number;
 }
 
+export interface CommitOptions {
+	all?: boolean | 'tracked';
+	amend?: boolean;
+	signoff?: boolean;
+	signCommit?: boolean;
+	empty?: boolean;
+}
+
 export interface Repository {
 
 	readonly rootUri: Uri;
@@ -177,6 +185,8 @@ export interface Repository {
 
 	blame(path: string): Promise<string>;
 	log(options?: LogOptions): Promise<Commit[]>;
+
+	commit(message: string, opts?: CommitOptions): Promise<void>;
 }
 
 export type APIState = 'uninitialized' | 'initialized';

extensions/git/src/commands.ts

@@ -9,8 +9,8 @@ import * as path from 'path';
 import { commands, Disposable, LineChange, MessageOptions, OutputChannel, Position, ProgressLocation, QuickPickItem, Range, SourceControlResourceState, TextDocumentShowOptions, TextEditor, Uri, ViewColumn, window, workspace, WorkspaceEdit, WorkspaceFolder } from 'vscode';
 import TelemetryReporter from 'vscode-extension-telemetry';
 import * as nls from 'vscode-nls';
-import { Branch, GitErrorCodes, Ref, RefType, Status } from './api/git';
-import { CommitOptions, ForcePushMode, Git, Stash } from './git';
+import { Branch, GitErrorCodes, Ref, RefType, Status, CommitOptions } from './api/git';
+import { ForcePushMode, Git, Stash } from './git';
 import { Model } from './model';
 import { Repository, Resource, ResourceGroupType } from './repository';
 import { applyLineChanges, getModifiedRange, intersectDiffWithRange, invertLineChange, toLineRanges } from './staging';
@@ -1620,7 +1620,7 @@ export class CommandCenter {
 
 		const rawBranchName = defaultName || await window.showInputBox({
 			placeHolder: localize('branch name', "Branch name"),
-			prompt: localize('provide branch name', "Please provide a branch name"),
+			prompt: localize('provide branch name', "Please provide a new branch name"),
 			value: initialValue,
 			ignoreFocusOut: true,
 			validateInput: (name: string) => {
@@ -2332,14 +2332,20 @@ export class CommandCenter {
 	}
 
 	@command('git.openDiff', { repository: false })
-	async openDiff(uri: Uri, hash: string) {
+	async openDiff(uri: Uri, lhs: string, rhs: string) {
 		const basename = path.basename(uri.fsPath);
 
-		if (hash === '~') {
-			return commands.executeCommand('vscode.diff', toGitUri(uri, hash), toGitUri(uri, `HEAD`), `${basename} (Index)`);
+		let title;
+		if ((lhs === 'HEAD' || lhs === '~') && rhs === '') {
+			title = `${basename} (Working Tree)`;
+		}
+		else if (lhs === 'HEAD' && rhs === '~') {
+			title = `${basename} (Index)`;
+		} else {
+			title = `${basename} (${lhs.endsWith('^') ? `${lhs.substr(0, 8)}^` : lhs.substr(0, 8)}) \u27f7 ${basename} (${rhs.endsWith('^') ? `${rhs.substr(0, 8)}^` : rhs.substr(0, 8)})`;
 		}
 
-		return commands.executeCommand('vscode.diff', toGitUri(uri, `${hash}^`), toGitUri(uri, hash), `${basename} (${hash.substr(0, 8)}^) \u27f7 ${basename} (${hash.substr(0, 8)})`);
+		return commands.executeCommand('vscode.diff', toGitUri(uri, lhs), rhs === '' ? uri : toGitUri(uri, rhs), title);
 	}
 
 	private createCommand(id: string, key: string, method: Function, options: CommandOptions): (...args: any[]) => any {

extensions/git/src/git.ts

@@ -15,7 +15,7 @@ import { assign, groupBy, IDisposable, toDisposable, dispose, mkdirp, readBytes,
 import { CancellationToken, Progress, Uri } from 'vscode';
 import { URI } from 'vscode-uri';
 import { detectEncoding } from './encoding';
-import { Ref, RefType, Branch, Remote, GitErrorCodes, LogOptions, Change, Status } from './api/git';
+import { Ref, RefType, Branch, Remote, GitErrorCodes, LogOptions, Change, Status, CommitOptions } from './api/git';
 import * as byline from 'byline';
 import { StringDecoder } from 'string_decoder';
 
@@ -333,7 +333,7 @@ function sanitizePath(path: string): string {
 	return path.replace(/^([a-z]):\\/i, (_, letter) => `${letter.toUpperCase()}:\\`);
 }
 
-const COMMIT_FORMAT = '%H\n%aN\n%aE\n%at\n%ct\n%P\n%B';
+const COMMIT_FORMAT = '%H%n%aN%n%aE%n%at%n%ct%n%P%n%B';
 
 export class Git {
 
@@ -728,14 +728,6 @@ export function parseLsFiles(raw: string): LsFilesElement[] {
 		.map(([, mode, object, stage, file]) => ({ mode, object, stage, file }));
 }
 
-export interface CommitOptions {
-	all?: boolean | 'tracked';
-	amend?: boolean;
-	signoff?: boolean;
-	signCommit?: boolean;
-	empty?: boolean;
-}
-
 export interface PullOptions {
 	unshallow?: boolean;
 	tags?: boolean;
@@ -812,8 +804,8 @@ export class Repository {
 	}
 
 	async log(options?: LogOptions): Promise<Commit[]> {
-		const maxEntries = options && typeof options.maxEntries === 'number' && options.maxEntries > 0 ? options.maxEntries : 32;
-		const args = ['log', '-' + maxEntries, `--format:${COMMIT_FORMAT}`, '-z'];
+		const maxEntries = options?.maxEntries ?? 32;
+		const args = ['log', `-n${maxEntries}`, `--format=${COMMIT_FORMAT}`, '-z', '--'];
 
 		const result = await this.run(args);
 		if (result.exitCode) {
@@ -826,7 +818,7 @@ export class Repository {
 
 	async logFile(uri: Uri, options?: LogFileOptions): Promise<Commit[]> {
 		const maxEntries = options?.maxEntries ?? 32;
-		const args = ['log', `-${maxEntries}`, `--format=${COMMIT_FORMAT}`, '-z', '--', uri.fsPath];
+		const args = ['log', `-n${maxEntries}`, `--format=${COMMIT_FORMAT}`, '-z', '--', uri.fsPath];
 
 		const result = await this.run(args);
 		if (result.exitCode) {

extensions/git/src/repository.ts

@@ -7,10 +7,10 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { CancellationToken, Command, Disposable, Event, EventEmitter, Memento, OutputChannel, ProgressLocation, ProgressOptions, scm, SourceControl, SourceControlInputBox, SourceControlInputBoxValidation, SourceControlInputBoxValidationType, SourceControlResourceDecorations, SourceControlResourceGroup, SourceControlResourceState, ThemeColor, Uri, window, workspace, WorkspaceEdit, Decoration } from 'vscode';
 import * as nls from 'vscode-nls';
-import { Branch, Change, GitErrorCodes, LogOptions, Ref, RefType, Remote, Status } from './api/git';
+import { Branch, Change, GitErrorCodes, LogOptions, Ref, RefType, Remote, Status, CommitOptions } from './api/git';
 import { AutoFetcher } from './autofetch';
 import { debounce, memoize, throttle } from './decorators';
-import { Commit, CommitOptions, ForcePushMode, GitError, Repository as BaseRepository, Stash, Submodule, LogFileOptions } from './git';
+import { Commit, ForcePushMode, GitError, Repository as BaseRepository, Stash, Submodule, LogFileOptions } from './git';
 import { StatusBarCommands } from './statusbar';
 import { toGitUri } from './uri';
 import { anyEvent, combinedDisposable, debounceEvent, dispose, EmptyDisposable, eventToPromise, filterEvent, find, IDisposable, isDescendant, onceEvent } from './util';
@@ -309,11 +309,17 @@ export const enum Operation {
 
 function isReadOnly(operation: Operation): boolean {
 	switch (operation) {
-		case Operation.Show:
-		case Operation.GetCommitTemplate:
+		case Operation.Blame:
 		case Operation.CheckIgnore:
+		case Operation.Diff:
+		case Operation.FindTrackingBranches:
+		case Operation.GetBranch:
+		case Operation.GetCommitTemplate:
 		case Operation.GetObjectDetails:
+		case Operation.Log:
+		case Operation.LogFile:
 		case Operation.MergeBase:
+		case Operation.Show:
 			return true;
 		default:
 			return false;

extensions/git/src/test/git.test.ts

@@ -189,7 +189,9 @@ suite('git', () => {
 	suite('parseGitCommit', () => {
 		test('single parent commit', function () {
 			const GIT_OUTPUT_SINGLE_PARENT = `52c293a05038d865604c2284aa8698bd087915a1
+John Doe
 john.doe@mail.com
+1580811030
 8e5a374372b8393906c7e380dbb09349c5385554
 This is a commit message.\x00`;
 
@@ -197,13 +199,17 @@ This is a commit message.\x00`;
 				hash: '52c293a05038d865604c2284aa8698bd087915a1',
 				message: 'This is a commit message.',
 				parents: ['8e5a374372b8393906c7e380dbb09349c5385554'],
+				authorDate: new Date(1580811030000),
+				authorName: 'John Doe',
 				authorEmail: 'john.doe@mail.com',
 			}]);
 		});
 
 		test('multiple parent commits', function () {
 			const GIT_OUTPUT_MULTIPLE_PARENTS = `52c293a05038d865604c2284aa8698bd087915a1
+John Doe
 john.doe@mail.com
+1580811030
 8e5a374372b8393906c7e380dbb09349c5385554 df27d8c75b129ab9b178b386077da2822101b217
 This is a commit message.\x00`;
 
@@ -211,13 +217,17 @@ This is a commit message.\x00`;
 				hash: '52c293a05038d865604c2284aa8698bd087915a1',
 				message: 'This is a commit message.',
 				parents: ['8e5a374372b8393906c7e380dbb09349c5385554', 'df27d8c75b129ab9b178b386077da2822101b217'],
+				authorDate: new Date(1580811030000),
+				authorName: 'John Doe',
 				authorEmail: 'john.doe@mail.com',
 			}]);
 		});
 
 		test('no parent commits', function () {
 			const GIT_OUTPUT_NO_PARENTS = `52c293a05038d865604c2284aa8698bd087915a1
+John Doe
 john.doe@mail.com
+1580811030
 
 This is a commit message.\x00`;
 
@@ -225,6 +235,8 @@ This is a commit message.\x00`;
 				hash: '52c293a05038d865604c2284aa8698bd087915a1',
 				message: 'This is a commit message.',
 				parents: [],
+				authorDate: new Date(1580811030000),
+				authorName: 'John Doe',
 				authorEmail: 'john.doe@mail.com',
 			}]);
 		});

extensions/git/src/test/index.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const path = require('path');
+const testRunner = require('vscode/lib/testrunner');
+
+const suite = 'Integration Git Tests';
+
+const options: any = {
+	ui: 'tdd',
+	useColors: (!process.env.BUILD_ARTIFACTSTAGINGDIRECTORY && process.platform !== 'win32'),
+	timeout: 60000
+};
+
+if (process.env.BUILD_ARTIFACTSTAGINGDIRECTORY) {
+	options.reporter = 'mocha-multi-reporters';
+	options.reporterOptions = {
+		reporterEnabled: 'spec, mocha-junit-reporter',
+		mochaJunitReporterReporterOptions: {
+			testsuitesTitle: `${suite} ${process.platform}`,
+			mochaFile: path.join(process.env.BUILD_ARTIFACTSTAGINGDIRECTORY, `test-results/${process.platform}-${suite.toLowerCase().replace(/[^\w]/g, '-')}-results.xml`)
+		}
+	};
+}
+
+testRunner.configure(options);
+
+export = testRunner;

extensions/git/src/test/smoke.test.ts

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import 'mocha';
+import * as assert from 'assert';
+import { workspace, commands, window, Uri, WorkspaceEdit, Range, TextDocument, extensions } from 'vscode';
+import * as cp from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { GitExtension, API, Repository, Status } from '../api/git';
+import { eventToPromise } from '../util';
+
+suite('git smoke test', function () {
+	const cwd = fs.realpathSync(workspace.workspaceFolders![0].uri.fsPath);
+
+	function file(relativePath: string) {
+		return path.join(cwd, relativePath);
+	}
+
+	function uri(relativePath: string) {
+		return Uri.file(file(relativePath));
+	}
+
+	async function open(relativePath: string) {
+		const doc = await workspace.openTextDocument(uri(relativePath));
+		await window.showTextDocument(doc);
+		return doc;
+	}
+
+	async function type(doc: TextDocument, text: string) {
+		const edit = new WorkspaceEdit();
+		const end = doc.lineAt(doc.lineCount - 1).range.end;
+		edit.replace(doc.uri, new Range(end, end), text);
+		await workspace.applyEdit(edit);
+	}
+
+	let git: API;
+	let repository: Repository;
+
+	suiteSetup(async function () {
+		fs.writeFileSync(file('app.js'), 'hello', 'utf8');
+		fs.writeFileSync(file('index.pug'), 'hello', 'utf8');
+		cp.execSync('git init', { cwd });
+		cp.execSync('git config user.name testuser', { cwd });
+		cp.execSync('git config user.email monacotools@microsoft.com', { cwd });
+		cp.execSync('git add .', { cwd });
+		cp.execSync('git commit -m "initial commit"', { cwd });
+
+		// make sure git is activated
+		const ext = extensions.getExtension<GitExtension>('vscode.git');
+		await ext?.activate();
+		git = ext!.exports.getAPI(1);
+
+		if (git.repositories.length === 0) {
+			await eventToPromise(git.onDidOpenRepository);
+		}
+
+		assert.equal(git.repositories.length, 1);
+		assert.equal(fs.realpathSync(git.repositories[0].rootUri.fsPath), cwd);
+
+		repository = git.repositories[0];
+	});
+
+	test('reflects working tree changes', async function () {
+		await commands.executeCommand('workbench.view.scm');
+
+		const appjs = await open('app.js');
+		await type(appjs, ' world');
+		await appjs.save();
+		await repository.status();
+		assert.equal(repository.state.workingTreeChanges.length, 1);
+		repository.state.workingTreeChanges.some(r => r.uri.path === appjs.uri.path && r.status === Status.MODIFIED);
+
+		fs.writeFileSync(file('newfile.txt'), '');
+		const newfile = await open('newfile.txt');
+		await type(newfile, 'hey there');
+		await newfile.save();
+		await repository.status();
+		assert.equal(repository.state.workingTreeChanges.length, 2);
+		repository.state.workingTreeChanges.some(r => r.uri.path === appjs.uri.path && r.status === Status.MODIFIED);
+		repository.state.workingTreeChanges.some(r => r.uri.path === newfile.uri.path && r.status === Status.UNTRACKED);
+	});
+
+	test('opens diff editor', async function () {
+		const appjs = uri('app.js');
+		await commands.executeCommand('git.openChange', appjs);
+
+		assert(window.activeTextEditor);
+		assert.equal(window.activeTextEditor!.document.uri.path, appjs.path);
+
+		// TODO: how do we really know this is a diff editor?
+	});
+
+	test('stages correctly', async function () {
+		const appjs = uri('app.js');
+		const newfile = uri('newfile.txt');
+
+		await commands.executeCommand('git.stage', appjs);
+		assert.equal(repository.state.workingTreeChanges.length, 1);
+		repository.state.workingTreeChanges.some(r => r.uri.path === newfile.path && r.status === Status.UNTRACKED);
+		assert.equal(repository.state.indexChanges.length, 1);
+		repository.state.indexChanges.some(r => r.uri.path === appjs.path && r.status === Status.INDEX_MODIFIED);
+
+		await commands.executeCommand('git.unstage', appjs);
+		assert.equal(repository.state.workingTreeChanges.length, 2);
+		repository.state.workingTreeChanges.some(r => r.uri.path === appjs.path && r.status === Status.MODIFIED);
+		repository.state.workingTreeChanges.some(r => r.uri.path === newfile.path && r.status === Status.UNTRACKED);
+	});
+
+	test('stages, commits changes and verifies outgoing change', async function () {
+		const appjs = uri('app.js');
+		const newfile = uri('newfile.txt');
+
+		await commands.executeCommand('git.stage', appjs);
+		await repository.commit('second commit');
+		assert.equal(repository.state.workingTreeChanges.length, 1);
+		repository.state.workingTreeChanges.some(r => r.uri.path === newfile.path && r.status === Status.UNTRACKED);
+		assert.equal(repository.state.indexChanges.length, 0);
+
+		await commands.executeCommand('git.stageAll', appjs);
+		await repository.commit('third commit');
+		assert.equal(repository.state.workingTreeChanges.length, 0);
+		assert.equal(repository.state.indexChanges.length, 0);
+	});
+});

extensions/git/src/timelineProvider.ts

@@ -6,7 +6,7 @@
 import * as dayjs from 'dayjs';
 import * as advancedFormat from 'dayjs/plugin/advancedFormat';
 import * as relativeTime from 'dayjs/plugin/relativeTime';
-import { CancellationToken, Disposable, Event, EventEmitter, ThemeIcon, TimelineItem, TimelineProvider, Uri, workspace } from 'vscode';
+import { CancellationToken, Disposable, Event, EventEmitter, ThemeIcon, TimelineItem, TimelineProvider, Uri, workspace, TimelineChangeEvent } from 'vscode';
 import { Model } from './model';
 import { Repository } from './repository';
 import { debounce } from './decorators';
@@ -19,13 +19,13 @@ dayjs.extend(relativeTime);
 // TODO[ECA]: Localize or use a setting for date format
 
 export class GitTimelineProvider implements TimelineProvider {
-	private _onDidChange = new EventEmitter<Uri | undefined>();
-	get onDidChange(): Event<Uri | undefined> {
+	private _onDidChange = new EventEmitter<TimelineChangeEvent>();
+	get onDidChange(): Event<TimelineChangeEvent> {
 		return this._onDidChange.event;
 	}
 
-	readonly source = 'git-history';
-	readonly sourceDescription = 'Git History';
+	readonly id = 'git-history';
+	readonly label = 'Git History';
 
 	private _disposable: Disposable;
 
@@ -62,8 +62,8 @@ export class GitTimelineProvider implements TimelineProvider {
 			this._repo = repo;
 			this._repoStatusDate = new Date();
 			this._repoDisposable = Disposable.from(
-				repo.onDidChangeRepository(this.onRepositoryChanged, this),
-				repo.onDidRunGitStatus(this.onRepositoryStatusChanged, this)
+				repo.onDidChangeRepository(uri => this.onRepositoryChanged(repo, uri)),
+				repo.onDidRunGitStatus(() => this.onRepositoryStatusChanged(repo))
 			);
 		}
 
@@ -82,19 +82,18 @@ export class GitTimelineProvider implements TimelineProvider {
 
 			dateFormatter = dayjs(c.authorDate);
 
-			return {
-				id: c.hash,
-				timestamp: c.authorDate?.getTime() ?? 0,
-				iconPath: new ThemeIcon('git-commit'),
-				label: message,
-				description: `${dateFormatter.fromNow()}  \u2022  ${c.authorName}`,
-				detail: `${c.authorName} (${c.authorEmail}) \u2014 ${c.hash.substr(0, 8)}\n${dateFormatter.fromNow()} (${dateFormatter.format('MMMM Do, YYYY h:mma')})\n\n${c.message}`,
-				command: {
-					title: 'Open Diff',
-					command: 'git.openDiff',
-					arguments: [uri, c.hash]
-				}
+			const item = new TimelineItem(message, c.authorDate?.getTime() ?? 0);
+			item.id = c.hash;
+			item.iconPath = new (ThemeIcon as any)('git-commit');
+			item.description = `${dateFormatter.fromNow()}  \u2022  ${c.authorName}`;
+			item.detail = `${c.authorName} (${c.authorEmail}) \u2014 ${c.hash.substr(0, 8)}\n${dateFormatter.fromNow()} (${dateFormatter.format('MMMM Do, YYYY h:mma')})\n\n${c.message}`;
+			item.command = {
+				title: 'Open Diff',
+				command: 'git.openDiff',
+				arguments: [uri, `${c.hash}^`, c.hash]
 			};
+
+			return item;
 		});
 
 		const index = repo.indexGroup.resourceStates.find(r => r.resourceUri.fsPath === uri.fsPath);
@@ -124,43 +123,91 @@ export class GitTimelineProvider implements TimelineProvider {
 					break;
 			}
 
+			const item = new TimelineItem('Staged Changes', date.getTime());
+			item.id = 'index';
+			// TODO[ECA]: Replace with a better icon -- reflecting its status maybe?
+			item.iconPath = new (ThemeIcon as any)('git-commit');
+			item.description = `${dateFormatter.fromNow()}  \u2022  You`;
+			item.detail = `You  \u2014 Index\n${dateFormatter.fromNow()} (${dateFormatter.format('MMMM Do, YYYY h:mma')})\n${status}`;
+			item.command = {
+				title: 'Open Comparison',
+				command: 'git.openDiff',
+				arguments: [uri, 'HEAD', '~']
+			};
 
-			items.push({
-				id: '~',
-				timestamp: date.getTime(),
-				// TODO[ECA]: Replace with a better icon -- reflecting its status maybe?
-				iconPath: new ThemeIcon('git-commit'),
-				label: 'Staged Changes',
-				description: `${dateFormatter.fromNow()}  \u2022  You`,
-				detail: `You  \u2014 Index\n${dateFormatter.fromNow()} (${dateFormatter.format('MMMM Do, YYYY h:mma')})\n${status}`,
-				command: {
-					title: 'Open Comparison',
-					command: 'git.openDiff',
-					arguments: [uri, '~']
-				}
-			});
+			items.push(item);
+		}
+
+
+		const working = repo.workingTreeGroup.resourceStates.find(r => r.resourceUri.fsPath === uri.fsPath);
+		if (working) {
+			const date = new Date();
+			dateFormatter = dayjs(date);
+
+			let status;
+			switch (working.type) {
+				case Status.INDEX_MODIFIED:
+					status = 'Modified';
+					break;
+				case Status.INDEX_ADDED:
+					status = 'Added';
+					break;
+				case Status.INDEX_DELETED:
+					status = 'Deleted';
+					break;
+				case Status.INDEX_RENAMED:
+					status = 'Renamed';
+					break;
+				case Status.INDEX_COPIED:
+					status = 'Copied';
+					break;
+				default:
+					status = '';
+					break;
+			}
+
+			const item = new TimelineItem('Uncommited Changes', date.getTime());
+			item.id = 'working';
+			// TODO[ECA]: Replace with a better icon -- reflecting its status maybe?
+			item.iconPath = new (ThemeIcon as any)('git-commit');
+			item.description = `${dateFormatter.fromNow()}  \u2022  You`;
+			item.detail = `You  \u2014 Working Tree\n${dateFormatter.fromNow()} (${dateFormatter.format('MMMM Do, YYYY h:mma')})\n${status}`;
+			item.command = {
+				title: 'Open Comparison',
+				command: 'git.openDiff',
+				arguments: [uri, index ? '~' : 'HEAD', '']
+			};
+
+			items.push(item);
 		}
 
 		return items;
 	}
 
-	@debounce(500)
 	private onRepositoriesChanged(_repo: Repository) {
 		// console.log(`GitTimelineProvider.onRepositoriesChanged`);
 
 		// TODO[ECA]: Being naive for now and just always refreshing each time there is a new repository
-		this._onDidChange.fire();
+		this.fireChanged();
+	}
+
+	private onRepositoryChanged(_repo: Repository, _uri: Uri) {
+		// console.log(`GitTimelineProvider.onRepositoryChanged: uri=${uri.toString(true)}`);
+
+		this.fireChanged();
+	}
+
+	private onRepositoryStatusChanged(_repo: Repository) {
+		// console.log(`GitTimelineProvider.onRepositoryStatusChanged`);
+
+		// This is crappy, but for now just save the last time a status was run and use that as the timestamp for staged items
+		this._repoStatusDate = new Date();
+
+		this.fireChanged();
 	}
 
 	@debounce(500)
-	private onRepositoryChanged() {
-		// console.log(`GitTimelineProvider.onRepositoryChanged`);
-
+	private fireChanged() {
 		this._onDidChange.fire();
 	}
-
-	private onRepositoryStatusChanged() {
-		// This is crappy, but for now just save the last time a status was run and use that as the timestamp for staged items
-		this._repoStatusDate = new Date();
-	}
 }

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

@@ -4,4 +4,5 @@
  *--------------------------------------------------------------------------------------------*/
 
 /// <reference path='../../../../src/vs/vscode.d.ts'/>
-/// <reference path='../../../../src/vs/vscode.proposed.d.ts'/>
+/// <reference path='../../../../src/vs/vscode.proposed.d.ts'/>
+/// <reference path="../../../types/lib.textEncoder.d.ts" />

extensions/git/src/util.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Event } from 'vscode';
+import { Event, Disposable } from 'vscode';
 import { dirname, sep } from 'path';
 import { Readable } from 'stream';
 import { promises as fs, createReadStream } from 'fs';
@@ -33,15 +33,15 @@ export function combinedDisposable(disposables: IDisposable[]): IDisposable {
 export const EmptyDisposable = toDisposable(() => null);
 
 export function fireEvent<T>(event: Event<T>): Event<T> {
-	return (listener, thisArgs = null, disposables?) => event(_ => (listener as any).call(thisArgs), null, disposables);
+	return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => event(_ => (listener as any).call(thisArgs), null, disposables);
 }
 
 export function mapEvent<I, O>(event: Event<I>, map: (i: I) => O): Event<O> {
-	return (listener, thisArgs = null, disposables?) => event(i => listener.call(thisArgs, map(i)), null, disposables);
+	return (listener: (e: O) => any, thisArgs?: any, disposables?: Disposable[]) => event(i => listener.call(thisArgs, map(i)), null, disposables);
 }
 
 export function filterEvent<T>(event: Event<T>, filter: (e: T) => boolean): Event<T> {
-	return (listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
+	return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
 }
 
 export function latchEvent<T>(event: Event<T>): Event<T> {
@@ -57,7 +57,7 @@ export function latchEvent<T>(event: Event<T>): Event<T> {
 }
 
 export function anyEvent<T>(...events: Event<T>[]): Event<T> {
-	return (listener, thisArgs = null, disposables?) => {
+	return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
 		const result = combinedDisposable(events.map(event => event(i => listener.call(thisArgs, i))));
 
 		if (disposables) {
@@ -73,7 +73,7 @@ export function done<T>(promise: Promise<T>): Promise<void> {
 }
 
 export function onceEvent<T>(event: Event<T>): Event<T> {
-	return (listener, thisArgs = null, disposables?) => {
+	return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
 		const result = event(e => {
 			result.dispose();
 			return listener.call(thisArgs, e);
@@ -84,7 +84,7 @@ export function onceEvent<T>(event: Event<T>): Event<T> {
 }
 
 export function debounceEvent<T>(event: Event<T>, delay: number): Event<T> {
-	return (listener, thisArgs = null, disposables?) => {
+	return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
 		let timer: NodeJS.Timer;
 		return event(e => {
 			clearTimeout(timer);