Add character insertion timeouts, overlapping matches

* Handle overlapping partial matches for the same binding
* Enable timeouts when first keystroke of a partial match corresponds to a character insertion

Signed-off-by: Nathan Sobo <nathan@github.com>

Author: maxbrunsfeld

spec/keymap-manager-spec.coffee

@@ -191,6 +191,7 @@ describe "KeymapManager", ->
           '.editor.visual-mode': 'i w': 'select-inside-word'
 
         events = []
+        editor.addEventListener 'textInput', (event) -> events.push("input:#{event.data}")
         workspace.addEventListener 'dog', -> events.push('dog')
         workspace.addEventListener 'viva!', -> events.push('viva!')
         workspace.addEventListener 'viv', -> events.push('viv')
@@ -222,27 +223,15 @@ describe "KeymapManager", ->
           expect(vEvent.defaultPrevented).toBe true
           expect(iEvent.defaultPrevented).toBe true
           expect(kEvent.defaultPrevented).toBe false
-          expect(events).toEqual ['enter-visual-mode']
+          expect(events).toEqual ['enter-visual-mode', 'input:i']
           expect(clearTimeout).toHaveBeenCalled()
 
         it "dispatches a text-input event for any replayed keyboard events that would have inserted characters", ->
-          textInputCharacters = []
-          editor.addEventListener 'textInput', (event) -> textInputCharacters.push(event.data)
-
-          keymapManager.handleKeyboardEvent(buildKeydownEvent('v', target: editor))
-          keymapManager.handleKeyboardEvent(buildKeydownEvent('i', target: editor))
-          keymapManager.handleKeyboardEvent(lastEvent = buildKeydownEvent('k', target: editor))
-
-          expect(textInputCharacters).toEqual ['i']
-          expect(lastEvent.defaultPrevented).toBe false # inserted as normal
-
-          textInputCharacters = []
-
           keymapManager.handleKeyboardEvent(buildKeydownEvent('d', target: editor))
           keymapManager.handleKeyboardEvent(buildKeydownEvent('o', target: editor))
           keymapManager.handleKeyboardEvent(lastEvent = buildKeydownEvent('q', target: editor))
 
-          expect(textInputCharacters).toEqual ['d', 'o']
+          expect(events).toEqual ['input:d', 'input:o']
           expect(lastEvent.defaultPrevented).toBe false # inserted as normal
 
       describe "when the currently queued keystrokes exactly match at least one binding", ->
@@ -257,7 +246,7 @@ describe "KeymapManager", ->
           keymapManager.handleKeyboardEvent(buildKeydownEvent('i', target: editor))
           expect(events).toEqual []
           advanceClock(keymapManager.getPartialMatchTimeout())
-          expect(events).toEqual ['enter-visual-mode']
+          expect(events).toEqual ['enter-visual-mode', 'input:i']
 
           events = []
           keymapManager.handleKeyboardEvent(buildKeydownEvent('v', target: editor))
@@ -275,17 +264,31 @@ describe "KeymapManager", ->
           expect(global.setTimeout).not.toHaveBeenCalled()
           expect(keymapManager.queuedKeyboardEvents.length).toBe 0
 
+      describe "when the first queued keystroke corresponds to a character insertion", ->
+        it "disables partially-matching bindings and replays the queued keystrokes if the ::partialMatchTimeout expires", ->
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('d', target: editor))
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('o', target: editor))
+          advanceClock(keymapManager.getPartialMatchTimeout())
+
+          expect(events).toEqual ['input:d', 'input:o']
+
       describe "when the currently queued keystrokes don't exactly match any bindings", ->
         it "never times out of the pending state", ->
-          keymapManager.handleKeyboardEvent(buildKeydownEvent('d', target: editor))
+          keymapManager.add 'test',
+            '.workspace':
+              'ctrl-d o g': 'control-dog'
+
+          workspace.addEventListener 'control-dog', -> events.push('control-dog')
+
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('ctrl-d', target: editor))
           keymapManager.handleKeyboardEvent(buildKeydownEvent('o', target: editor))
 
           advanceClock(keymapManager.getPartialMatchTimeout())
           advanceClock(keymapManager.getPartialMatchTimeout())
 
           expect(events).toEqual []
           keymapManager.handleKeyboardEvent(buildKeydownEvent('g', target: editor))
