feat(git): mark the last pushed commit in history

src/extensions/default/Git/src/History.js

@@ -1,11 +1,12 @@
 define(function (require) {
 
     // Brackets modules
     var _ = brackets.getModule("thirdparty/lodash"),
         DocumentManager = brackets.getModule("document/DocumentManager"),
         FileUtils = brackets.getModule("file/FileUtils"),
         LocalizationUtils = brackets.getModule("utils/LocalizationUtils"),
         Strings = brackets.getModule("strings"),
+        StringUtils = brackets.getModule("utils/StringUtils"),
         Metrics = brackets.getModule("utils/Metrics"),
         NotificationUI = brackets.getModule("widgets/NotificationUI"),
         Mustache = brackets.getModule("thirdparty/mustache/mustache");
@@ -19,8 +20,9 @@
         Preferences = require("src/Preferences");
 
     // Templates
     var gitPanelHistoryTemplate = require("text!templates/git-panel-history.html"),
-        gitPanelHistoryCommitsTemplate = require("text!templates/git-panel-history-commits.html");
+        gitPanelHistoryCommitsTemplate = require("text!templates/git-panel-history-commits.html"),
+        gitPanelHistoryEndTemplate = require("text!templates/git-panel-history-end.html");
 
     // Module variables
     let $gitPanel         = $(null),
@@ -29,6 +31,14 @@
         commitCache       = [],
         lastDocumentSeen  = null;
 
+    // Where the branch stands against its remote, for the push waterline.
+    // `remoteHead` is null when the branch has no counterpart on the remote at
+    // all; `remoteHeadSeen` latches once the waterline has been placed, so the
+    // pages loaded after it are known to be pushed without re-testing them.
+    let remoteHead      = null,
+        remoteHeadSeen  = false,
+        unpushedCount   = 0;
+
     // must match the page size git log is invoked with in GitCli.getHistory
     const HISTORY_PAGE_SIZE = 100;
 
@@ -52,8 +62,8 @@
             })
             .on("click.history", ".history-commit", function () {
                 const $tr = $(this);
                 var hash = $tr.attr("x-hash");
                 var commit = _.find(commitCache, function (commit) { return commit.hash === hash; });
                 const historyShown = HistoryViewer.toggle(commit, getCurrentDocument(), {
                     isInitial: $(this).attr("x-initial-commit") === "true"
                 });
@@ -64,21 +74,21 @@
             });
     }
 
     var generateCssAvatar = _.memoize(function (author, email) {
 
         // Original source: http://indiegamr.com/generate-repeatable-random-numbers-in-js/
         var seededRandom = function (max, min, seed) {
             max = max || 1;
             min = min || 0;
 
             seed = (seed * 9301 + 49297) % 233280;
             var rnd = seed / 233280.0;
 
             return min + rnd * (max - min);
         };
 
         // Use `seededRandom()` to generate a pseudo-random number [0-16] to pick a color from the list
         var seedBase = parseInt(author.charCodeAt(3).toString(), email.length),
             seed = parseInt(email.charCodeAt(seedBase.toString().substring(1, 2)).toString(), 16),
             colors = [
                 "#ffb13b", "#dd5f7a", "#8dd43a", "#2f7e2f", "#4141b9", "#3dafea", "#7e3e3e", "#f2f26b",
@@ -100,12 +110,15 @@
     function _renderHistoryTable(commits, file) {
         // calculate some missing stuff like avatars
         commits = addAdditionalCommitInfo(commits);
+        commits = markPushState(commits, file);
         commitCache = commitCache.concat(commits);
 
         const templateData = {
             commits: commits,
-            emptyMessage: file ? Strings.GIT_FILE_HISTORY_NOTHING_TO_SHOW : Strings.GIT_HISTORY_NOTHING_TO_SHOW,
-            Strings: Strings
+            // the banner only makes sense for a branch, not one file's history
+            notPushed: !file && !remoteHead && commits.length > 0,
+            Strings: Strings,
+            emptyMessage: file ? Strings.GIT_FILE_HISTORY_NOTHING_TO_SHOW : Strings.GIT_HISTORY_NOTHING_TO_SHOW
         };
 
         $tableContainer.find("#git-history-list").remove();
@@ -120,10 +133,30 @@
         if (commits.length < HISTORY_PAGE_SIZE) {
             // the full history is already here, so the last commit is the initial
             // one. with more pages the initial commit is marked by loadMoreHistory.
-            $historyList.attr("x-finished", "true");
-            $historyList
-                .find("tr.history-commit:last-child")
-                .attr("x-initial-commit", "true");
+            markHistoryFinished();
+        }
+    }
+
+    /**
+     * Note that the whole history is on screen.
+     *
+     * Marks the oldest commit so HistoryViewer knows it has nothing to diff
+     * against, and, for a branch with no counterpart on the remote, closes the
+     * unpushed run with a line — only here, because until the initial commit is
+     * reached a closing line would claim a bottom the list does not have yet.
+     *
+     * Matches the last commit row with `.last()` rather than `:last-child`: the
+     * waterline rows are siblings, so the oldest commit is not always the final
+     * child of the table body.
+     */
+    function markHistoryFinished() {
+        $historyList.attr("x-finished", "true");
+        const $lastCommit = $historyList.find("tr.history-commit").last();
+        $lastCommit.attr("x-initial-commit", "true");
+        if (!remoteHead && $lastCommit.length && !$historyList.find("tr.history-push-end").length) {
+            $lastCommit.after(Mustache.render(gitPanelHistoryEndTemplate, {
+                allLocalText: StringUtils.format(Strings.GIT_HISTORY_ALL_LOCAL, unpushedCount)
+            }));
         }
     }
 
@@ -134,14 +167,25 @@
         // clear cache
         commitCache = [];
 
+        // the waterline is recomputed per render: the remote may have moved
+        remoteHead = null;
+        remoteHeadSeen = false;
+        unpushedCount = 0;
+
         return Git.getCurrentBranchName().then(function (branchName) {
-            // Get the history commits of the current branch
-            var p = file ? Git.getFileHistory(file.relative, branchName) : Git.getHistory(branchName);
-            return p.then(function (commits) {
-                if (renderId === historyRenderId) {
-                    _renderHistoryTable(commits, file);
-                }
-                return true;
+            return Git.getRemoteBranchHead(branchName).catch(function () {
+                // a repo without remotes is normal, not an error to surface
+                return null;
+            }).then(function (head) {
+                remoteHead = head;
+                // Get the history commits of the current branch
+                var p = file ? Git.getFileHistory(file.relative, branchName) : Git.getHistory(branchName);
+                return p.then(function (commits) {
+                    if (renderId === historyRenderId) {
+                        _renderHistoryTable(commits, file);
+                    }
+                    return true;
+                });
             });
         }).catch(function (err) {
             if (renderId !== historyRenderId) {
@@ -170,7 +214,7 @@
                 loadingMoreHistory = true;
                 const renderId = historyRenderId;
                 return Git.getCurrentBranchName().then(function (branchName) {
                     var p,
                         file = $historyList.data("file-relative"),
                         skipCount = $tableContainer.find("tr.history-commit").length;
                     if (file) {
@@ -184,22 +228,20 @@
                             return;
                         }
                         if (commits.length === 0) {
-                            $historyList.attr("x-finished", "true");
                             // marks initial commit as first
-                            $historyList
-                                .find("tr.history-commit:last-child")
-                                .attr("x-initial-commit", "true");
+                            markHistoryFinished();
                             return;
                         }
 
                         commits = addAdditionalCommitInfo(commits);
+                        commits = markPushState(commits, file);
                         commitCache = commitCache.concat(commits);
 
                         var templateData = {
                             commits: commits,
                             Strings: Strings
                         };
                         var commitsHtml = Mustache.render(gitPanelHistoryCommitsTemplate, templateData);
                         $historyList.children("tbody").append(commitsHtml);
                     })
                     .catch(function (err) {
@@ -241,11 +283,60 @@
         return commits;
     }
 
+    /**
+     * Flag each commit against the remote, for the waterline the table draws.
+     *
+     * Commits arrive newest first, so everything listed before the remote's
+     * head is still local: walk until that commit shows up, mark it, and leave
+     * the rest alone — they are older than the remote tip and therefore pushed.
+     * The latch carries the answer across pages, since every later page is
+     * older than the one before it. With no counterpart on the remote nothing
+     * has been pushed and every commit is flagged.
+     *
+     * File history is skipped entirely: it lists only the commits touching one
+     * file, so the remote's head usually is not among them and every row would
+     * be wrongly called local.
+     *
+     * @param {Array<Object>} commits - commits for this page, newest first
+     * @param {?(Object|string)} file - whatever the caller holds for the file on
+     *      show; only its presence matters, the first page has the object and
+     *      later pages the relative path
+     * @return {Array<Object>} the same commits, flagged in place
+     */
+    function markPushState(commits, file) {
+        if (file) {
+            return commits;
+        }
+        _.forEach(commits, function (commit) {
+            if (!remoteHead) {
+                commit.unpushed = true;
+                return;
+            }
+            if (remoteHeadSeen) {
+                return;
+            }
+            if (commit.hash === remoteHead.hash) {
+                commit.isRemoteHead = true;
+                // the ref name is a git identifier, never translated
+                commit.remoteRef = remoteHead.ref;
+                commit.isAhead = unpushedCount > 0;
+                commit.pushStateText = commit.isAhead
+                    ? StringUtils.format(Strings.GIT_HISTORY_AHEAD, unpushedCount)
+                    : Strings.GIT_HISTORY_UP_TO_DATE;
+                remoteHeadSeen = true;
+                return;
+            }
+            commit.unpushed = true;
+            unpushedCount++;
+        });
+        return commits;
+    }
+
     function getCurrentDocument() {
         if (HistoryViewer.isVisible()) {
             return lastDocumentSeen;
         }
         var doc = DocumentManager.getCurrentDocument();
         if (doc) {
             lastDocumentSeen = doc;
         }
@@ -264,7 +355,7 @@
     }
 
     function handleFileChange() {
         var currentDocument = getCurrentDocument();
 
         if ($historyList.is(":visible") && $historyList.data("file")) {
             handleToggleHistory("FILE", currentDocument);
@@ -322,13 +413,13 @@
         }
 
         // Render #git-history-list if is not already generated or if the viewed file for file history has changed
         var isEmpty = $historyList.find("tr").length === 0,
             fileChanged = currentFile !== (file ? file.absolute : null);
         if (historyEnabled && (isEmpty || fileChanged || isRefresh)) {
             if ($historyList.length > 0) {
                 $historyList.remove();
             }
             var $spinner = $("<div class='spinner spin large'></div>").appendTo($gitPanel);
             renderHistory(file).then(function (rendered) {
                 $spinner.remove();
                 if (!rendered) {
@@ -368,7 +459,7 @@
         if (!historyEnabled) { HistoryViewer.hide(); }
 
         // Toggle history button
         var globalButtonActive  = historyEnabled && newHistoryMode === "GLOBAL",
             fileButtonActive    = historyEnabled && newHistoryMode === "FILE";
         $gitPanel.find(".git-history-toggle").toggleClass("active", globalButtonActive)
             .attr("title", globalButtonActive ? Strings.TOOLTIP_HIDE_HISTORY : Strings.TOOLTIP_SHOW_HISTORY);

src/extensions/default/Git/src/Remotes.js

@@ -127,6 +127,16 @@ define(function (require) {
                 clearRemotePicker();
             }
         }).catch(function (err) {
+            // Opening a project without a repository still refreshes the panel,
+            // so `git remote -v` lands here reporting there is no repository.
+            // That is the project the user chose, not a fault, and a modal over
+            // the editor for it interrupts them for nothing — drop the picker
+            // and keep the reason in the log.
+            if (ErrorHandler.contains(err, "not a git repository")) {
+                clearRemotePicker();
+                ErrorHandler.logError(err);
+                return;
+            }
             ErrorHandler.showError(err, Strings.ERROR_GETTING_REMOTES);
         });
     }

src/extensions/default/Git/src/git/Git.js

@@ -82,6 +82,10 @@ define(function (require, exports) {
         return GitCli.getHistory(branch, skip, file);
     }
 
+    function getRemoteBranchHead(branch) {
+        return GitCli.getRemoteBranchHead(branch);
+    }
+
     function resetIndex() {
         return GitCli.reset();
     }
@@ -180,6 +184,7 @@ define(function (require, exports) {
     exports.getAllBranches          = getAllBranches;
     exports.getHistory              = getHistory;
     exports.getFileHistory          = getFileHistory;
+    exports.getRemoteBranchHead     = getRemoteBranchHead;
     exports.resetIndex              = resetIndex;
     exports.discardAllChanges       = discardAllChanges;
     exports.getMergeInfo            = getMergeInfo;

src/extensions/default/Git/src/git/GitCli.js

@@ -501,6 +501,76 @@ define(function (require, exports) {
             });
     }
 
+    /**
+     * Where the current branch's counterpart on the remote points right now.
+     *
+     * The configured upstream wins, but a branch pushed with an explicit refspec
+     * often never gets one, so the default remote's branch of the same name
+     * stands in — otherwise history would call a pushed branch local. Resolves
+     * to null when neither ref is there, which is what a branch that has never
+     * been pushed looks like.
+     *
+     * Usually one git call: a single `for-each-ref` reads the branch and that
+     * default-remote ref together, giving the upstream's name and the hash in
+     * the same pass. Only a branch tracking some other ref needs a second.
+     *
+     * @param {string} branch - name of the current branch
+     * @return {Promise<?{ref: string, hash: string}>} null when there is no counterpart
+     */
+    function getRemoteBranchHead(branch) {
+        if (!branch) {
+            return Promise.resolve(null);
+        }
+        const remotes = Preferences.get("defaultRemotes") || {};
+        const remote = remotes[Preferences.get("currentGitRoot")];
+        const guess = remote ? remote + "/" + branch : null;
+        // The full refname disambiguates: a branch really can be called
+        // "origin/ai", and then both rows would answer to the same short name.
+        const localRef = "refs/heads/" + branch;
+        const guessRef = guess ? "refs/remotes/" + guess : null;
+        // "|" is legal in a ref name, so the fields are parted the way
+        // getHistory above does it rather than on a character refs may contain.
+        const separator = "_._";
+        const args = [
+            "for-each-ref",
+            "--format=%(refname)" + separator + "%(upstream:short)" + separator + "%(objectname)",
+            localRef
+        ];
+        if (guessRef) { args.push(guessRef); }
+
+        // One pass over both refs: the branch row carries the upstream's name,
+        // the remote row carries the hash. A ref that is not there prints
+        // nothing rather than failing, so absence needs no special case.
+        return git(args).then(function (stdout) {
+            let upstream = null, guessHash = null;
+            (stdout || "").split("\n").forEach(function (line) {
+                const parts = line.trim().split(separator);
+                if (parts.length < 3) { return; }
+                if (parts[0] === localRef) {
+                    upstream = parts[1] || null;
+                } else if (parts[0] === guessRef) {
+                    guessHash = parts[2] || null;
+                }
+            });
+            if (upstream && upstream !== guess) {
+                // Tracking something other than <remote>/<branch>, so its hash
+                // was not in the pass above. rev-parse resolves it whatever it
+                // is — a remote-tracking ref, or a local branch for `remote = .`
+                return git(["rev-parse", "--verify", "--quiet", upstream])
+                    .then(function (out) {
+                        const hash = (out || "").trim();
+                        return hash ? { ref: upstream, hash: hash } : null;
+                    })
+                    .catch(function () { return null; });
+            }
+            // The upstream is the ref just read, or there is no upstream and the
+            // branch was pushed to its own name; either way the hash is in hand.
+            return guessHash ? { ref: guess, hash: guessHash } : null;
+        }).catch(function () {
+            return null;
+        });
+    }
+
     // Get list of deleted files between two branches
     function getDeletedFiles(oldBranch, newBranch) {
         return git(["diff", "--no-ext-diff", "--name-status", oldBranch + ".." + newBranch])
@@ -1166,6 +1236,7 @@ define(function (require, exports) {
     exports.setUpstreamBranch         = setUpstreamBranch;
     exports.getCurrentBranchName      = getCurrentBranchName;
     exports.getCurrentUpstreamBranch  = getCurrentUpstreamBranch;
+    exports.getRemoteBranchHead       = getRemoteBranchHead;
     exports.getConfig                 = getConfig;
     exports.setConfig                 = setConfig;
     exports.getBranches               = getBranches;