mirror of
https://github.com/Kyren223/eko.git
synced 2025-09-13 16:58:21 +00:00
1337 lines
28 KiB
Go
1337 lines
28 KiB
Go
package viminput
|
|
|
|
import (
|
|
"slices"
|
|
"strings"
|
|
"unicode"
|
|
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/kyren223/eko/internal/client/ui/colors"
|
|
"github.com/kyren223/eko/pkg/assert"
|
|
)
|
|
|
|
var DefaultCursorStyle = lipgloss.NewStyle().Background(colors.White).Foreground(colors.Background)
|
|
|
|
type (
|
|
LineDecoration = func(lnum int, m Model) string
|
|
)
|
|
|
|
const (
|
|
Unchanged = -1
|
|
InvalidGoal = -1
|
|
NullChar = 0
|
|
)
|
|
|
|
const (
|
|
NormalMode = iota
|
|
InsertMode
|
|
VisualMode
|
|
VisualLineMode
|
|
OpendingMode
|
|
)
|
|
|
|
type Model struct {
|
|
PlaceholderStyle lipgloss.Style
|
|
PromptStyle lipgloss.Style
|
|
|
|
Placeholder string
|
|
LineDecoration LineDecoration
|
|
|
|
register string
|
|
lines [][]rune
|
|
cursorLine int
|
|
cursorColumn int
|
|
goalColumn int
|
|
mode int
|
|
pending byte
|
|
gmod bool
|
|
fchar byte
|
|
fmod byte
|
|
tlast bool
|
|
imod bool // only in O-pending
|
|
amod bool // only in O-pending
|
|
|
|
focus bool
|
|
width int
|
|
height int
|
|
}
|
|
|
|
func New(width, height int) Model {
|
|
return Model{
|
|
PlaceholderStyle: lipgloss.NewStyle(),
|
|
PromptStyle: lipgloss.NewStyle(),
|
|
Placeholder: "",
|
|
LineDecoration: EmptyLineDecoration,
|
|
register: "\nHMM\nYO",
|
|
lines: [][]rune{[]rune("")},
|
|
cursorLine: 0,
|
|
cursorColumn: 0,
|
|
goalColumn: InvalidGoal,
|
|
mode: NormalMode,
|
|
pending: NullChar,
|
|
gmod: false,
|
|
fchar: NullChar,
|
|
fmod: NullChar,
|
|
tlast: false,
|
|
imod: false,
|
|
amod: false,
|
|
focus: false,
|
|
width: width,
|
|
height: height,
|
|
}
|
|
}
|
|
|
|
func (m Model) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (m Model) View() string {
|
|
var lines [][]rune
|
|
if len(m.lines) == 0 {
|
|
placeholder := m.PlaceholderStyle.Render(m.Placeholder)
|
|
lines = append(lines, []rune(placeholder))
|
|
} else {
|
|
lines = m.lines
|
|
}
|
|
|
|
var builder strings.Builder
|
|
for i, line := range lines {
|
|
lineDecoration := m.LineDecoration(i, m)
|
|
builder.WriteString(lineDecoration)
|
|
|
|
if m.cursorLine != i {
|
|
builder.WriteString(string(line))
|
|
} else if m.cursorColumn == len(m.lines[m.cursorLine]) {
|
|
builder.WriteString(string(line))
|
|
builder.WriteString(DefaultCursorStyle.Render(" "))
|
|
} else {
|
|
builder.WriteString(string(line[:m.cursorColumn]))
|
|
builder.WriteString(DefaultCursorStyle.Render(string(line[m.cursorColumn])))
|
|
builder.WriteString(string(line[m.cursorColumn+1:]))
|
|
}
|
|
|
|
builder.WriteByte('\n')
|
|
}
|
|
|
|
result := builder.String()
|
|
result = lipgloss.NewStyle().Width(m.width).Height(m.height).Render(result)
|
|
|
|
return result
|
|
}
|
|
|
|
func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
|
|
if !m.focus {
|
|
return m, nil
|
|
}
|
|
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
m.handleKeys(msg)
|
|
return m, nil
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m *Model) SetWidth(width int) {
|
|
m.width = width
|
|
}
|
|
|
|
func (m Model) Width() int {
|
|
return m.width
|
|
}
|
|
|
|
func (m *Model) SetHeight(height int) {
|
|
m.height = height
|
|
}
|
|
|
|
func (m Model) Height() int {
|
|
return m.height
|
|
}
|
|
|
|
func (m *Model) Focus() {
|
|
m.focus = true
|
|
}
|
|
|
|
func (m *Model) Blur() {
|
|
m.focus = false
|
|
}
|
|
|
|
func (m *Model) SetLines(lines ...[]rune) {
|
|
m.lines = lines
|
|
}
|
|
|
|
func (m *Model) Lines() [][]rune {
|
|
return m.lines
|
|
}
|
|
|
|
func (m *Model) SetCursorColumn(col int) {
|
|
if len(m.lines[m.cursorLine]) == 0 {
|
|
m.cursorColumn = 0
|
|
} else {
|
|
m.cursorColumn = max(col, 0)
|
|
}
|
|
m.goalColumn = InvalidGoal
|
|
}
|
|
|
|
func (m *Model) SetCursorLine(line int) {
|
|
m.cursorLine = min(max(line, 0), len(m.lines)-1)
|
|
fromLength := m.cursorColumn
|
|
toLength := len(m.lines[m.cursorLine])
|
|
// In visual it's fine to be after the char
|
|
if m.mode == NormalMode {
|
|
toLength-- // In normal it's not (unless length == 0)
|
|
}
|
|
if fromLength > toLength && m.goalColumn == InvalidGoal {
|
|
m.goalColumn = fromLength
|
|
}
|
|
if m.goalColumn != InvalidGoal {
|
|
m.cursorColumn = max(min(toLength, m.goalColumn), 0)
|
|
}
|
|
}
|
|
|
|
func (m *Model) handleKeys(key tea.KeyMsg) {
|
|
switch m.mode {
|
|
case NormalMode:
|
|
m.handleNormalModeKeys(key)
|
|
case InsertMode:
|
|
m.handleInsertModeKeys(key)
|
|
case OpendingMode:
|
|
m.handleOpendingModeKeys(key)
|
|
}
|
|
}
|
|
|
|
func (m *Model) handleNormalModeKeys(key tea.KeyMsg) {
|
|
line, col := m.Motion(key.String())
|
|
if line != Unchanged || col != Unchanged {
|
|
if line != Unchanged {
|
|
m.SetCursorLine(line)
|
|
}
|
|
if col != Unchanged {
|
|
length := len(m.lines[m.cursorLine]) - 1
|
|
m.SetCursorColumn(min(col, length))
|
|
}
|
|
return
|
|
}
|
|
|
|
switch key.String() {
|
|
case "d":
|
|
fallthrough
|
|
case "y":
|
|
fallthrough
|
|
case "c":
|
|
m.mode = OpendingMode
|
|
m.pending = key.String()[0]
|
|
|
|
case "i":
|
|
m.mode = InsertMode
|
|
case "a":
|
|
m.mode = InsertMode
|
|
m.SetCursorColumn(m.cursorColumn + 1)
|
|
case "I":
|
|
_, col := m.Motion("_")
|
|
assert.Assert(col != -1, "Motion should exist", "motion", "_")
|
|
m.SetCursorColumn(col)
|
|
m.mode = InsertMode
|
|
case "A":
|
|
m.mode = InsertMode
|
|
m.SetCursorColumn(len(m.lines[m.cursorLine]))
|
|
|
|
case "x":
|
|
line := m.lines[m.cursorLine]
|
|
if len(line) != 0 {
|
|
m.Yank(string(line[m.cursorColumn : m.cursorColumn+1]))
|
|
copy(line[m.cursorColumn:], line[m.cursorColumn+1:])
|
|
m.lines[m.cursorLine] = line[:len(line)-1]
|
|
if m.cursorColumn == len(line)-1 {
|
|
m.SetCursorColumn(m.cursorColumn - 1)
|
|
}
|
|
}
|
|
case "C":
|
|
m.mode = InsertMode
|
|
fallthrough
|
|
case "D":
|
|
line := m.lines[m.cursorLine]
|
|
if len(line) != 0 {
|
|
m.Yank(string(line[m.cursorColumn:]))
|
|
m.lines[m.cursorLine] = line[:m.cursorColumn]
|
|
m.SetCursorColumn(m.cursorColumn - 1)
|
|
}
|
|
case "Y":
|
|
line := m.lines[m.cursorLine]
|
|
m.Yank(string(line[m.cursorColumn:]))
|
|
|
|
case "o":
|
|
m.lines = slices.Insert(m.lines, m.cursorLine+1, []rune(""))
|
|
m.SetCursorLine(m.cursorLine + 1)
|
|
m.SetCursorColumn(0)
|
|
m.mode = InsertMode
|
|
case "O":
|
|
m.lines = slices.Insert(m.lines, m.cursorLine, []rune(""))
|
|
m.SetCursorColumn(0)
|
|
m.mode = InsertMode
|
|
|
|
case "p":
|
|
paste := m.Paste()
|
|
newline := paste[len(paste)-1] == '\n'
|
|
if newline {
|
|
paste = paste[:len(paste)-1]
|
|
}
|
|
lines := strings.Split(paste, "\n")
|
|
|
|
line := m.lines[m.cursorLine]
|
|
|
|
if len(lines) == 1 && !newline {
|
|
pastedLine := []rune(lines[0])
|
|
if m.cursorColumn+1 >= len(line) {
|
|
m.lines[m.cursorLine] = append(line, pastedLine...)
|
|
} else {
|
|
m.lines[m.cursorLine] = slices.Insert(line, m.cursorColumn+1, pastedLine...)
|
|
}
|
|
if len(line) == 0 {
|
|
m.SetCursorColumn(m.cursorColumn - 1)
|
|
}
|
|
m.SetCursorColumn(m.cursorColumn + len(pastedLine))
|
|
} else if newline {
|
|
var runeLines [][]rune
|
|
for _, line := range lines {
|
|
runeLines = append(runeLines, []rune(line))
|
|
}
|
|
|
|
m.lines = slices.Insert(m.lines, m.cursorLine+1, runeLines...)
|
|
|
|
m.SetCursorLine(m.cursorLine + 1)
|
|
_, col := m.Motion("_")
|
|
m.SetCursorColumn(col)
|
|
} else {
|
|
var runeLines [][]rune
|
|
for _, line := range lines {
|
|
runeLines = append(runeLines, []rune(line))
|
|
}
|
|
|
|
splittingCol := min(m.cursorColumn+1, len(line))
|
|
line := m.lines[m.cursorLine]
|
|
after := line[splittingCol:]
|
|
lastLine := len(runeLines) - 1
|
|
runeLines[lastLine] = append(runeLines[lastLine], after...)
|
|
|
|
m.lines[m.cursorLine] = append(line[:splittingCol], runeLines[0]...)
|
|
m.lines = slices.Insert(m.lines, m.cursorLine+1, runeLines[1:]...)
|
|
|
|
m.SetCursorColumn(min(splittingCol, len(m.lines[m.cursorLine])-1))
|
|
}
|
|
case "P":
|
|
paste := m.Paste()
|
|
newline := paste[len(paste)-1] == '\n'
|
|
if newline {
|
|
paste = paste[:len(paste)-1]
|
|
}
|
|
|
|
lines := strings.Split(paste, "\n")
|
|
line := m.lines[m.cursorLine]
|
|
if len(lines) == 1 && !newline {
|
|
pastedLine := []rune(lines[0])
|
|
m.lines[m.cursorLine] = slices.Insert(line, m.cursorColumn, pastedLine...)
|
|
m.SetCursorColumn(m.cursorColumn + len(pastedLine) - 1)
|
|
} else if newline {
|
|
var runeLines [][]rune
|
|
for _, line := range lines {
|
|
runeLines = append(runeLines, []rune(line))
|
|
}
|
|
m.lines = slices.Insert(m.lines, m.cursorLine, runeLines...)
|
|
m.SetCursorLine(m.cursorLine)
|
|
_, col := m.Motion("_")
|
|
m.SetCursorColumn(col)
|
|
} else {
|
|
// TODO:
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m *Model) handleInsertModeKeys(key tea.KeyMsg) {
|
|
if key.Type == tea.KeyEscape {
|
|
m.SetCursorColumn(m.cursorColumn - 1)
|
|
m.mode = NormalMode
|
|
return
|
|
}
|
|
|
|
if key.Type == tea.KeyBackspace {
|
|
line := m.lines[m.cursorLine]
|
|
if m.cursorColumn == 0 && m.cursorLine != 0 {
|
|
lineBefore := m.lines[m.cursorLine-1]
|
|
cursorColumn := len(lineBefore)
|
|
|
|
m.lines = slices.Delete(m.lines, m.cursorLine, m.cursorLine+1)
|
|
m.lines[m.cursorLine-1] = append(lineBefore, line...)
|
|
|
|
m.SetCursorLine(m.cursorLine - 1)
|
|
m.SetCursorColumn(cursorColumn)
|
|
} else if len(line) != 0 {
|
|
m.lines[m.cursorLine] = slices.Delete(line, m.cursorColumn-1, m.cursorColumn)
|
|
m.SetCursorColumn(m.cursorColumn - 1)
|
|
}
|
|
return
|
|
}
|
|
|
|
if key.Type == tea.KeyEnter {
|
|
line := m.lines[m.cursorLine]
|
|
after := line[m.cursorColumn:]
|
|
m.lines[m.cursorLine] = line[:m.cursorColumn]
|
|
|
|
var newline []rune
|
|
newline = append(newline, after...)
|
|
m.lines = slices.Insert(m.lines, m.cursorLine+1, newline)
|
|
|
|
m.SetCursorLine(m.cursorLine + 1)
|
|
m.SetCursorColumn(0)
|
|
|
|
return
|
|
}
|
|
|
|
keyStr := key.String()
|
|
length := len(keyStr)
|
|
if length == 1 && 32 <= keyStr[0] && keyStr[0] <= 126 {
|
|
line := m.lines[m.cursorLine]
|
|
m.lines[m.cursorLine] = slices.Insert(line, m.cursorColumn, rune(keyStr[0]))
|
|
m.SetCursorColumn(m.cursorColumn + 1)
|
|
}
|
|
}
|
|
|
|
func (m *Model) RuneAtCursor() rune {
|
|
return m.lines[m.cursorLine][m.cursorColumn]
|
|
}
|
|
|
|
func (m *Model) Motion(motion string) (line, col int) {
|
|
if motion == "g" && !m.gmod {
|
|
m.gmod = true
|
|
return Unchanged, Unchanged
|
|
} else if m.gmod {
|
|
m.gmod = false
|
|
motion = "g" + motion
|
|
} else {
|
|
m.gmod = false
|
|
}
|
|
|
|
isF := motion == "f" || motion == "t" || motion == "F" || motion == "T"
|
|
if isF && m.fmod == NullChar {
|
|
m.fmod = motion[0]
|
|
return Unchanged, Unchanged
|
|
}
|
|
if m.fmod != NullChar {
|
|
defer func(m *Model) { m.fmod = NullChar }(m)
|
|
|
|
if len(motion) != 1 {
|
|
return Unchanged, Unchanged
|
|
}
|
|
m.fchar = motion[0]
|
|
|
|
dir := 1
|
|
if m.fmod == 'F' || m.fmod == 'T' {
|
|
dir = -1
|
|
}
|
|
line := m.lines[m.cursorLine]
|
|
i := m.cursorColumn + dir
|
|
|
|
index, ok := SearchChar(line, i, dir, rune(m.fchar))
|
|
if !ok {
|
|
return Unchanged, Unchanged
|
|
}
|
|
|
|
if m.fmod == 't' || m.fmod == 'T' {
|
|
index -= dir
|
|
m.tlast = true
|
|
} else {
|
|
m.tlast = false
|
|
}
|
|
return Unchanged, index
|
|
}
|
|
|
|
switch motion {
|
|
case "h":
|
|
return Unchanged, m.cursorColumn - 1
|
|
case "j":
|
|
return m.cursorLine + 1, Unchanged
|
|
case "k":
|
|
return m.cursorLine - 1, Unchanged
|
|
case "l":
|
|
return Unchanged, m.cursorColumn + 1
|
|
|
|
case "0":
|
|
return Unchanged, 0
|
|
case "$":
|
|
return Unchanged, len(m.lines[m.cursorLine])
|
|
case "_":
|
|
for i, r := range m.lines[m.cursorLine] {
|
|
if !unicode.IsSpace(r) {
|
|
return Unchanged, i
|
|
}
|
|
}
|
|
return Unchanged, len(m.lines[m.cursorLine]) - 1
|
|
case "-":
|
|
if m.cursorLine-1 < 0 {
|
|
return Unchanged, Unchanged
|
|
}
|
|
line := m.lines[m.cursorLine-1]
|
|
for i, r := range line {
|
|
if !unicode.IsSpace(r) {
|
|
return m.cursorLine - 1, i
|
|
}
|
|
}
|
|
return m.cursorLine - 1, len(line) - 1
|
|
case "+":
|
|
if m.cursorLine+1 >= len(m.lines) {
|
|
return Unchanged, Unchanged
|
|
}
|
|
line := m.lines[m.cursorLine+1]
|
|
for i, r := range line {
|
|
if !unicode.IsSpace(r) {
|
|
return m.cursorLine + 1, i
|
|
}
|
|
}
|
|
return m.cursorLine + 1, len(line) - 1
|
|
|
|
case "gg":
|
|
return 0, Unchanged
|
|
case "G":
|
|
return len(m.lines) - 1, Unchanged
|
|
|
|
case ",":
|
|
dir := -1
|
|
line := m.lines[m.cursorLine]
|
|
i := m.cursorColumn + dir
|
|
if m.tlast {
|
|
i += dir
|
|
}
|
|
index, ok := SearchChar(line, i, dir, rune(m.fchar))
|
|
if !ok {
|
|
return Unchanged, Unchanged
|
|
}
|
|
if m.tlast {
|
|
index -= dir
|
|
}
|
|
return Unchanged, index
|
|
case ";":
|
|
dir := 1
|
|
line := m.lines[m.cursorLine]
|
|
i := m.cursorColumn + dir
|
|
if m.tlast {
|
|
i += dir
|
|
}
|
|
index, ok := SearchChar(line, i, dir, rune(m.fchar))
|
|
if !ok {
|
|
return Unchanged, Unchanged
|
|
}
|
|
if m.tlast {
|
|
index -= dir
|
|
}
|
|
return Unchanged, index
|
|
|
|
case "E":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
for {
|
|
line := m.lines[lnum]
|
|
isLastLine := lnum == len(m.lines)-1
|
|
isColAtEnd := col == len(line)-1
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isLastLine {
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
|
|
// Search next whitespace
|
|
i, ok := SearchCharFunc(line, col+1, 1, unicode.IsSpace)
|
|
if !ok {
|
|
if isLastLine || !isColAtEnd {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
|
|
// Found next word - Simple case
|
|
if i-1 != col {
|
|
return lnum, i - 1
|
|
}
|
|
|
|
// Search start of next word
|
|
i, ok = SearchCharFunc(line, i, 1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
|
|
// Next word exists, find it's end
|
|
i, ok = SearchCharFunc(line, i, 1, unicode.IsSpace)
|
|
if !ok {
|
|
if isLastLine || !isColAtEnd {
|
|
return lnum, len(line) - 1
|
|
}
|
|
// If at the end, continue to next line (if it exists)
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
return lnum, i - 1
|
|
}
|
|
case "e":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
for {
|
|
line := m.lines[lnum]
|
|
isLastLine := lnum == len(m.lines)-1
|
|
isColAtEnd := col == len(line)-1
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isLastLine {
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
|
|
// Search next non-matching char
|
|
if len(line) == 0 {
|
|
return lnum, 0
|
|
}
|
|
if col >= len(line) {
|
|
return lnum, len(line) - 1
|
|
}
|
|
isKeyword := IsKeyword(line[col])
|
|
isWhitespace := unicode.IsSpace(line[col])
|
|
i, ok := SearchCharFunc(line, col+1, 1, func(c rune) bool {
|
|
return unicode.IsSpace(c) || isWhitespace || isKeyword != IsKeyword(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine || !isColAtEnd {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
|
|
// Found next word - Simple case
|
|
if i-1 != col {
|
|
return lnum, i - 1
|
|
}
|
|
|
|
// Search start of next word
|
|
i, ok = SearchCharFunc(line, i, 1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
|
|
// Next word exists, find it's end
|
|
isKeyword = IsKeyword(line[i])
|
|
isWhitespace = unicode.IsSpace(line[i])
|
|
i, ok = SearchCharFunc(line, i, 1, func(c rune) bool {
|
|
return unicode.IsSpace(c) || isWhitespace || isKeyword != IsKeyword(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine || !isColAtEnd {
|
|
return lnum, len(line) - 1
|
|
}
|
|
// If at the end, continue to next line (if it exists)
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
return lnum, i - 1
|
|
}
|
|
case "B":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
for {
|
|
line := m.lines[lnum]
|
|
isFirstLine := lnum == 0
|
|
isColAtStart := col == 0
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isFirstLine {
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
|
|
// Search previous whitespace
|
|
i, ok := SearchCharFunc(line, col-1, -1, unicode.IsSpace)
|
|
if !ok {
|
|
if isFirstLine || !isColAtStart {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
|
|
// Found next word - Simple case
|
|
if i+1 != col {
|
|
return lnum, i + 1
|
|
}
|
|
|
|
// Search end of previous word
|
|
i, ok = SearchCharFunc(line, i, -1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
|
|
// Previous word exists, find it's start
|
|
i, ok = SearchCharFunc(line, i, -1, unicode.IsSpace)
|
|
if !ok {
|
|
if isFirstLine || !isColAtStart {
|
|
return lnum, 0
|
|
}
|
|
// If at the start, continue to previous line (if it exists)
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
return lnum, i + 1
|
|
}
|
|
case "b":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
for {
|
|
line := m.lines[lnum]
|
|
isFirstLine := lnum == 0
|
|
isColAtStart := col == 0
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isFirstLine {
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
|
|
// Search previous non-matching char
|
|
if col < 0 || len(line) == 0 {
|
|
return lnum, 0
|
|
}
|
|
isKeyword := IsKeyword(line[col])
|
|
isWhitespace := unicode.IsSpace(line[col])
|
|
i, ok := SearchCharFunc(line, col-1, -1, func(c rune) bool {
|
|
return unicode.IsSpace(c) || isWhitespace || isKeyword != IsKeyword(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine || !isColAtStart {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
|
|
// Found next word - Simple case
|
|
if i+1 != col {
|
|
return lnum, i + 1
|
|
}
|
|
|
|
// Search end of previous word
|
|
i, ok = SearchCharFunc(line, i, -1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
|
|
// Previous word exists, find it's start
|
|
isKeyword = IsKeyword(line[i])
|
|
isWhitespace = unicode.IsSpace(line[i])
|
|
i, ok = SearchCharFunc(line, i, -1, func(c rune) bool {
|
|
return unicode.IsSpace(c) || isWhitespace || isKeyword != IsKeyword(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine || !isColAtStart {
|
|
return lnum, 0
|
|
}
|
|
// If at the start, continue to previous line (if it exists)
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
return lnum, i + 1
|
|
}
|
|
case "W":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
remember := false
|
|
for {
|
|
line := m.lines[lnum]
|
|
isLastLine := lnum == len(m.lines)-1
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isLastLine {
|
|
// What happens if this is the current line
|
|
if lnum == m.cursorLine {
|
|
lnum++
|
|
col = 0
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, 0
|
|
}
|
|
|
|
if remember {
|
|
i, ok := SearchCharFunc(line, col, 1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
|
|
// Search next whitespace
|
|
i, ok := SearchCharFunc(line, col, 1, unicode.IsSpace)
|
|
if !ok {
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
remember = true
|
|
continue
|
|
}
|
|
|
|
// Search start of next word
|
|
i, ok = SearchCharFunc(line, i, 1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
case "w":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
remember := false
|
|
for {
|
|
line := m.lines[lnum]
|
|
isLastLine := lnum == len(m.lines)-1
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isLastLine {
|
|
// What happens if this is the current line
|
|
if lnum == m.cursorLine {
|
|
lnum++
|
|
col = 0
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, 0
|
|
}
|
|
|
|
if remember {
|
|
i, ok := SearchCharFunc(line, col, 1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
|
|
// Search previous non-matching char
|
|
if col < 0 || len(line) == 0 {
|
|
return lnum, 0
|
|
}
|
|
isKeyword := IsKeyword(line[col])
|
|
isWhitespace := unicode.IsSpace(line[col])
|
|
i, ok := SearchCharFunc(line, col, 1, func(c rune) bool {
|
|
return unicode.IsSpace(c) || isWhitespace || isKeyword != IsKeyword(c)
|
|
})
|
|
if !ok {
|
|
if remember {
|
|
return lnum, 0
|
|
}
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
remember = true
|
|
continue
|
|
}
|
|
|
|
// Search start of next word
|
|
i, ok = SearchCharFunc(line, i, 1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isLastLine {
|
|
return lnum, len(line) - 1
|
|
}
|
|
lnum++
|
|
col = 0
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
case "gE":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
remember := false
|
|
for {
|
|
line := m.lines[lnum]
|
|
isFirstLine := lnum == 0
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isFirstLine {
|
|
// What happens if this is the current line
|
|
if lnum == m.cursorLine {
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, 0
|
|
}
|
|
|
|
if remember {
|
|
i, ok := SearchCharFunc(line, col, -1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
|
|
// Search next whitespace
|
|
i, ok := SearchCharFunc(line, col, -1, unicode.IsSpace)
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
remember = true
|
|
continue
|
|
}
|
|
|
|
// Search start of next word
|
|
i, ok = SearchCharFunc(line, i, -1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
case "ge":
|
|
lnum := m.cursorLine
|
|
col := m.cursorColumn
|
|
remember := false
|
|
for {
|
|
line := m.lines[lnum]
|
|
isFirstLine := lnum == 0
|
|
|
|
// Skip if empty
|
|
if len(line) == 0 && !isFirstLine {
|
|
// What happens if this is the current line
|
|
if lnum == m.cursorLine {
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, 0
|
|
}
|
|
|
|
if remember {
|
|
i, ok := SearchCharFunc(line, col, -1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
|
|
// Search previous non-matching char
|
|
if col < 0 || len(line) == 0 {
|
|
return lnum, 0
|
|
}
|
|
isKeyword := IsKeyword(line[col])
|
|
isWhitespace := unicode.IsSpace(line[col])
|
|
i, ok := SearchCharFunc(line, col, -1, func(c rune) bool {
|
|
return unicode.IsSpace(c) || isWhitespace || isKeyword != IsKeyword(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
remember = true
|
|
continue
|
|
}
|
|
|
|
// Search start of next word
|
|
i, ok = SearchCharFunc(line, i, -1, func(c rune) bool {
|
|
return !unicode.IsSpace(c)
|
|
})
|
|
if !ok {
|
|
if isFirstLine {
|
|
return lnum, 0
|
|
}
|
|
lnum--
|
|
col = len(m.lines[lnum]) - 1
|
|
remember = true
|
|
continue
|
|
}
|
|
return lnum, i
|
|
}
|
|
|
|
default:
|
|
return Unchanged, Unchanged
|
|
}
|
|
}
|
|
|
|
func (m *Model) handleOpendingModeKeys(key tea.KeyMsg) {
|
|
if key.Type == tea.KeyEscape {
|
|
m.ResetOpending(false)
|
|
return
|
|
}
|
|
|
|
motion := key.String()
|
|
|
|
// Text objects
|
|
if motion == "i" && !m.imod {
|
|
m.imod = true
|
|
return
|
|
} else if m.imod {
|
|
m.imod = false
|
|
motion = "i" + motion
|
|
} else {
|
|
m.imod = false
|
|
}
|
|
if motion == "a" && !m.amod {
|
|
m.amod = true
|
|
return
|
|
} else if m.amod {
|
|
m.amod = false
|
|
motion = "a" + motion
|
|
} else {
|
|
m.amod = false
|
|
}
|
|
|
|
ftmod := m.fmod == 'f' || m.fmod == 't'
|
|
lnum, col := m.Motion(motion)
|
|
if m.gmod || m.fmod != NullChar {
|
|
return
|
|
}
|
|
|
|
// For now hardcoding is fine
|
|
// Should include all the "vertical" movement (j k - + gg G)
|
|
isVerticalMotion := col == Unchanged || motion[0] == '-' || motion[0] == '+'
|
|
|
|
if lnum != Unchanged || col != Unchanged {
|
|
if lnum == Unchanged {
|
|
lnum = m.cursorLine
|
|
}
|
|
if col == Unchanged {
|
|
col = m.cursorColumn
|
|
}
|
|
if ftmod {
|
|
col++ // Adjust due to upper bound being exclusive
|
|
// For F/T (backwards), being exclusive is the correct
|
|
}
|
|
if motion == "e" || motion == "E" {
|
|
col++ // Adjust due to upper bound being exclusive
|
|
}
|
|
|
|
if lnum == m.cursorLine {
|
|
line := m.lines[m.cursorLine]
|
|
lower := min(col, m.cursorColumn, len(line))
|
|
upper := min(max(col, m.cursorColumn), len(line))
|
|
value := line[lower:upper]
|
|
|
|
m.Yank(string(value))
|
|
|
|
if m.pending == 'd' || m.pending == 'c' {
|
|
line = slices.Delete(line, lower, upper)
|
|
m.lines[m.cursorLine] = line
|
|
}
|
|
|
|
m.SetCursorColumn(min(lower, len(line)-1))
|
|
if ftmod && m.pending == 'c' {
|
|
m.SetCursorColumn(lower) // Ignore bound
|
|
// Only ok because of insert mode (same as NVIM)
|
|
}
|
|
|
|
} else if isVerticalMotion {
|
|
lower := min(lnum, m.cursorLine)
|
|
upper := max(lnum, m.cursorLine) + 1
|
|
if upper > len(m.lines) || lower < 0 {
|
|
m.ResetOpending(false)
|
|
return
|
|
}
|
|
|
|
var builder strings.Builder
|
|
for i := lower; i < upper; i++ {
|
|
builder.WriteString(string(m.lines[i]))
|
|
builder.WriteRune('\n')
|
|
}
|
|
|
|
m.Yank(builder.String())
|
|
m.SetCursorLine(lower)
|
|
|
|
switch m.pending {
|
|
case 'd':
|
|
m.lines = slices.Delete(m.lines, lower, upper)
|
|
if len(m.lines) == 0 {
|
|
m.lines = append(m.lines, []rune(""))
|
|
}
|
|
m.SetCursorLine(min(m.cursorLine, len(m.lines)-1))
|
|
|
|
end := len(m.lines[m.cursorLine]) - 1
|
|
m.SetCursorColumn(min(m.cursorColumn, end))
|
|
|
|
case 'y':
|
|
end := len(m.lines[m.cursorLine]) - 1
|
|
m.SetCursorColumn(min(m.cursorColumn, end))
|
|
|
|
case 'c':
|
|
m.lines = slices.Delete(m.lines, lower+1, upper)
|
|
m.lines[lower] = []rune("")
|
|
m.SetCursorColumn(0)
|
|
}
|
|
|
|
} else {
|
|
// Multiline but not horizontal movement (such as "word" motions)
|
|
|
|
// Known issues (won't be fixed most likely, PRs are welcome):
|
|
// "dw" doesn't delete last char if it's the only word in the last line
|
|
// "dge" doesn't delete current char, in NVIM it does
|
|
// "dge" doesn't combine lines in certain scenarios where NVIM does
|
|
|
|
line := m.lines[m.cursorLine]
|
|
|
|
isLastLine := len(m.lines)-1 == m.cursorLine
|
|
if len(line) == 0 && len(m.lines) > 1 && !isLastLine {
|
|
m.lines = slices.Delete(m.lines, m.cursorLine, m.cursorLine+1)
|
|
m.ResetOpending(true)
|
|
return
|
|
}
|
|
|
|
if lnum > m.cursorLine {
|
|
col = len(line) // end
|
|
} else {
|
|
col = 0 // start
|
|
}
|
|
|
|
lower := min(col, m.cursorColumn, len(line))
|
|
upper := min(max(col, m.cursorColumn), len(line))
|
|
value := line[lower:upper]
|
|
|
|
m.Yank(string(value))
|
|
|
|
if m.pending == 'd' || m.pending == 'c' {
|
|
line = slices.Delete(line, lower, upper)
|
|
m.lines[m.cursorLine] = line
|
|
}
|
|
|
|
m.SetCursorColumn(min(lower, len(line)-1))
|
|
if ftmod && m.pending == 'c' {
|
|
m.SetCursorColumn(lower) // Ignore bound
|
|
// Only ok because of insert mode (same as NVIM)
|
|
}
|
|
}
|
|
|
|
m.ResetOpending(true)
|
|
return
|
|
}
|
|
|
|
switch motion {
|
|
case "c":
|
|
m.Yank(string(m.lines[m.cursorLine]) + "\n")
|
|
m.lines[m.cursorLine] = []rune("")
|
|
m.SetCursorColumn(0)
|
|
m.ResetOpending(true)
|
|
|
|
case "d":
|
|
m.Yank(string(m.lines[m.cursorLine]) + "\n")
|
|
if len(m.lines) == 1 {
|
|
m.lines[0] = []rune("")
|
|
m.SetCursorColumn(0)
|
|
} else {
|
|
m.lines = slices.Delete(m.lines, m.cursorLine, m.cursorLine+1)
|
|
m.SetCursorLine(m.cursorLine)
|
|
m.SetCursorColumn(m.cursorColumn)
|
|
}
|
|
m.ResetOpending(true)
|
|
|
|
case "y":
|
|
m.Yank(string(m.lines[m.cursorLine]) + "\n")
|
|
m.ResetOpending(true)
|
|
|
|
case "aW":
|
|
fallthrough
|
|
case "iW":
|
|
line := m.lines[m.cursorLine]
|
|
if len(line) == 0 {
|
|
m.ResetOpending(true)
|
|
return
|
|
}
|
|
|
|
isWhitespace := unicode.IsSpace(line[m.cursorColumn])
|
|
lower := m.cursorColumn
|
|
upper := m.cursorColumn + 1
|
|
searchFunc := func(c rune) bool {
|
|
return isWhitespace != unicode.IsSpace(c)
|
|
}
|
|
|
|
i, ok := SearchCharFunc(line, lower, -1, searchFunc)
|
|
if ok {
|
|
lower = i + 1
|
|
} else {
|
|
lower = 0
|
|
}
|
|
|
|
i, ok = SearchCharFunc(line, upper, 1, searchFunc)
|
|
if ok {
|
|
upper = i
|
|
} else {
|
|
upper = len(line)
|
|
}
|
|
|
|
value := line[lower:upper]
|
|
m.Yank(string(value))
|
|
|
|
if m.pending == 'd' || m.pending == 'c' {
|
|
line = slices.Delete(line, lower, upper)
|
|
m.lines[m.cursorLine] = line
|
|
m.SetCursorColumn(min(lower, len(line)-1))
|
|
}
|
|
|
|
m.ResetOpending(true)
|
|
|
|
case "aw":
|
|
fallthrough
|
|
case "iw":
|
|
line := m.lines[m.cursorLine]
|
|
if len(line) == 0 {
|
|
m.ResetOpending(true)
|
|
return
|
|
}
|
|
|
|
isKeyword := IsKeyword(line[m.cursorColumn])
|
|
isWhitespace := unicode.IsSpace(line[m.cursorColumn])
|
|
lower := m.cursorColumn
|
|
upper := m.cursorColumn + 1
|
|
searchFunc := func(c rune) bool {
|
|
return isKeyword != IsKeyword(c) || isWhitespace != unicode.IsSpace(c)
|
|
}
|
|
|
|
i, ok := SearchCharFunc(line, lower, -1, searchFunc)
|
|
if ok {
|
|
lower = i + 1
|
|
} else {
|
|
lower = 0
|
|
}
|
|
|
|
i, ok = SearchCharFunc(line, upper, 1, searchFunc)
|
|
if ok {
|
|
upper = i
|
|
} else {
|
|
upper = len(line)
|
|
}
|
|
|
|
value := line[lower:upper]
|
|
m.Yank(string(value))
|
|
|
|
if m.pending == 'd' || m.pending == 'c' {
|
|
line = slices.Delete(line, lower, upper)
|
|
m.lines[m.cursorLine] = line
|
|
m.SetCursorColumn(min(lower, len(line)-1))
|
|
}
|
|
|
|
m.ResetOpending(true)
|
|
|
|
default:
|
|
m.ResetOpending(false)
|
|
}
|
|
}
|
|
|
|
func (m *Model) ResetOpending(allowInsert bool) {
|
|
if m.pending == 'c' && allowInsert {
|
|
m.mode = InsertMode
|
|
} else {
|
|
m.mode = NormalMode
|
|
}
|
|
m.imod = false
|
|
m.amod = false
|
|
}
|
|
|
|
func (m *Model) Yank(s string) {
|
|
m.register = s
|
|
}
|
|
|
|
func (m Model) Paste() string {
|
|
return m.register
|
|
}
|