-          expect(events).toEqual ['dog']
+          expect(events).toEqual ['control-dog']
 
       describe "when the partially matching bindings all map to the 'unset!' directive", ->
         it "ignores the 'unset!' bindings and invokes the command associated with the matching binding as normal", ->
@@ -298,6 +301,16 @@ describe "KeymapManager", ->
 
           expect(events).toEqual ['enter-visual-mode']
 
+      describe "when a subsequent keystroke begins a new match of an already pending binding", ->
+        it "recognizes the match", ->
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('d', target: editor))
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('o', target: editor))
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('d', target: editor))
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('o', target: editor))
+          keymapManager.handleKeyboardEvent(buildKeydownEvent('g', target: editor))
+
+          expect(events).toEqual ['input:d', 'input:o', 'dog']
+
     it "only counts entire keystrokes when checking for partial matches", ->
       element = $$ -> @div class: 'a'
       keymapManager.add 'test',

src/keymap-manager.coffee

@@ -389,7 +389,7 @@ class KeymapManager
   # target is `.defaultTarget` if that property is assigned on the keymap.
   #
   # * `event` A `KeyboardEvent` of type 'keydown'
-  handleKeyboardEvent: (event, replaying) ->
+  handleKeyboardEvent: (event) ->
     keystroke = @keystrokeForKeyboardEvent(event)
 
     if @queuedKeystrokes.length > 0 and isAtomModifier(keystroke)
@@ -453,7 +453,12 @@ class KeymapManager
     # keystroke.
     if partialMatches.length > 0
       event.preventDefault()
-      enableTimeout = foundMatch ? @pendingStateTimeoutHandle?
+      enableTimeout = (
+        @pendingStateTimeoutHandle? or
+        foundMatch or
+        characterForKeyboardEvent(@queuedKeyboardEvents[0])?
+      )
+
       @enterPendingState(partialMatches, enableTimeout)
       @emitter.emit 'did-partially-match-binding', {
         keystrokes,
@@ -556,7 +561,7 @@ class KeymapManager
     @cancelPendingState() if @pendingStateTimeoutHandle?
     @pendingPartialMatches = pendingPartialMatches
     if enableTimeout
-      @pendingStateTimeoutHandle = setTimeout(@terminatePendingState.bind(this), @partialMatchTimeout)
+      @pendingStateTimeoutHandle = setTimeout(@terminatePendingState.bind(this, true), @partialMatchTimeout)
 
   cancelPendingState: ->
     clearTimeout(@pendingStateTimeoutHandle)
@@ -568,16 +573,26 @@ class KeymapManager
   # It disables the longest of the pending partially matching bindings, then
   # replays the queued keyboard events to allow any bindings with shorter
   # keystroke sequences to be matched unambiguously.
-  terminatePendingState: ->
+  terminatePendingState: (timeout) ->
     bindingsToDisable = @pendingPartialMatches
     eventsToReplay = @queuedKeyboardEvents
 
     @cancelPendingState()
     @clearQueuedKeystrokes()
 
     binding.enabled = false for binding in bindingsToDisable
-    @handleKeyboardEvent(event, true) for event in eventsToReplay
-    binding.enabled = true for binding in bindingsToDisable
+
+    for event in eventsToReplay
+      @handleKeyboardEvent(event)
+      if bindingsToDisable? and not @pendingPartialMatches?
+        binding.enabled = true for binding in bindingsToDisable
+        bindingsToDisable = null
+
+    atom?.assert(not bindingsToDisable?, "Invalid keymap state")
+
+    if timeout and @pendingPartialMatches?
+      @terminatePendingState(true)
+
     return
 
   # After we match a binding, we call this method to dispatch a custom event