Merge branch 'joao/git-fs-provider'

extensions/git/src/api/api1.ts

@@ -8,6 +8,7 @@ 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 { Event, SourceControlInputBox, Uri, SourceControl } from 'vscode';
 import { mapEvent } from '../util';
+import { toGitUri } from '../uri';
 
 class ApiInputBox implements InputBox {
 	set value(value: string) { this._inputBox.value = value; }
@@ -234,5 +235,9 @@ export class ApiImpl implements API {
 		return this._model.repositories.map(r => new ApiRepository(r));
 	}
 
+	toGitUri(uri: Uri, ref: string): Uri {
+		return toGitUri(uri, ref);
+	}
+
 	constructor(private _model: Model) { }
 }

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

@@ -185,6 +185,8 @@ export interface API {
 	readonly repositories: Repository[];
 	readonly onDidOpenRepository: Event<Repository>;
 	readonly onDidCloseRepository: Event<Repository>;
+
+	toGitUri(uri: Uri, ref: string): Uri;
 }
 
 export interface GitExtension {

extensions/git/src/contentProvider.ts

@@ -147,4 +147,4 @@ export class GitContentProvider {
 	dispose(): void {
 		this.disposables.forEach(d => d.dispose());
 	}
-}
\ No newline at end of file
+}

extensions/git/src/fileSystemProvider.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { workspace, Uri, Disposable, Event, EventEmitter, window, FileSystemProvider, FileChangeEvent, FileStat, FileType, FileChangeType, FileSystemError } from 'vscode';
+import { debounce, throttle } from './decorators';
+import { fromGitUri, toGitUri } from './uri';
+import { Model, ModelChangeEvent, OriginalResourceChangeEvent } from './model';
+import { filterEvent, eventToPromise, isDescendant, pathEquals, EmptyDisposable } from './util';
+
+interface CacheRow {
+	uri: Uri;
+	timestamp: number;
+}
+
+const THREE_MINUTES = 1000 * 60 * 3;
+const FIVE_MINUTES = 1000 * 60 * 5;
+
+export class GitFileSystemProvider implements FileSystemProvider {
+
+	private _onDidChangeFile = new EventEmitter<FileChangeEvent[]>();
+	readonly onDidChangeFile: Event<FileChangeEvent[]> = this._onDidChangeFile.event;
+
+	private changedRepositoryRoots = new Set<string>();
+	private cache = new Map<string, CacheRow>();
+	private mtime = new Date().getTime();
+	private disposables: Disposable[] = [];
+
+	constructor(private model: Model) {
+		this.disposables.push(
+			model.onDidChangeRepository(this.onDidChangeRepository, this),
+			model.onDidChangeOriginalResource(this.onDidChangeOriginalResource, this),
+			workspace.registerFileSystemProvider('gitfs', this, { isReadonly: true, isCaseSensitive: true }),
+			workspace.registerResourceLabelFormatter({
+				scheme: 'gitfs',
+				formatting: {
+					label: '${path} (git)',
+					separator: '/'
+				}
+			})
+		);
+
+		setInterval(() => this.cleanup(), FIVE_MINUTES);
+	}
+
+	private onDidChangeRepository({ repository }: ModelChangeEvent): void {
+		this.changedRepositoryRoots.add(repository.root);
+		this.eventuallyFireChangeEvents();
+	}
+
+	private onDidChangeOriginalResource({ uri }: OriginalResourceChangeEvent): void {
+		if (uri.scheme !== 'file') {
+			return;
+		}
+
+		const gitUri = toGitUri(uri, '', { replaceFileExtension: true });
+		this.mtime = new Date().getTime();
+		this._onDidChangeFile.fire([{ type: FileChangeType.Changed, uri: gitUri }]);
+	}
+
+	@debounce(1100)
+	private eventuallyFireChangeEvents(): void {
+		this.fireChangeEvents();
+	}
+
+	@throttle
+	private async fireChangeEvents(): Promise<void> {
+		if (!window.state.focused) {
+			const onDidFocusWindow = filterEvent(window.onDidChangeWindowState, e => e.focused);
+			await eventToPromise(onDidFocusWindow);
+		}
+
+		const events: FileChangeEvent[] = [];
+
+		for (const { uri } of this.cache.values()) {
+			const fsPath = uri.fsPath;
+
+			for (const root of this.changedRepositoryRoots) {
+				if (isDescendant(root, fsPath)) {
+					events.push({ type: FileChangeType.Changed, uri });
+					break;
+				}
+			}
+		}
+
+		if (events.length > 0) {
+			this.mtime = new Date().getTime();
+			this._onDidChangeFile.fire(events);
+		}
+
+		this.changedRepositoryRoots.clear();
+	}
+
+	private cleanup(): void {
+		const now = new Date().getTime();
+		const cache = new Map<string, CacheRow>();
+
+		for (const row of this.cache.values()) {
+			const { path } = fromGitUri(row.uri);
+			const isOpen = workspace.textDocuments
+				.filter(d => d.uri.scheme === 'file')
+				.some(d => pathEquals(d.uri.fsPath, path));
+
+			if (isOpen || now - row.timestamp < THREE_MINUTES) {
+				cache.set(row.uri.toString(), row);
+			} else {
+				// TODO: should fire delete events?
+			}
+		}
+
+		this.cache = cache;
+	}
+
+	watch(): Disposable {
+		return EmptyDisposable;
+	}
+
+	stat(uri: Uri): FileStat {
+		const { submoduleOf } = fromGitUri(uri);
+		const repository = submoduleOf ? this.model.getRepository(submoduleOf) : this.model.getRepository(uri);
+
+		if (!repository) {
+			throw FileSystemError.FileNotFound();
+		}
+
+		return { type: FileType.File, size: 0, mtime: this.mtime, ctime: 0 };
+	}
+
+	readDirectory(): Thenable<[string, FileType][]> {
+		throw new Error('Method not implemented.');
+	}
+
+	createDirectory(): void {
+		throw new Error('Method not implemented.');
+	}
+
+	async readFile(uri: Uri): Promise<Uint8Array> {
+		let { path, ref, submoduleOf } = fromGitUri(uri);
+
+		if (submoduleOf) {
+			const repository = this.model.getRepository(submoduleOf);
+
+			if (!repository) {
+				throw FileSystemError.FileNotFound();
+			}
+
+			const encoder = new TextEncoder();
+
+			if (ref === 'index') {
+				return encoder.encode(await repository.diffIndexWithHEAD(path));
+			} else {
+				return encoder.encode(await repository.diffWithHEAD(path));
+			}
+		}
+
+		const repository = this.model.getRepository(uri);
+
+		if (!repository) {
+			throw FileSystemError.FileNotFound();
+		}
+
+		const timestamp = new Date().getTime();
+		const cacheValue: CacheRow = { uri, timestamp };
+
+		this.cache.set(uri.toString(), cacheValue);
+
+		if (ref === '~') {
+			const fileUri = Uri.file(path);
+			const uriString = fileUri.toString();
+			const [indexStatus] = repository.indexGroup.resourceStates.filter(r => r.resourceUri.toString() === uriString);
+			ref = indexStatus ? '' : 'HEAD';
+		} else if (/^~\d$/.test(ref)) {
+			ref = `:${ref[1]}`;
+		}
+
+		try {
+			return await repository.buffer(ref, path);
+		} catch (err) {
+			return new Uint8Array(0);
+		}
+	}
+
+	writeFile(): void {
+		throw new Error('Method not implemented.');
+	}
+
+	delete(): void {
+		throw new Error('Method not implemented.');
+	}
+
+	rename(): void {
+		throw new Error('Method not implemented.');
+	}
+
+	dispose(): void {
+		this.disposables.forEach(d => d.dispose());
+	}
+}

extensions/git/src/main.ts

@@ -11,6 +11,7 @@ import { findGit, Git, IGit } from './git';
 import { Model } from './model';
 import { CommandCenter } from './commands';
 import { GitContentProvider } from './contentProvider';
+import { GitFileSystemProvider } from './fileSystemProvider';
 import { GitDecorations } from './decorationProvider';
 import { Askpass } from './askpass';
 import { toDisposable, filterEvent, eventToPromise } from './util';
@@ -62,6 +63,7 @@ async function createModel(context: ExtensionContext, outputChannel: OutputChann
 	disposables.push(
 		new CommandCenter(git, model, outputChannel, telemetryReporter),
 		new GitContentProvider(model),
+		new GitFileSystemProvider(model),
 		new GitDecorations(model),
 		new GitProtocolHandler()
 	);

extensions/git/src/uri.ts

@@ -42,8 +42,8 @@ export function toGitUri(uri: Uri, ref: string, options: GitUriOptions = {}): Ur
 	}
 
 	return uri.with({
-		scheme: 'git',
+		scheme: 'gitfs',
 		path,
 		query: JSON.stringify(params)
 	});
-}
\ No newline at end of file
+}