Git: Adopt FileSystem 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());
  }
-}
+}

extensions/git/src/fileSystemProvider.ts

@@ -0,0 +1,199 @@
+/*---------------------------------------------------------------------------------------------
+ * 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)
  });
-}
+}