make search region padding only one rune wide

Author: matthias314

internal/buffer/search.go

@@ -2,7 +2,6 @@ package buffer
 
 import (
 	"regexp"
-	"unicode/utf8"
 
 	"github.com/zyedidia/micro/v2/internal/util"
 )
@@ -32,33 +31,6 @@ func NewRegexpGroup(s string) (RegexpGroup, error) {
 	return rgrp, err
 }
 
-func findLineParams(b *Buffer, start, end Loc, i int) ([]byte, int, int) {
-	l := b.LineBytes(i)
-	charpos := 0
-	padMode := 0
-
-	if i == end.Y {
-		nchars := util.CharacterCount(l)
-		end.X = util.Clamp(end.X, 0, nchars)
-		if end.X < nchars {
-			l = util.SliceStart(l, end.X+1)
-			padMode |= padEnd
-		}
-	}
-
-	if i == start.Y {
-		nchars := util.CharacterCount(l)
-		start.X = util.Clamp(start.X, 0, nchars)
-		if start.X > 0 {
-			charpos = start.X - 1
-			l = util.SliceEnd(l, charpos)
-			padMode |= padStart
-		}
-	}
-
-	return l, charpos, padMode
-}
-
 type bytesFind func(*regexp.Regexp, []byte) []int
 
 func (b *Buffer) findDownFunc(rgrp RegexpGroup, start, end Loc, find bytesFind) []Loc {
@@ -77,21 +49,40 @@ func (b *Buffer) findDownFunc(rgrp RegexpGroup, start, end Loc, find bytesFind)
 	}
 
 	for i := start.Y; i <= end.Y; i++ {
-		l, charpos, padMode := findLineParams(b, start, end, i)
+		l := b.LineBytes(i)
+		from, to := 0, len(l)
+		padMode := 0
+
+		if i == end.Y {
+			nchars := util.CharacterCount(l)
+			end.X = util.Clamp(end.X, 0, nchars)
+			if end.X < nchars {
+				padMode |= padEnd
+				to = util.NextRunePos(l, util.BytePosFromCharPos(l, end.X))
+			}
+		}
+
+		if i == start.Y {
+			nchars := util.CharacterCount(l)
+			start.X = util.Clamp(start.X, 0, nchars)
+			if start.X > 0 {
+				padMode |= padStart
+				from = util.PreviousRunePos(l, util.BytePosFromCharPos(l, start.X))
+			}
+		}
 
-		match := find(rgrp[padMode], l)
+		s := l[from:to]
+		match := find(rgrp[padMode], s)
 
 		if match != nil {
 			if padMode&padStart != 0 {
-				_, size := utf8.DecodeRune(l[match[0]:])
-				match[0] += size
+				match[0] = util.NextRunePos(s, match[0])
 			}
 			if padMode&padEnd != 0 {
-				_, size := utf8.DecodeLastRune(l[:match[1]])
-				match[1] -= size
+				match[1] = util.PreviousRunePos(s, match[1])
 			}
 			return util.SliceMap(match, func(pos int) Loc {
-				return Loc{charpos + util.RunePos(l, pos), i}
+				return Loc{util.CharPos(l, from+pos), i}
 			})
 		}
 	}

internal/util/unicode.go

@@ -26,6 +26,27 @@ func isMark(r rune) bool {
 	return unicode.In(r, unicode.Mark)
 }
 
+// PreviousRunePos returns the position of the rune preceding the one starting
+// at `i` in the given byte slice, or -1 if there is no valid rune
+func PreviousRunePos(b []byte, i int) int {
+	r, size := utf8.DecodeLastRune(b[:i])
+	if r == utf8.RuneError {
+		return -1
+	} else {
+		return i-size
+	}
+}
+
+// NextRunePos returns the position of the rune following the one starting
+// at `i` in the given byte slice, or -1 if there is no valid rune
+func NextRunePos(b []byte, i int) int {
+	r, size := utf8.DecodeRune(b[i:])
+	if r == utf8.RuneError {
+		return -1
+	} else {
+		return i+size
+	}
+}
 // DecodeCharacter returns the next character from an array of bytes
 // A character is a rune along with any accompanying combining runes
 func DecodeCharacter(b []byte) (rune, []rune, int) {
@@ -94,3 +115,14 @@ func CharacterCountInString(str string) int {
 
 	return s
 }
+
+// BytePosFromCharPos returns the position of the byte in `b` that
+// starts first rune of the character indexed by `ci`
+func BytePosFromCharPos(b []byte, ci int) int {
+	i := 0
+	for j := 0; j < ci; j++ {
+		_, _, size := DecodeCharacter(b[i:])
+		i += size
+	}
+	return i
+}

internal/util/util.go

@@ -327,9 +327,9 @@ func IsBytesWhitespace(b []byte) bool {
 	return true
 }
 
-// RunePos returns the rune index of a given byte index
-// Make sure the byte index is not between code points
-func RunePos(b []byte, i int) int {
+// CharPos returns the index of the character whose first rune starts at
+// the given byte index. Make sure the byte index is not between code points
+func CharPos(b []byte, i int) int {
 	return CharacterCount(b[:i])
 }