Changed Pane and TextEditor specs to match new pending behavior

spec/pane-spec.coffee

@@ -18,8 +18,8 @@ describe "Pane", ->
     onDidDestroy: (fn) -> @emitter.on('did-destroy', fn)
     destroy: -> @destroyed = true; @emitter.emit('did-destroy')
     isDestroyed: -> @destroyed
-    isPending: -> @pending
-    pending: false
+    onDidTerminatePendingState: (callback) -> @emitter.on 'terminate-pending-state', callback
+    terminatePendingState: -> @emitter.emit 'terminate-pending-state'
 
   beforeEach ->
     confirm = spyOn(atom.applicationDelegate, 'confirm')
@@ -136,10 +136,8 @@ describe "Pane", ->
       pane = new Pane(paneParams(items: []))
       itemA = new Item("A")
       itemB = new Item("B")
-      itemA.pending = true
-      itemB.pending = true
-      pane.addItem(itemA)
-      pane.addItem(itemB)
+      pane.addItem(itemA, undefined, false, true)
+      pane.addItem(itemB, undefined, false, true)
       expect(itemA.isDestroyed()).toBe true
 
   describe "::activateItem(item)", ->
@@ -172,19 +170,17 @@ describe "Pane", ->
       beforeEach ->
         itemC = new Item("C")
         itemD = new Item("D")
-        itemC.pending = true
-        itemD.pending = true
 
       it "replaces the active item if it is pending", ->
-        pane.activateItem(itemC)
+        pane.activateItem(itemC, true)
         expect(pane.getItems().map (item) -> item.name).toEqual ['A', 'C', 'B']
-        pane.activateItem(itemD)
+        pane.activateItem(itemD, true)
         expect(pane.getItems().map (item) -> item.name).toEqual ['A', 'D', 'B']
 
       it "adds the item after the active item if it is not pending", ->
-        pane.activateItem(itemC)
+        pane.activateItem(itemC, true)
         pane.activateItemAtIndex(2)
-        pane.activateItem(itemD)
+        pane.activateItem(itemD, true)
         expect(pane.getItems().map (item) -> item.name).toEqual ['A', 'B', 'D']
 
   describe "::activateNextItem() and ::activatePreviousItem()", ->
@@ -806,6 +802,67 @@ describe "Pane", ->
         pane2.destroy()
         expect(container.root).toBe pane1
 
+  describe "pending state", ->
+    editor1 = null
+    pane = null
+    eventCount = null
+
+    beforeEach ->
+      waitsForPromise ->
+        atom.workspace.open('sample.txt', pending: true).then (o) ->
+          editor1 = o
+          pane = atom.workspace.getActivePane()
+
+      runs ->
+        eventCount = 0
+        editor1.onDidTerminatePendingState -> eventCount++
+
+    it "does not open file in pending state by default", ->
+      waitsForPromise ->
+        atom.workspace.open('sample.js').then (o) ->
+          editor1 = o
+          pane = atom.workspace.getActivePane()
+
+      runs ->
+        expect(pane.getPendingItem()).toBeNull()
+
+    it "opens file in pending state if 'pending' option is true", ->
+      expect(pane.getPendingItem()).toEqual editor1
+
+    it "terminates pending state if ::terminatePendingState is invoked", ->
+      editor1.terminatePendingState()
+
+      expect(pane.getPendingItem()).toBeNull()
+      expect(eventCount).toBe 1
+
+    it "terminates pending state when buffer is changed", ->
+      editor1.insertText('I\'ll be back!')
+      advanceClock(editor1.getBuffer().stoppedChangingDelay)
+
+      expect(pane.getPendingItem()).toBeNull()
+      expect(eventCount).toBe 1
+
+    it "only calls terminate handler once when text is modified twice", ->
+      editor1.insertText('Some text')
+      advanceClock(editor1.getBuffer().stoppedChangingDelay)
+
+      editor1.save()
+
+      editor1.insertText('More text')
+      advanceClock(editor1.getBuffer().stoppedChangingDelay)
+
+      expect(pane.getPendingItem()).toBeNull()
+      expect(eventCount).toBe 1
+
+    it "only calls clearPendingItem if there is a pending item to clear", ->
+      spyOn(pane, "clearPendingItem").andCallThrough()
+
+      editor1.terminatePendingState()
+      editor1.terminatePendingState()
+
+      expect(pane.getPendingItem()).toBeNull()
+      expect(pane.clearPendingItem.callCount).toBe 1
+
   describe "serialization", ->
     pane = null
 

