Merge pull request #109 from edgardmessias/improved_external_changes

Improved external changes - Good stuff

Author: JohnstonCode

src/extension.ts

@@ -27,7 +27,7 @@ async function init(context: ExtensionContext, disposables: Disposable[]) {
   const model = new Model(svn);
   const contentProvider = new SvnContentProvider(model);
   const commands = new SvnCommands(model);
-  disposables.push(model);
+  disposables.push(model, contentProvider);
 
   outputChannel.appendLine("Using svn " + info.version + " from " + info.path);
 

src/model.ts

@@ -3,7 +3,9 @@ import {
   Uri,
   window,
   Disposable,
-  WorkspaceFoldersChangeEvent
+  WorkspaceFoldersChangeEvent,
+  EventEmitter,
+  Event
 } from "vscode";
 import * as fs from "fs";
 import * as path from "path";
@@ -13,11 +15,25 @@ import { Svn } from "./svn";
 import { dispose, anyEvent, filterEvent } from "./util";
 import { sequentialize } from "./decorators";
 
+export interface ModelChangeEvent {
+  repository: Repository;
+  uri: Uri;
+}
+
+export interface OriginalResourceChangeEvent {
+  repository: Repository;
+  uri: Uri;
+}
+
 interface OpenRepository {
   repository: Repository;
 }
 
 export class Model {
+  private _onDidChangeRepository = new EventEmitter<ModelChangeEvent>();
+  readonly onDidChangeRepository: Event<ModelChangeEvent> = this
+    ._onDidChangeRepository.event;
+
   public openRepositories: OpenRepository[] = [];
   private disposables: Disposable[] = [];
   private enabled = false;
@@ -199,7 +215,10 @@ export class Model {
       fs.readdirSync(path).forEach(file => {
         const dir = path + "/" + file;
 
-        if (fs.statSync(dir).isDirectory() && !micromatch.some([dir], this.ignoreList)) {
+        if (
+          fs.statSync(dir).isDirectory() &&
+          !micromatch.some([dir], this.ignoreList)
+        ) {
           this.tryOpenRepository(dir, newLevel);
         }
       });
@@ -257,6 +276,12 @@ export class Model {
   }
 
   private open(repository: Repository): void {
+    const changeListener = repository.onDidChangeRepository(uri =>
+      this._onDidChangeRepository.fire({ repository, uri })
+    );
+
+    this.disposables.push(changeListener);
+
     this.openRepositories.push({ repository });
   }
 

src/repository.ts

@@ -19,6 +19,7 @@ import { dispose, anyEvent, filterEvent, toDisposable } from "./util";
 import * as path from "path";
 import * as micromatch from "micromatch";
 import { setInterval, clearInterval } from "timers";
+import { toSvnUri } from "./uri";
 
 export class Repository {
   public watcher: FileSystemWatcher;
@@ -38,6 +39,9 @@ export class Repository {
   private _onDidChangeStatus = new EventEmitter<void>();
   readonly onDidChangeStatus: Event<void> = this._onDidChangeStatus.event;
 
+  private _onDidChangeBranch = new EventEmitter<void>();
+  readonly onDidChangeBranch: Event<void> = this._onDidChangeBranch.event;
+
   get root(): string {
     return this.repository.root;
   }
@@ -59,25 +63,37 @@ export class Repository {
       fsWatcher.onDidCreate,
       fsWatcher.onDidDelete
     );
+
     const onRepositoryChange = filterEvent(
       onWorkspaceChange,
       uri => !/^\.\./.test(path.relative(repository.root, uri.fsPath))
     );
     const onRelevantRepositoryChange = filterEvent(
       onRepositoryChange,
-      uri => !/\/\.svn\/tmp/.test(uri.path)
+      uri => !/[\\\/]\.svn[\\\/]tmp/.test(uri.path)
     );
     onRelevantRepositoryChange(this.update, this, this.disposables);
 
     const onRelevantSvnChange = filterEvent(onRelevantRepositoryChange, uri =>
-      /\/\.svn\//.test(uri.path)
+      /[\\\/]\.svn[\\\/]/.test(uri.path)
     );
+
     onRelevantSvnChange(
       this._onDidChangeRepository.fire,
       this._onDidChangeRepository,
       this.disposables
     );
 
+    this.onDidChangeRepository(
+      async () => {
+        if (!this.isSwitchingBranch) {
+          this.currentBranch = await this.getCurrentBranch();
+        }
+      },
+      null,
+      this.disposables
+    );
+
     this.sourceControl = scm.createSourceControl(
       "svn",
       "SVN",
@@ -98,12 +114,12 @@ export class Repository {
       null,
       this.disposables
     );
-    this.onDidChangeRepository(
-      () => (this.sourceControl.statusBarCommands = statusBar.commands),
-      null,
-      this.disposables
-    );
-    this.sourceControl.statusBarCommands = statusBar.commands;
+
+    const updateBranchName = async () => {
+      this.currentBranch = await this.getCurrentBranch();
+      this.sourceControl.statusBarCommands = statusBar.commands;
+    };
+    updateBranchName();
 
     this.changes = this.sourceControl.createResourceGroup("changes", "Changes");
     this.notTracked = this.sourceControl.createResourceGroup(
@@ -196,8 +212,6 @@ export class Repository {
     this.changes.resourceStates = changes;
     this.notTracked.resourceStates = notTracked;
 
-    this.currentBranch = await this.getCurrentBranch();
-
     this._onDidChangeStatus.fire();
 
     return Promise.resolve();
@@ -208,7 +222,7 @@ export class Repository {
       return;
     }
 
-    return uri.with({ scheme: "svn", query: uri.path, path: uri.path });
+    return toSvnUri(uri, "");
   }
 
   show(filePath: string, revision?: string): Promise<string> {
@@ -229,17 +243,17 @@ export class Repository {
 
   async branch(name: string) {
     this.isSwitchingBranch = true;
-    this._onDidChangeRepository.fire();
+    this._onDidChangeBranch.fire();
     const response = await this.repository.branch(name);
     this.isSwitchingBranch = false;
     this.updateBranches();
-    this._onDidChangeRepository.fire();
+    this._onDidChangeBranch.fire();
     return response;
   }
 
   async switchBranch(name: string) {
     this.isSwitchingBranch = true;
-    this._onDidChangeRepository.fire();
+    this._onDidChangeBranch.fire();
 
     try {
       const response = await this.repository.switchBranch(name);
@@ -257,7 +271,7 @@ export class Repository {
     } finally {
       this.isSwitchingBranch = false;
       this.updateBranches();
-      this._onDidChangeRepository.fire();
+      this._onDidChangeBranch.fire();
     }
   }
 }

src/statusBar.ts

@@ -10,11 +10,20 @@ export class SvnStatusBar {
   }
 
   constructor(private repository: Repository) {
-    repository.onDidChangeStatus(
+    repository.onDidChangeBranch(
       this._onDidChange.fire,
       this._onDidChange,
       this.disposables
     );
+    repository.onDidChangeRepository(
+      () => {
+        if (!this.repository.isSwitchingBranch) {
+          this._onDidChange.fire();
+        }
+      },
+      null,
+      this.disposables
+    );
   }
 
   get commands() {

src/svnContentProvider.ts

@@ -1,9 +1,87 @@
-import { workspace, Uri } from "vscode";
-import { Model } from "./model";
+import {
+  workspace,
+  Uri,
+  TextDocumentContentProvider,
+  EventEmitter,
+  Event,
+  Disposable,
+  window
+} from "vscode";
+import { Model, ModelChangeEvent, OriginalResourceChangeEvent } from "./model";
+import { toSvnUri, fromSvnUri } from "./uri";
+import { throttle, debounce } from "./decorators";
+import {
+  filterEvent,
+  eventToPromise,
+  isDescendant,
+  toDisposable
+} from "./util";
+
+interface CacheRow {
+  uri: Uri;
+  timestamp: number;
+}
+
+interface Cache {
+  [uri: string]: CacheRow;
+}
+
+const THREE_MINUTES = 1000 * 60 * 3;
+const FIVE_MINUTES = 1000 * 60 * 5;
+
+export class SvnContentProvider implements TextDocumentContentProvider {
+  private _onDidChange = new EventEmitter<Uri>();
+  get onDidChange(): Event<Uri> {
+    return this._onDidChange.event;
+  }
+
+  private changedRepositoryRoots = new Set<string>();
+  private cache: Cache = Object.create(null);
+  private disposables: Disposable[] = [];
 
-export class SvnContentProvider {
   constructor(private model: Model) {
-    workspace.registerTextDocumentContentProvider("svn", this);
+    this.disposables.push(
+      model.onDidChangeRepository(this.onDidChangeRepository, this),
+      workspace.registerTextDocumentContentProvider("svn", this)
+    );
+
+    const interval = setInterval(() => this.cleanup(), FIVE_MINUTES);
+    this.disposables.push(toDisposable(() => clearInterval(interval)));
+  }
+
+  private onDidChangeRepository({ repository }: ModelChangeEvent): void {
+    this.changedRepositoryRoots.add(repository.root);
+    this.eventuallyFireChangeEvents();
+  }
+
+  @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);
+    }
+
+    Object.keys(this.cache).forEach(key => {
+      const uri = this.cache[key].uri;
+      const fsPath = uri.fsPath;
+
+      for (const root of this.changedRepositoryRoots) {
+        if (isDescendant(root, fsPath)) {
+          this._onDidChange.fire(uri);
+          return;
+        }
+      }
+    });
+
+    this.changedRepositoryRoots.clear();
   }
 
   async provideTextDocumentContent(uri: Uri): Promise<string> {
@@ -13,6 +91,12 @@ export class SvnContentProvider {
       return "";
     }
 
+    const cacheKey = uri.toString();
+    const timestamp = new Date().getTime();
+    const cacheValue: CacheRow = { uri, timestamp };
+
+    this.cache[cacheKey] = cacheValue;
+
     let revision = undefined;
 
     const config = workspace.getConfiguration("svn");
@@ -28,4 +112,27 @@ export class SvnContentProvider {
       return "";
     }
   }
+
+  private cleanup(): void {
+    const now = new Date().getTime();
+    const cache = Object.create(null);
+
+    Object.keys(this.cache).forEach(key => {
+      const row = this.cache[key];
+      const { path } = fromSvnUri(row.uri);
+      const isOpen = workspace.textDocuments
+        .filter(d => d.uri.scheme === "file")
+        .some(d => d.uri.fsPath === path);
+
+      if (isOpen || now - row.timestamp < THREE_MINUTES) {
+        cache[row.uri.toString()] = row;
+      }
+    });
+
+    this.cache = cache;
+  }
+
+  dispose(): void {
+    this.disposables.forEach(d => d.dispose());
+  }
 }

src/uri.ts

@@ -1,5 +1,14 @@
 import { Uri } from "vscode";
 
+export interface SvnUriParams {
+  path: string;
+  ref: string;
+}
+
+export function fromSvnUri(uri: Uri): SvnUriParams {
+  return JSON.parse(uri.query);
+}
+
 export function toSvnUri(uri: Uri, ref: string): Uri {
   return uri.with({
     scheme: "svn",