Extracting autocomplete functions...

Extracting autocomplete functions,
Adding autocomplete checks to each cursor

Author: Neko-Box-Coder

internal/action/actions.go

@@ -850,25 +850,23 @@ func (h *BufPane) OutdentSelection() bool {
 func (h *BufPane) Autocomplete() bool {
 	b := h.Buf
 
-	if h.Cursor.HasSelection() {
+	// Don't autocomplete at all if the active cursor cannot be autocomplete
+	if !buffer.AutocompleteCheck(h.Cursor) {
 		return false
 	}
 
-	if h.Cursor.X == 0 {
-		return false
-	}
-	r := h.Cursor.RuneUnder(h.Cursor.X)
-	prev := h.Cursor.RuneUnder(h.Cursor.X - 1)
-	if !util.IsAutocomplete(prev) || util.IsWordChar(r) {
-		// don't autocomplete if cursor is within a word
+	if !b.HasSuggestions && !b.StartAutocomplete(buffer.BufferComplete) {
 		return false
 	}
 
-	if b.HasSuggestions {
-		b.CycleAutocomplete(true)
-		return true
+	prevSuggestion := b.CycleAutocomplete(true)
+	for i := 0; i < b.NumCursors(); i++ {
+		if buffer.AutocompleteCheck(b.GetCursor(i)) {
+			b.PerformSingleAutocomplete(prevSuggestion, b.GetCursor(i))
+		}
 	}
-	return b.Autocomplete(buffer.BufferComplete)
+
+	return true
 }
 
 // CycleAutocompleteBack cycles back in the autocomplete suggestion list
@@ -877,8 +875,14 @@ func (h *BufPane) CycleAutocompleteBack() bool {
 		return false
 	}
 
-	if h.Buf.HasSuggestions {
-		h.Buf.CycleAutocomplete(false)
+	b := h.Buf
+	if b.HasSuggestions {
+		prevSuggestion := b.CycleAutocomplete(false)
+		for i := 0; i < b.NumCursors(); i++ {
+			if buffer.AutocompleteCheck(b.GetCursor(i)) {
+				b.PerformSingleAutocomplete(prevSuggestion, b.GetCursor(i))
+			}
+		}
 		return true
 	}
 	return false

internal/action/infopane.go

@@ -191,30 +191,44 @@ func (h *InfoPane) HistorySearchDown() {
 // Autocomplete begins autocompletion
 func (h *InfoPane) CommandComplete() {
 	b := h.Buf
+	c := b.GetActiveCursor()
+
+	// Cycling commands
+	if !buffer.AutocompleteCheck(c) {
+		return
+	}
 	if b.HasSuggestions {
-		b.CycleAutocomplete(true)
+		prevSuggestion := b.CycleAutocomplete(true)
+		b.PerformSingleAutocomplete(prevSuggestion, c)
 		return
 	}
 
-	c := b.GetActiveCursor()
+	// Otherwise start autocomplete
 	l := b.LineBytes(0)
 	l = util.SliceStart(l, c.X)
-
 	args := bytes.Split(l, []byte{' '})
 	cmd := string(args[0])
 
+	var completer buffer.Completer = nil
+
 	if h.PromptType == "Command" {
 		if len(args) == 1 {
-			b.Autocomplete(CommandComplete)
+			completer = CommandComplete
 		} else if action, ok := commands[cmd]; ok {
-			if action.completer != nil {
-				b.Autocomplete(action.completer)
-			}
+			completer = action.completer
 		}
 	} else {
 		// by default use filename autocompletion
-		b.Autocomplete(buffer.FileComplete)
+		completer = buffer.FileComplete
+	}
+	if completer == nil {
+		return
+	}
+	if !b.StartAutocomplete(completer) {
+		return
 	}
+	prevSuggestion := b.CycleAutocomplete(true)
+	b.PerformSingleAutocomplete(prevSuggestion, c)
 }
 
 // ExecuteCommand completes the prompt

internal/buffer/autocomplete.go

@@ -23,19 +23,33 @@ func (b *Buffer) GetSuggestions() {
 
 }
 
-// Autocomplete starts the autocomplete process
-func (b *Buffer) Autocomplete(c Completer) bool {
+func AutocompleteCheck(cursor *Cursor) bool {
+	if cursor.HasSelection() {
+		return false
+	}
+	if cursor.X == 0 {
+		return false
+	}
+	r := cursor.RuneUnder(cursor.X)
+	prev := cursor.RuneUnder(cursor.X - 1)
+	if !util.IsAutocomplete(prev) || util.IsWordChar(r) {
+		// don't autocomplete if cursor is within a word
+		return false
+	}
+	return true
+}
+
+func (b *Buffer) StartAutocomplete(c Completer) bool {
 	b.Completions, b.Suggestions = c(b)
 	if len(b.Completions) != len(b.Suggestions) || len(b.Completions) == 0 {
 		return false
 	}
 	b.CurSuggestion = -1
-	b.CycleAutocomplete(true)
 	return true
 }
 
-// CycleAutocomplete moves to the next suggestion
-func (b *Buffer) CycleAutocomplete(forward bool) {
+// CycleAutocomplete moves to the next suggestion and return the previous suggestion
+func (b *Buffer) CycleAutocomplete(forward bool) int {
 	prevSuggestion := b.CurSuggestion
 
 	if forward {
@@ -49,24 +63,25 @@ func (b *Buffer) CycleAutocomplete(forward bool) {
 		b.CurSuggestion = len(b.Suggestions) - 1
 	}
 
-	b.performAutoComplete(prevSuggestion)
-
 	if len(b.Suggestions) > 1 {
 		b.HasSuggestions = true
 	}
+
+	return prevSuggestion
 }
 
-func (b *Buffer) performAutoComplete(prevSuggestion int) {
-	for _, cur := range b.cursors {
-		curLoc := cur.Loc
-		curStart := curLoc
-		curEnd := curLoc
+func (b *Buffer) PerformSingleAutocomplete(prevSuggestion int, cursor *Cursor) {
+	curLoc := cursor.Loc
+	curStart := curLoc
+	curEnd := curLoc
 
-		if prevSuggestion < len(b.Suggestions) && prevSuggestion >= 0 {
-			curStart = curEnd.Move(-util.CharacterCountInString(b.Completions[prevSuggestion]), b)
-		}
-		b.Replace(curStart, curEnd, b.Completions[b.CurSuggestion])
+	if prevSuggestion < len(b.Suggestions) && prevSuggestion >= 0 {
+		curStart = curEnd.Move(-util.CharacterCountInString(b.Completions[prevSuggestion]), b)
 	}
+
+	hasSuggestions := b.HasSuggestions
+	b.Replace(curStart, curEnd, b.Completions[b.CurSuggestion])
+	b.HasSuggestions = hasSuggestions
 }
 
 // GetWord gets the most recent word separated by any separator