Merge pull request #11101 from atom/emit-status-changes-when-anything-changes

Emit status changes when anything changes

spec/git-repository-async-spec.js

@@ -422,6 +422,44 @@ describe('GitRepositoryAsync', () => {
       expect(repo.isStatusModified(status)).toBe(true)
       expect(repo.isStatusNew(status)).toBe(false)
     })
+
+    it('emits did-change-statuses if the status changes', async () => {
+      const someNewPath = path.join(workingDirectory, 'MyNewJSFramework.md')
+      fs.writeFileSync(someNewPath, '')
+
+      const statusHandler = jasmine.createSpy('statusHandler')
+      repo.onDidChangeStatuses(statusHandler)
+
+      await repo.refreshStatus()
+
+      waitsFor('the onDidChangeStatuses handler to be called', () => statusHandler.callCount > 0)
+    })
+
+    it('emits did-change-statuses if the branch changes', async () => {
+      const statusHandler = jasmine.createSpy('statusHandler')
+      repo.onDidChangeStatuses(statusHandler)
+
+      repo._refreshBranch = jasmine.createSpy('_refreshBranch').andCallFake(() => {
+        return Promise.resolve(true)
+      })
+
+      await repo.refreshStatus()
+
+      waitsFor('the onDidChangeStatuses handler to be called', () => statusHandler.callCount > 0)
+    })
+
+    it('emits did-change-statuses if the ahead/behind changes', async () => {
+      const statusHandler = jasmine.createSpy('statusHandler')
+      repo.onDidChangeStatuses(statusHandler)
+
+      repo._refreshAheadBehindCount = jasmine.createSpy('_refreshAheadBehindCount').andCallFake(() => {
+        return Promise.resolve(true)
+      })
+
+      await repo.refreshStatus()
+
+      waitsFor('the onDidChangeStatuses handler to be called', () => statusHandler.callCount > 0)
+    })
   })
 
   describe('.isProjectAtRoot()', () => {
@@ -676,7 +714,7 @@ describe('GitRepositoryAsync', () => {
         repo = GitRepositoryAsync.open(workingDirectory)
       })
 
-      it('returns 0, 0 for a branch with no upstream', async () => {
+      it('returns 1, 0 for a branch which is ahead by 1', async () => {
         await repo.refreshStatus()
 
         const {ahead, behind} = await repo.getCachedUpstreamAheadBehindCount('You-Dont-Need-jQuery')

src/git-repository-async.js

@@ -783,12 +783,17 @@ export default class GitRepositoryAsync {
 
   // Get the current branch and update this.branch.
   //
-  // Returns a {Promise} which resolves to the {String} branch name.
+  // Returns a {Promise} which resolves to a {boolean} indicating whether the
+  // branch name changed.
   _refreshBranch () {
     return this.getRepo()
       .then(repo => repo.getCurrentBranch())
       .then(ref => ref.name())
-      .then(branchName => this.branch = branchName)
+      .then(branchName => {
+        const changed = branchName !== this.branch
+        this.branch = branchName
+        return changed
+      })
   }
 
   // Refresh the cached ahead/behind count with the given branch.
@@ -796,10 +801,15 @@ export default class GitRepositoryAsync {
   // * `branchName` The {String} name of the branch whose ahead/behind should be
   //                used for the refresh.
   //
-  // Returns a {Promise} which will resolve to {null}.
+  // Returns a {Promise} which will resolve to a {boolean} indicating whether
+  // the ahead/behind count changed.
   _refreshAheadBehindCount (branchName) {
     return this.getAheadBehindCount(branchName)
-      .then(counts => this.upstream = counts)
+      .then(counts => {
+        const changed = !_.isEqual(counts, this.upstream)
+        this.upstream = counts
+        return changed
+      })
   }
 
   // Get the status for this repository.
@@ -905,15 +915,15 @@ export default class GitRepositoryAsync {
 
   // Refresh the cached status.
   //
-  // Returns a {Promise} which will resolve to {null}.
+  // Returns a {Promise} which will resolve to a {boolean} indicating whether
+  // any statuses changed.
   _refreshStatus () {
     return Promise.all([this._getRepositoryStatus(), this._getSubmoduleStatuses()])
       .then(([repositoryStatus, submoduleStatus]) => {
         const statusesByPath = _.extend({}, repositoryStatus, submoduleStatus)
-        if (!_.isEqual(this.pathStatusCache, statusesByPath) && this.emitter != null) {
-          this.emitter.emit('did-change-statuses')
-        }
+        const changed = !_.isEqual(this.pathStatusCache, statusesByPath)
         this.pathStatusCache = statusesByPath
+        return changed
       })
   }
 
@@ -923,11 +933,17 @@ export default class GitRepositoryAsync {
   refreshStatus () {
     const status = this._refreshStatus()
     const branch = this._refreshBranch()
-    const aheadBehind = branch.then(branchName => this._refreshAheadBehindCount(branchName))
+    const aheadBehind = branch.then(() => this._refreshAheadBehindCount(this.branch))
 
     this._refreshingPromise = this._refreshingPromise.then(_ => {
       return Promise.all([status, branch, aheadBehind])
-        .then(_ => null)
+        .then(([statusChanged, branchChanged, aheadBehindChanged]) => {
+          if (this.emitter && (statusChanged || branchChanged || aheadBehindChanged)) {
+            this.emitter.emit('did-change-statuses')
+          }
+
+          return null
+        })
         // Because all these refresh steps happen asynchronously, it's entirely
         // possible the repository was destroyed while we were working. In which
         // case we should just swallow the error.