Simplify git status.

Author: vlad-shatskyi

src/plugins/GitWatcher.ts

@@ -5,9 +5,9 @@ import {watch, FSWatcher} from "fs";
 import * as Path from "path";
 import * as _ from "lodash";
 import {EventEmitter} from "events";
-import {executeCommand} from "../PTY";
 import {debounce} from "../Decorators";
 import * as Git from "../utils/Git";
+import {currentBranchName, GitDirectoryPath, hasUncommittedChanges} from "../utils/Git";
 
 const GIT_WATCHER_EVENT_NAME = "git-data-changed";
 
@@ -31,7 +31,7 @@ class GitWatcher extends EventEmitter {
 
     watch() {
         if (Git.isGitDirectory(this.directory)) {
-            this.updateGitData();
+            this.updateGitData(this.directory);
             this.watcher = watch(this.directory, <any>{
                 recursive: true,
             });
@@ -42,7 +42,9 @@ class GitWatcher extends EventEmitter {
                     if (!fileName.startsWith(".git") ||
                         fileName === this.GIT_HEAD_FILE_NAME ||
                         fileName.startsWith(this.GIT_HEADS_DIRECTORY_NAME)) {
-                        this.updateGitData();
+                        if (Git.isGitDirectory(this.directory)) {
+                            this.updateGitData(this.directory);
+                        }
                     }
                 },
             );
@@ -53,88 +55,16 @@ class GitWatcher extends EventEmitter {
     }
 
     @debounce(1000 / 60)
-    private async updateGitData() {
-
-        executeCommand("git", ["status", "-b", "--porcelain"], this.directory).then(changes => {
-            const status: VcsStatus = (changes.split("\n").length > 2) ? "dirty" : "clean";
-            let head: string = changes.split(" ")[1];
-            let push: string = "0";
-            let pull: string = "0";
-
-            let secondSplit: Array<string> = changes.split("[");
-            if (secondSplit.length > 1) {
-                let rawPushPull: string = secondSplit[1].slice(0, -2);
-                let separatedPushPull: Array<string> = rawPushPull.split(", ");
-
-
-                if (separatedPushPull.length > 0) {
-                    for (let i in separatedPushPull) {
-                        if (separatedPushPull.hasOwnProperty(i)) {
-                            let splitAgain: Array<string> = separatedPushPull[i].split(" ");
-                            switch (splitAgain[0]) {
-                                case "ahead":
-                                    push = splitAgain[1];
-                                    break;
-                                case "behind":
-                                    pull = splitAgain[1];
-                                    break;
-                                default:
-                                    break;
-                            }
-                        }
-                    }
-                }
-            }
-
-            let fileChanges = linesToFileChanges(changes);
-
-            const data: VcsData = {
-                kind: "repository",
-                branch: head,
-                push: push,
-                pull: pull,
-                status: status,
-                changes: fileChanges,
-            };
-
-            this.emit(GIT_WATCHER_EVENT_NAME, data);
-        });
+    private async updateGitData(directory: GitDirectoryPath) {
+        const data: VcsData = {
+            kind: "repository",
+            branch: await currentBranchName(directory),
+            status: (await hasUncommittedChanges(directory) ? "dirty" : "clean"),
+        };
+
+        this.emit(GIT_WATCHER_EVENT_NAME, data);
     }
 }
-function linesToFileChanges(lines: string): FileChanges {
-    let stagedChanges = new Map<string, number>([["+", 0], ["~", 0], ["-", 0], ["!", 0]]);
-    let unstagedChanges = new Map<string, number>([["+", 0], ["~", 0], ["-", 0], ["!", 0]]);
-    lines.split("\n").slice(1).forEach((line) => {
-        switch (line[0]) {
-            case "A": stagedChanges.set("+", stagedChanges.get("+")! + 1); break;
-            case "M":
-            case "R":
-            case "C": stagedChanges.set("~", stagedChanges.get("~")! + 1); break;
-            case "D": stagedChanges.set("-", stagedChanges.get("-")! + 1); break;
-            case "U": stagedChanges.set("!", stagedChanges.get("!")! + 1); break;
-            default: break;
-        }
-
-        switch (line[1]) {
-            case "?":
-            case "A": unstagedChanges.set("+", stagedChanges.get("+")! + 1); break;
-            case "M": unstagedChanges.set("~", stagedChanges.get("~")! + 1); break;
-            case "D": unstagedChanges.set("-", stagedChanges.get("-")! + 1); break;
-            case "U": unstagedChanges.set("!", stagedChanges.get("!")! + 1); break;
-            default: break;
-        }
-    });
-    let stagedResult: string = [...stagedChanges]
-        .filter((pair) => (pair[1] !== 0))
-        .map(([key, v]) => (key + String(v) + " "))
-        .reduce((left, right) => (left + right), "");
-    let unstagedResult: string = [...unstagedChanges]
-        .filter((pair) => (pair[1] !== 0))
-        .map(([key, v]) => key + String(v) + " ")
-        .reduce((left, right) => left + right, "");
-    return {stagedChanges: stagedResult, unstagedChanges: unstagedResult};
-}
-
 
 interface WatchesValue {
     listeners: Set<Session>;

src/utils/Git.ts

@@ -117,16 +117,32 @@ type BranchesOptions = {
     tags: boolean;
 };
 
+export async function currentBranchName(directory: GitDirectoryPath): Promise<string> {
+    const output = await executeCommand(
+        "git",
+        ['"symbolic-ref"', '"--short"', '"-q"', '"HEAD"'],
+        directory,
+    );
+
+    return output.trim();
+}
+
+export async function hasUncommittedChanges(directory: GitDirectoryPath): Promise<boolean> {
+    const output = await executeCommand(
+        "git",
+        ["status", "--untracked-files=no", "--porcelain"],
+        directory,
+    );
+
+    return output.trim().length !== 0;
+}
+
 export async function branches({
     directory,
     remotes,
     tags,
 }: BranchesOptions): Promise<Branch[]> {
-    const currentBranch = await executeCommand(
-        "git",
-        ['"symbolic-ref"', '"--short"', '"-q"', '"HEAD"'],
-        directory)
-        .then(branchName => branchName.trim());
+    const currentBranch = await currentBranchName(directory);
     const promiseHeadsTags = linedOutputOf(
         "git",
         ["for-each-ref", "refs/heads ", tags ? "refs/tags " : "",

src/views/StatusBarComponent.tsx

@@ -9,22 +9,6 @@ const VcsDataComponent = ({data}: { data: VcsData }) => {
         return (
             <div style={css.statusBar.vcsData}>
                 <span style={css.statusBar.status(data.status)}>
-                    {(data.status === "dirty") ?
-                      (<span>
-                        <span style={css.statusBar.stagedFileChanges}>
-                          {data.changes.stagedChanges}
-                        </span>
-                        {(data.changes.stagedChanges === "") ? "" : "| "}
-                        <span style={css.statusBar.unstagedFileChanges}>
-                          {data.changes.unstagedChanges}
-                        </span>
-                      </span>) :
-                      undefined
-                    }
-                    <span style={css.statusBar.icon}>{fontAwesome.longArrowDown}</span>
-                    {data.pull}
-                    <span style={css.statusBar.icon}>{fontAwesome.longArrowUp}</span>
-                    {data.push}
                     <span style={css.statusBar.icon}>{fontAwesome.codeFork}</span>
                     {data.branch}
                 </span>

typings/Interfaces.d.ts

@@ -23,9 +23,6 @@ type VcsStatus = "dirty" | "clean";
 type VcsData = {
   kind: "repository",
   branch: string,
-  push: string,
-  pull: string,
-  changes: FileChanges,
   status: VcsStatus;
 } | { kind: "not-repository"; };