Merge pull request #52 from edgardmessias/statusbar_switching

Improved workspace events changes

Author: JohnstonCode

src/decorators.ts

@@ -1,38 +1,103 @@
-export function debounce(func: Function, wait: number, context: any) {
-  let timer: any = null;
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
 
-  return function(...args: any[]) {
-    clearTimeout(timer);
+'use strict';
 
-    timer = setTimeout(() => {
-      func.apply(context, ...args);
-    }, wait);
+import { done } from './util';
+
+function decorate(decorator: (fn: Function, key: string) => Function): Function {
+  return (target: any, key: string, descriptor: any) => {
+    let fnKey: string | null = null;
+    let fn: Function | null = null;
+
+    if (typeof descriptor.value === 'function') {
+      fnKey = 'value';
+      fn = descriptor.value;
+    } else if (typeof descriptor.get === 'function') {
+      fnKey = 'get';
+      fn = descriptor.get;
+    }
+
+    if (!fn || !fnKey) {
+      throw new Error('not supported');
+    }
+
+    descriptor[fnKey] = decorator(fn, key);
+  };
+}
+
+function _memoize(fn: Function, key: string): Function {
+  const memoizeKey = `$memoize$${key}`;
+
+  return function (...args: any[]) {
+    if (!this.hasOwnProperty(memoizeKey)) {
+      Object.defineProperty(this, memoizeKey, {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: fn.apply(this, args)
+      });
+    }
+
+    return this[memoizeKey];
   };
 }
 
-export function throttleAsync(fn: Function, key: string, context: any) {
-  //   const currentKey = `$throttle$current$${key}`;
-  //   const nextKey = `$throttle$next$${key}`;
-  //   const trigger = function(...args: any[]) {
-  //     if (this[nextKey]) {
-  //       return this[nextKey];
-  //     }
-  //     if (this[nextKey]) {
-  //       done(this[currentKey]).then(() => {
-  //         this[nextKey] = false;
-  //         return trigger.apply(context, ...args);
-  //       });
-  //       return this[nextKey];
-  //     }
-  //     this[currentKey] = fn.apply(context, args);
-  //     this[currentKey].then(() => {
-  //       this[currentKey] = false;
-  //     });
-  //     return this[currentKey];
-  //   };
-  //   return trigger;
+export const memoize = decorate(_memoize);
+
+function _throttle<T>(fn: Function, key: string): Function {
+  const currentKey = `$throttle$current$${key}`;
+  const nextKey = `$throttle$next$${key}`;
+
+  const trigger = function (...args: any[]) {
+    if (this[nextKey]) {
+      return this[nextKey];
+    }
+
+    if (this[currentKey]) {
+      this[nextKey] = done(this[currentKey]).then(() => {
+        this[nextKey] = undefined;
+        return trigger.apply(this, args);
+      });
+
+      return this[nextKey];
+    }
+
+    this[currentKey] = fn.apply(this, args) as Promise<T>;
+
+    const clear = () => this[currentKey] = undefined;
+    done(this[currentKey]).then(clear, clear);
+
+    return this[currentKey];
+  };
+
+  return trigger;
 }
 
-function done(promise: Promise<void>) {
-  return promise.then(() => void 0);
+export const throttle = decorate(_throttle);
+
+function _sequentialize<T>(fn: Function, key: string): Function {
+  const currentKey = `__$sequence$${key}`;
+
+  return function (...args: any[]) {
+    const currentPromise = this[currentKey] as Promise<any> || Promise.resolve(null);
+    const run = async () => await fn.apply(this, args);
+    this[currentKey] = currentPromise.then(run, run);
+    return this[currentKey];
+  };
 }
+
+export const sequentialize = decorate(_sequentialize);
+
+export function debounce(delay: number): Function {
+  return decorate((fn, key) => {
+    const timerKey = `$debounce$${key}`;
+
+    return function (...args: any[]) {
+      clearTimeout(this[timerKey]);
+      this[timerKey] = setTimeout(() => fn.apply(this, args), delay);
+    };
+  });
+}

src/repository.ts

@@ -11,10 +11,11 @@ import {
   Event
 } from "vscode";
 import { Resource } from "./resource";
-import { throttleAsync, debounce } from "./decorators";
-import { Repository as BaseRepository } from "./svnRepository";
+import { throttle, debounce } from "./decorators";
+import { Repository as BaseRepository } from "./svn";
 import { SvnStatusBar } from "./statusBar";
-import { dispose } from "./util";
+import { dispose, anyEvent, filterEvent } from "./util";
+import * as path from 'path';
 
 export class Repository {
   public watcher: FileSystemWatcher;
@@ -23,8 +24,12 @@ export class Repository {
   public notTracked: SourceControlResourceGroup;
   private disposables: Disposable[] = [];
   public currentBranch = "";
+  public isSwitchingBranch: boolean = false;
   public branches: any[] = [];
 
+  private _onDidChangeRepository = new EventEmitter<Uri>();
+  readonly onDidChangeRepository: Event<Uri> = this._onDidChangeRepository.event;
+
   private _onDidChangeStatus = new EventEmitter<void>();
   readonly onDidChangeStatus: Event<void> = this._onDidChangeStatus.event;
 
@@ -41,8 +46,16 @@ export class Repository {
   }
 
   constructor(public repository: BaseRepository) {
-    this.watcher = workspace.createFileSystemWatcher("**");
-    this.disposables.push(this.watcher);
+    const fsWatcher = workspace.createFileSystemWatcher("**");
+    this.disposables.push(fsWatcher);
+
+    const onWorkspaceChange = anyEvent(fsWatcher.onDidChange, 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));
+    onRelevantRepositoryChange(this.update, this, this.disposables);
+
+    const onRelevantSvnChange = filterEvent(onRelevantRepositoryChange, uri => /\/\.svn\//.test(uri.path));
+    onRelevantSvnChange(this._onDidChangeRepository.fire, this._onDidChangeRepository, this.disposables);
 
     this.sourceControl = scm.createSourceControl(
       "svn",
@@ -76,23 +89,9 @@ export class Repository {
     this.notTracked.hideWhenEmpty = true;
 
     this.update();
-    this.addEventListeners();
-  }
-
-  private addEventListeners() {
-    const debounceUpdate = debounce(this.update, 1000, this);
-
-    this.watcher.onDidChange(() => {
-      debounceUpdate();
-    });
-    this.watcher.onDidCreate(() => {
-      debounceUpdate();
-    });
-    this.watcher.onDidDelete(() => {
-      debounceUpdate();
-    });
   }
 
+  @debounce(1000)
   async update() {
     let changes: any[] = [];
     let notTracked: any[] = [];
@@ -170,7 +169,12 @@ export class Repository {
     return this.repository.branch(name);
   }
 
-  switchBranch(name: string) {
-    return this.repository.switchBranch(name);
+  async switchBranch(name: string) {
+    this.isSwitchingBranch = true;
+    this._onDidChangeStatus.fire();
+    const response = await this.repository.switchBranch(name);
+    this.isSwitchingBranch = false;
+    this._onDidChangeStatus.fire();
+    return response;
   }
 }

src/statusBar.ts

@@ -18,7 +18,8 @@ export class SvnStatusBar {
   }
 
   get commands() {
-    const title = `$(git-branch) ${this.repository.currentBranch}`;
+    const icon = (this.repository.isSwitchingBranch)? 'sync~spin' : 'git-branch';
+    const title = `$(${icon}) ${this.repository.currentBranch}`;
 
     return [
       {

src/util.ts

@@ -4,6 +4,9 @@ export interface BaseDisposable {
   dispose(): void;
 }
 
+export function done<T>(promise: Promise<T>): Promise<void> {
+  return promise.then<void>(() => void 0);
+}
 export function anyEvent<T>(...events: Event<T>[]): Event<T> {
   return (listener, thisArgs = null, disposables?) => {
     const result = combinedDisposable(