workspace folder events now work correctly

Author: JohnstonCode

src/model.ts

@@ -9,7 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { Repository } from "./repository";
 import { Svn } from "./svn";
-import { dispose } from "./util";
+import { dispose, anyEvent, filterEvent } from "./util";
 
 interface OpenRepository {
   repository: Repository;
@@ -19,6 +19,7 @@ export class Model {
   public openRepositories: OpenRepository[] = [];
   private disposables: Disposable[] = [];
   private enabled = false;
+  private possibleSvnRepositoryPaths = new Set<string>();
 
   get repositories(): Repository[] {
     return this.openRepositories.map(r => r.repository);
@@ -46,9 +47,41 @@ export class Model {
       removed: []
     });
 
+    const fsWatcher = workspace.createFileSystemWatcher("**");
+    this.disposables.push(fsWatcher);
+
+    const onWorkspaceChange = anyEvent(
+      fsWatcher.onDidChange,
+      fsWatcher.onDidCreate,
+      fsWatcher.onDidDelete
+    );
+    const onPossibleSvnRepositoryChange = filterEvent(
+      onWorkspaceChange,
+      uri => !this.getRepository(uri)
+    );
+    onPossibleSvnRepositoryChange(
+      this.onPossibleSvnRepositoryChange,
+      this,
+      this.disposables
+    );
+
     this.scanWorkspaceFolders();
   }
 
+  private onPossibleSvnRepositoryChange(uri: Uri): void {
+    const possibleSvnRepositoryPath = uri.fsPath.replace(/\.svn.*$/, "");
+    this.possibleSvnRepositoryPaths.add(possibleSvnRepositoryPath);
+    this.eventuallyScanPossibleSvnRepositories();
+  }
+
+  private eventuallyScanPossibleSvnRepositories(): void {
+    for (const path of this.possibleSvnRepositoryPaths) {
+      this.tryOpenRepository(path);
+    }
+
+    this.possibleSvnRepositoryPaths.clear();
+  }
+
   private disable(): void {
     this.repositories.forEach(repository => repository.dispose());
     this.openRepositories = [];
@@ -112,7 +145,7 @@ export class Model {
     return liveRepository && liveRepository.repository;
   }
 
-  getOpenRepository(hint: any) {
+  getOpenRepository(hint: any): OpenRepository | undefined {
     if (!hint) {
       return undefined;
     }
@@ -121,20 +154,38 @@ export class Model {
       return this.openRepositories.filter(r => r.repository === hint)[0];
     }
 
-    hint = Uri.file(hint);
+    if (typeof hint === "string") {
+      hint = Uri.file(hint);
+    }
+
+    if (hint instanceof Uri) {
+      for (const liveRepository of this.openRepositories) {
+        const relativePath = path.relative(
+          liveRepository.repository.root,
+          hint.fsPath
+        );
+
+        if (!/^\.\./.test(relativePath)) {
+          return liveRepository;
+        }
+      }
+
+      return undefined;
+    }
 
     for (const liveRepository of this.openRepositories) {
-      const relativePath = path.relative(
-        liveRepository.repository.root,
-        hint.fsPath
-      );
+      const repository = liveRepository.repository;
 
-      if (!/^\.\./.test(relativePath)) {
+      if (hint === repository.sourceControl) {
         return liveRepository;
       }
 
-      return undefined;
+      if (hint === repository.changes || hint === repository.notTracked) {
+        return liveRepository;
+      }
     }
+
+    return undefined;
   }
 
   private open(repository: Repository): void {

src/repository.ts

@@ -18,7 +18,7 @@ import { dispose } from "./util";
 
 export class Repository {
   public watcher: FileSystemWatcher;
-  private sourceControl: SourceControl;
+  public sourceControl: SourceControl;
   public changes: SourceControlResourceGroup;
   public notTracked: SourceControlResourceGroup;
   private disposables: Disposable[] = [];

src/svn.ts

@@ -155,7 +155,7 @@ export class Repository {
         .pop();
       return currentBranch;
     } catch (error) {
-      return;
+      return "";
     }
   }
 }

src/util.ts

@@ -1,5 +1,43 @@
+import { Event } from "vscode";
+
+export interface BaseDisposable {
+  dispose(): void;
+}
+
+export function anyEvent<T>(...events: Event<T>[]): Event<T> {
+  return (listener, thisArgs = null, disposables?) => {
+    const result = combinedDisposable(
+      events.map(event => event(i => listener.call(thisArgs, i)))
+    );
+
+    if (disposables) {
+      disposables.push(result);
+    }
+
+    return result;
+  };
+}
+
+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);
+}
+
 export function dispose(disposables: any[]): any[] {
   disposables.forEach(disposable => disposable.dispose());
 
   return [];
 }
+
+export function combinedDisposable(
+  disposables: BaseDisposable[]
+): BaseDisposable {
+  return toDisposable(() => dispose(disposables));
+}
+
+export function toDisposable(dispose: () => void): BaseDisposable {
+  return { dispose };
+}