spec/text-editor-spec.coffee

@@ -55,16 +55,6 @@ describe "TextEditor", ->
 
       expect(editor.tokenizedLineForScreenRow(0).invisibles.eol).toBe '?'
 
-    it "restores pending tabs in pending state", ->
-      expect(editor.isPending()).toBe false
-      editor2 = TextEditor.deserialize(editor.serialize(), atom)
-      expect(editor2.isPending()).toBe false
-
-      pendingEditor = atom.workspace.buildTextEditor(pending: true)
-      expect(pendingEditor.isPending()).toBe true
-      editor3 = TextEditor.deserialize(pendingEditor.serialize(), atom)
-      expect(editor3.isPending()).toBe true
-
   describe "when the editor is constructed with the largeFileMode option set to true", ->
     it "loads the editor but doesn't tokenize", ->
       editor = null
@@ -5827,53 +5817,3 @@ describe "TextEditor", ->
           screenRange: marker1.getRange(),
           rangeIsReversed: false
         }
-
-  describe "pending state", ->
-    editor1 = null
-    eventCount = null
-
-    beforeEach ->
-      waitsForPromise ->
-        atom.workspace.open('sample.txt', pending: true).then (o) -> editor1 = o
-
-      runs ->
-        eventCount = 0
-        editor1.onDidTerminatePendingState -> eventCount++
-
-    it "does not open file in pending state by default", ->
-      expect(editor.isPending()).toBe false
-
-    it "opens file in pending state if 'pending' option is true", ->
-      expect(editor1.isPending()).toBe true
-
-    it "terminates pending state if ::terminatePendingState is invoked", ->
-      editor1.terminatePendingState()
-
-      expect(editor1.isPending()).toBe false
-      expect(eventCount).toBe 1
-
-    it "terminates pending state when buffer is changed", ->
-      editor1.insertText('I\'ll be back!')
-      advanceClock(editor1.getBuffer().stoppedChangingDelay)
-
-      expect(editor1.isPending()).toBe false
-      expect(eventCount).toBe 1
-
-    it "only calls terminate handler once when text is modified twice", ->
-      editor1.insertText('Some text')
-      advanceClock(editor1.getBuffer().stoppedChangingDelay)
-
-      editor1.save()
-
-      editor1.insertText('More text')
-      advanceClock(editor1.getBuffer().stoppedChangingDelay)
-
-      expect(editor1.isPending()).toBe false
-      expect(eventCount).toBe 1
-
-    it "only calls terminate handler once when terminatePendingState is called twice", ->
-      editor1.terminatePendingState()
-      editor1.terminatePendingState()
-
-      expect(editor1.isPending()).toBe false
-      expect(eventCount).toBe 1

src/text-editor.coffee

@@ -111,7 +111,7 @@ class TextEditor extends Model
     @cursors = []
     @cursorsByMarkerId = new Map
     @selections = []
-    @bufferHasChanged = false
+    @hasTerminatedPendingState = false
 
     buffer ?= new TextBuffer
     @displayBuffer ?= new DisplayBuffer({
@@ -152,7 +152,6 @@ class TextEditor extends Model
     firstVisibleScreenColumn: @getFirstVisibleScreenColumn()
     displayBuffer: @displayBuffer.serialize()
     selectionsMarkerLayerId: @selectionsMarkerLayer.id
-    bufferHasChanged: @bufferHasChanged
 
   subscribeToBuffer: ->
     @buffer.retain()
@@ -165,10 +164,14 @@ class TextEditor extends Model
       @emitter.emit 'did-change-encoding', @getEncoding()
     @disposables.add @buffer.onDidDestroy => @destroy()
     @disposables.add @buffer.onDidChangeModified =>
-      @emitter.emit 'did-terminate-pending-state'
+      @terminatePendingState() if @buffer.isModified()
 
     @preserveCursorPositionOnBufferReload()
 
+  terminatePendingState: ->
+    @emitter.emit 'did-terminate-pending-state' if not @hasTerminatedPendingState
+    @hasTerminatedPendingState = true
+
   onDidTerminatePendingState: (callback) ->
     @emitter.on 'did-terminate-pending-state', callback