aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/nvim/api/buffer.c284
-rw-r--r--src/nvim/extmark.c17
-rw-r--r--test/functional/api/buffer_spec.lua123
-rw-r--r--test/functional/lua/buffer_updates_spec.lua67
4 files changed, 474 insertions, 17 deletions
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index f1151d196a..8d82d22040 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -309,6 +309,27 @@ end:
return rv;
}
+static bool check_string_array(Array arr, bool disallow_nl, Error *err)
+{
+ for (size_t i = 0; i < arr.size; i++) {
+ if (arr.items[i].type != kObjectTypeString) {
+ api_set_error(err,
+ kErrorTypeValidation,
+ "All items in the replacement array must be strings");
+ return false;
+ }
+ // Disallow newlines in the middle of the line.
+ if (disallow_nl) {
+ const String l = arr.items[i].data.string;
+ if (memchr(l.data, NL, l.size)) {
+ api_set_error(err, kErrorTypeValidation,
+ "String cannot contain newlines");
+ return false;
+ }
+ }
+ }
+ return true;
+}
/// Sets (replaces) a line-range in the buffer.
///
@@ -362,22 +383,9 @@ void nvim_buf_set_lines(uint64_t channel_id,
return;
}
- for (size_t i = 0; i < replacement.size; i++) {
- if (replacement.items[i].type != kObjectTypeString) {
- api_set_error(err,
- kErrorTypeValidation,
- "All items in the replacement array must be strings");
- return;
- }
- // Disallow newlines in the middle of the line.
- if (channel_id != VIML_INTERNAL_CALL) {
- const String l = replacement.items[i].data.string;
- if (memchr(l.data, NL, l.size)) {
- api_set_error(err, kErrorTypeValidation,
- "String cannot contain newlines");
- return;
- }
- }
+ bool disallow_nl = (channel_id != VIML_INTERNAL_CALL);
+ if (!check_string_array(replacement, disallow_nl, err)) {
+ return;
}
size_t new_len = replacement.size;
@@ -487,6 +495,250 @@ end:
try_end(err);
}
+/// Sets (replaces) a range in the buffer
+///
+/// This is recommended over nvim_buf_set_lines when only modifying parts of a
+/// line, as extmarks will be preserved on non-modified parts of the touched
+/// lines.
+///
+/// Indexing is zero-based and end-exclusive.
+///
+/// To insert text at a given index, set `start` and `end` ranges to the same
+/// index. To delete a range, set `replacement` to an array containing
+/// an empty string, or simply an empty array.
+///
+/// Prefer nvim_buf_set_lines when adding or deleting entire lines only.
+///
+/// @param channel_id
+/// @param buffer Buffer handle, or 0 for current buffer
+/// @param start_row First line index
+/// @param start_column Last column
+/// @param end_row Last line index
+/// @param end_column Last column
+/// @param replacement Array of lines to use as replacement
+/// @param[out] err Error details, if any
+void nvim_buf_set_text(uint64_t channel_id, Buffer buffer,
+ Integer start_row, Integer start_col,
+ Integer end_row, Integer end_col,
+ ArrayOf(String) replacement, Error *err)
+ FUNC_API_SINCE(7)
+{
+ FIXED_TEMP_ARRAY(scratch, 1);
+ if (replacement.size == 0) {
+ scratch.items[0] = STRING_OBJ(STATIC_CSTR_AS_STRING(""));
+ replacement = scratch;
+ }
+
+ buf_T *buf = find_buffer_by_handle(buffer, err);
+ if (!buf) {
+ return;
+ }
+
+ bool oob = false;
+
+ // check range is ordered and everything!
+ // start_row, end_row within buffer len (except add text past the end?)
+ start_row = normalize_index(buf, start_row, &oob);
+ if (oob || start_row == buf->b_ml.ml_line_count + 1) {
+ api_set_error(err, kErrorTypeValidation, "start_row out of bounds");
+ return;
+ }
+
+ end_row = normalize_index(buf, end_row, &oob);
+ if (oob || end_row == buf->b_ml.ml_line_count + 1) {
+ api_set_error(err, kErrorTypeValidation, "end_row out of bounds");
+ return;
+ }
+
+ char *str_at_start = (char *)ml_get_buf(buf, start_row, false);
+ if (start_col < 0 || (size_t)start_col > strlen(str_at_start)) {
+ api_set_error(err, kErrorTypeValidation, "start_col out of bounds");
+ return;
+ }
+
+ char *str_at_end = (char *)ml_get_buf(buf, end_row, false);
+ size_t len_at_end = strlen(str_at_end);
+ if (end_col < 0 || (size_t)end_col > len_at_end) {
+ api_set_error(err, kErrorTypeValidation, "end_col out of bounds");
+ return;
+ }
+
+ if (start_row > end_row || (end_row == start_row && start_col > end_col)) {
+ api_set_error(err, kErrorTypeValidation, "start is higher than end");
+ return;
+ }
+
+ bool disallow_nl = (channel_id != VIML_INTERNAL_CALL);
+ if (!check_string_array(replacement, disallow_nl, err)) {
+ return;
+ }
+
+ size_t new_len = replacement.size;
+
+ bcount_t new_byte = 0;
+ bcount_t old_byte = 0;
+
+ // calculate byte size of old region before it gets modified/deleted
+ if (start_row == end_row) {
+ old_byte = (bcount_t)end_col - start_col;
+ } else {
+ const char *bufline;
+ old_byte += (bcount_t)strlen(str_at_start) - start_col;
+ for (int64_t i = 1; i < end_row - start_row; i++) {
+ int64_t lnum = start_row + i;
+
+ bufline = (char *)ml_get_buf(buf, lnum, false);
+ old_byte += (bcount_t)(strlen(bufline))+1;
+ }
+ old_byte += (bcount_t)end_col+1;
+ }
+
+ String first_item = replacement.items[0].data.string;
+ String last_item = replacement.items[replacement.size-1].data.string;
+
+ size_t firstlen = (size_t)start_col+first_item.size;
+ size_t last_part_len = strlen(str_at_end) - (size_t)end_col;
+ if (replacement.size == 1) {
+ firstlen += last_part_len;
+ }
+ char *first = xmallocz(firstlen), *last = NULL;
+ memcpy(first, str_at_start, (size_t)start_col);
+ memcpy(first+start_col, first_item.data, first_item.size);
+ memchrsub(first+start_col, NUL, NL, first_item.size);
+ if (replacement.size == 1) {
+ memcpy(first+start_col+first_item.size, str_at_end+end_col, last_part_len);
+ } else {
+ last = xmallocz(last_item.size+last_part_len);
+ memcpy(last, last_item.data, last_item.size);
+ memchrsub(last, NUL, NL, last_item.size);
+ memcpy(last+last_item.size, str_at_end+end_col, last_part_len);
+ }
+
+ char **lines = (new_len != 0) ? xcalloc(new_len, sizeof(char *)) : NULL;
+ lines[0] = first;
+ new_byte += (bcount_t)(first_item.size);
+ for (size_t i = 1; i < new_len-1; i++) {
+ const String l = replacement.items[i].data.string;
+
+ // Fill lines[i] with l's contents. Convert NULs to newlines as required by
+ // NL-used-for-NUL.
+ lines[i] = xmemdupz(l.data, l.size);
+ memchrsub(lines[i], NUL, NL, l.size);
+ new_byte += (bcount_t)(l.size)+1;
+ }
+ if (replacement.size > 1) {
+ lines[replacement.size-1] = last;
+ new_byte += (bcount_t)(last_item.size)+1;
+ }
+
+ try_start();
+ aco_save_T aco;
+ aucmd_prepbuf(&aco, (buf_T *)buf);
+
+ if (!MODIFIABLE(buf)) {
+ api_set_error(err, kErrorTypeException, "Buffer is not 'modifiable'");
+ goto end;
+ }
+
+ // Small note about undo states: unlike set_lines, we want to save the
+ // undo state of one past the end_row, since end_row is inclusive.
+ if (u_save((linenr_T)start_row - 1, (linenr_T)end_row + 1) == FAIL) {
+ api_set_error(err, kErrorTypeException, "Failed to save undo information");
+ goto end;
+ }
+
+ ptrdiff_t extra = 0; // lines added to text, can be negative
+ size_t old_len = (size_t)(end_row-start_row+1);
+
+ // If the size of the range is reducing (ie, new_len < old_len) we
+ // need to delete some old_len. We do this at the start, by
+ // repeatedly deleting line "start".
+ size_t to_delete = (new_len < old_len) ? (size_t)(old_len - new_len) : 0;
+ for (size_t i = 0; i < to_delete; i++) {
+ if (ml_delete((linenr_T)start_row, false) == FAIL) {
+ api_set_error(err, kErrorTypeException, "Failed to delete line");
+ goto end;
+ }
+ }
+
+ if (to_delete > 0) {
+ extra -= (ptrdiff_t)to_delete;
+ }
+
+ // For as long as possible, replace the existing old_len with the
+ // new old_len. This is a more efficient operation, as it requires
+ // less memory allocation and freeing.
+ size_t to_replace = old_len < new_len ? old_len : new_len;
+ for (size_t i = 0; i < to_replace; i++) {
+ int64_t lnum = start_row + (int64_t)i;
+
+ if (lnum >= MAXLNUM) {
+ api_set_error(err, kErrorTypeValidation, "Index value is too high");
+ goto end;
+ }
+
+ if (ml_replace((linenr_T)lnum, (char_u *)lines[i], false) == FAIL) {
+ api_set_error(err, kErrorTypeException, "Failed to replace line");
+ goto end;
+ }
+ // Mark lines that haven't been passed to the buffer as they need
+ // to be freed later
+ lines[i] = NULL;
+ }
+
+ // Now we may need to insert the remaining new old_len
+ for (size_t i = to_replace; i < new_len; i++) {
+ int64_t lnum = start_row + (int64_t)i - 1;
+
+ if (lnum >= MAXLNUM) {
+ api_set_error(err, kErrorTypeValidation, "Index value is too high");
+ goto end;
+ }
+
+ if (ml_append((linenr_T)lnum, (char_u *)lines[i], 0, false) == FAIL) {
+ api_set_error(err, kErrorTypeException, "Failed to insert line");
+ goto end;
+ }
+
+ // Same as with replacing, but we also need to free lines
+ xfree(lines[i]);
+ lines[i] = NULL;
+ extra++;
+ }
+
+ // Adjust marks. Invalidate any which lie in the
+ // changed range, and move any in the remainder of the buffer.
+ mark_adjust((linenr_T)start_row,
+ (linenr_T)end_row,
+ MAXLNUM,
+ (long)extra,
+ kExtmarkNOOP);
+
+ colnr_T col_extent = (colnr_T)(end_col
+ - ((end_row == start_row) ? start_col : 0));
+ extmark_splice(buf, (int)start_row-1, (colnr_T)start_col,
+ (int)(end_row-start_row), col_extent, old_byte,
+ (int)new_len-1, (colnr_T)last_item.size, new_byte,
+ kExtmarkUndo);
+
+
+ changed_lines((linenr_T)start_row, 0, (linenr_T)end_row, (long)extra, true);
+
+ // adjust cursor like an extmark ( i e it was inside last_part_len)
+ if (curwin->w_cursor.lnum == end_row && curwin->w_cursor.col > end_col) {
+ curwin->w_cursor.col -= col_extent - (colnr_T)last_item.size;
+ }
+ fix_cursor((linenr_T)start_row, (linenr_T)end_row, (linenr_T)extra);
+
+end:
+ for (size_t i = 0; i < new_len; i++) {
+ xfree(lines[i]);
+ }
+ xfree(lines);
+ aucmd_restbuf(&aco);
+ try_end(err);
+}
+
/// Returns the byte offset of a line (0-indexed). |api-indexing|
///
/// Line 1 (index=0) has offset 0. UTF-8 bytes are counted. EOL is one byte.
diff --git a/src/nvim/extmark.c b/src/nvim/extmark.c
index ba685b158e..b2d8532cd7 100644
--- a/src/nvim/extmark.c
+++ b/src/nvim/extmark.c
@@ -560,6 +560,23 @@ void extmark_adjust(buf_T *buf,
new_row, 0, new_byte, undo);
}
+// Adjust extmarks following a text edit.
+//
+// @param buf
+// @param start_row Start row of the region to be changed
+// @param start_col Start col of the region to be changed
+// @param old_row End row of the region to be changed.
+// Encoded as an offset to start_row.
+// @param old_col End col of the region to be changed. Encodes
+// an offset from start_col if old_row = 0; otherwise,
+// encodes the end column of the old region.
+// @param old_byte Byte extent of the region to be changed.
+// @param new_row Row offset of the new region.
+// @param new_col Col offset of the new region. Encodes an offset from
+// start_col if new_row = 0; otherwise, encodes
+// the end column of the new region.
+// @param new_byte Byte extent of the new region.
+// @param undo
void extmark_splice(buf_T *buf,
int start_row, colnr_T start_col,
int old_row, colnr_T old_col, bcount_t old_byte,
diff --git a/test/functional/api/buffer_spec.lua b/test/functional/api/buffer_spec.lua
index 8ed642b43e..fb8ed6a9d7 100644
--- a/test/functional/api/buffer_spec.lua
+++ b/test/functional/api/buffer_spec.lua
@@ -392,6 +392,129 @@ describe('api/buf', function()
end)
end)
+ describe('nvim_buf_get_lines, nvim_buf_set_text', function()
+ local get_lines, set_text = curbufmeths.get_lines, curbufmeths.set_text
+
+ it('works', function()
+ insert([[
+ hello foo!
+ text
+ ]])
+
+ eq({'hello foo!'}, get_lines(0, 1, true))
+
+
+ -- can replace a single word
+ set_text(0, 6, 0, 9, {'world'})
+ eq({'hello world!', 'text'}, get_lines(0, 2, true))
+
+ -- can insert text
+ set_text(0, 0, 0, 0, {'well '})
+ eq({'well hello world!', 'text'}, get_lines(0, 2, true))
+
+ -- can delete text
+ set_text(0, 0, 0, 5, {''})
+ eq({'hello world!', 'text'}, get_lines(0, 2, true))
+
+ -- can replace with multiple lines
+ set_text(0, 6, 0, 11, {'foo', 'wo', 'more'})
+ eq({'hello foo', 'wo', 'more!', 'text'}, get_lines(0, 4, true))
+
+ -- will join multiple lines if needed
+ set_text(0, 6, 3, 4, {'bar'})
+ eq({'hello bar'}, get_lines(0, 1, true))
+ end)
+
+ it('works with undo', function()
+ insert([[
+ hello world!
+ foo bar
+ ]])
+
+ -- setting text
+ set_text(0, 0, 0, 0, {'well '})
+ feed('u')
+ eq({'hello world!'}, get_lines(0, 1, true))
+
+ -- deleting text
+ set_text(0, 0, 0, 6, {''})
+ feed('u')
+ eq({'hello world!'}, get_lines(0, 1, true))
+
+ -- inserting newlines
+ set_text(0, 0, 0, 0, {'hello', 'mr '})
+ feed('u')
+ eq({'hello world!'}, get_lines(0, 1, true))
+
+ -- deleting newlines
+ set_text(0, 0, 1, 4, {'hello'})
+ feed('u')
+ eq({'hello world!'}, get_lines(0, 1, true))
+ end)
+
+ it('updates the cursor position', function()
+ insert([[
+ hello world!
+ ]])
+
+ -- position the cursor on `!`
+ curwin('set_cursor', {1, 11})
+ -- replace 'world' with 'foo'
+ set_text(0, 6, 0, 11, {'foo'})
+ eq('hello foo!', curbuf_depr('get_line', 0))
+ -- cursor should be moved left by two columns (replacement is shorter by 2 chars)
+ eq({1, 9}, curwin('get_cursor'))
+ end)
+
+ it('can handle NULs', function()
+ set_text(0, 0, 0, 0, {'ab\0cd'})
+ eq('ab\0cd', curbuf_depr('get_line', 0))
+ end)
+
+ it('adjusts extmarks', function()
+ local ns = request('nvim_create_namespace', "my-fancy-plugin")
+ insert([[
+ foo bar
+ baz
+ ]])
+ local id1 = curbufmeths.set_extmark(ns, 0, 1, {})
+ local id2 = curbufmeths.set_extmark(ns, 0, 7, {})
+ local id3 = curbufmeths.set_extmark(ns, 1, 1, {})
+ set_text(0, 4, 0, 7, {"q"})
+
+ eq({'foo q', 'baz'}, get_lines(0, 2, true))
+ -- mark before replacement point is unaffected
+ eq({0, 1}, curbufmeths.get_extmark_by_id(ns, id1, {}))
+ -- mark gets shifted back because the replacement was shorter
+ eq({0, 5}, curbufmeths.get_extmark_by_id(ns, id2, {}))
+ -- mark on the next line is unaffected
+ eq({1, 1}, curbufmeths.get_extmark_by_id(ns, id3, {}))
+
+ -- replacing the text spanning two lines will adjust the mark on the next line
+ set_text(0, 3, 1, 3, {"qux"})
+ eq({'fooqux', ''}, get_lines(0, 2, true))
+ eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id3, {}))
+ -- but mark before replacement point is still unaffected
+ eq({0, 1}, curbufmeths.get_extmark_by_id(ns, id1, {}))
+ -- and the mark in the middle was shifted to the end of the insertion
+ eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id2, {}))
+
+ -- marks should be put back into the same place after undoing
+ set_text(0, 0, 0, 2, {''})
+ feed('u')
+ eq({0, 1}, curbufmeths.get_extmark_by_id(ns, id1, {}))
+ eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id2, {}))
+ eq({0, 6}, curbufmeths.get_extmark_by_id(ns, id3, {}))
+
+ -- marks should be shifted over by the correct number of bytes for multibyte
+ -- chars
+ set_text(0, 0, 0, 0, {'Ø'})
+ eq({0, 3}, curbufmeths.get_extmark_by_id(ns, id1, {}))
+ eq({0, 8}, curbufmeths.get_extmark_by_id(ns, id2, {}))
+ eq({0, 8}, curbufmeths.get_extmark_by_id(ns, id3, {}))
+ end)
+ end)
+
describe('nvim_buf_get_offset', function()
local get_offset = curbufmeths.get_offset
it('works', function()
diff --git a/test/functional/lua/buffer_updates_spec.lua b/test/functional/lua/buffer_updates_spec.lua
index 9f2b1b6e52..67dc5f5a16 100644
--- a/test/functional/lua/buffer_updates_spec.lua
+++ b/test/functional/lua/buffer_updates_spec.lua
@@ -288,7 +288,8 @@ describe('lua: nvim_buf_attach on_bytes', function()
-- TODO: while we are brewing the real strong coffe,
-- verify should check buf_get_offset after every check_events
if verify then
- meths.buf_get_offset(0, meths.buf_line_count(0))
+ local len = meths.buf_get_offset(0, meths.buf_line_count(0))
+ eq(len == -1 and 1 or len, string.len(shadowbytes))
end
exec_lua("return test_register(...)", 0, "test1", false, false, true)
meths.buf_get_changedtick(0)
@@ -510,6 +511,70 @@ describe('lua: nvim_buf_attach on_bytes', function()
{ "test1", "bytes", 1, 3, 0, 1, 1, 0, 3, 3, 0, 1, 1 };
}
end)
+
+ it('nvim_buf_set_text insert', function()
+ local check_events = setup_eventcheck(verify, {"bastext"})
+ meths.buf_set_text(0, 0, 3, 0, 3, {"fiol","kontra"})
+ check_events {
+ { "test1", "bytes", 1, 3, 0, 3, 3, 0, 0, 0, 1, 6, 11 };
+ }
+
+ meths.buf_set_text(0, 1, 6, 1, 6, {"punkt","syntgitarr","övnings"})
+ check_events {
+ { "test1", "bytes", 1, 4, 1, 6, 14, 0, 0, 0, 2, 8, 25 };
+ }
+
+ eq({ "basfiol", "kontrapunkt", "syntgitarr", "övningstext" },
+ meths.buf_get_lines(0, 0, -1, true))
+ end)
+
+ it('nvim_buf_set_text replace', function()
+ local check_events = setup_eventcheck(verify, origlines)
+
+ meths.buf_set_text(0, 2, 3, 2, 8, {"very text"})
+ check_events {
+ { "test1", "bytes", 1, 3, 2, 3, 35, 0, 5, 5, 0, 9, 9 };
+ }
+
+ meths.buf_set_text(0, 3, 5, 3, 7, {" splitty","line "})
+ check_events {
+ { "test1", "bytes", 1, 4, 3, 5, 57, 0, 2, 2, 1, 5, 14 };
+ }
+
+ meths.buf_set_text(0, 0, 8, 1, 2, {"JOINY"})
+ check_events {
+ { "test1", "bytes", 1, 5, 0, 8, 8, 1, 2, 10, 0, 5, 5 };
+ }
+
+ meths.buf_set_text(0, 4, 0, 6, 0, {"was 5,6",""})
+ check_events {
+ { "test1", "bytes", 1, 6, 4, 0, 75, 2, 0, 32, 1, 0, 8 };
+ }
+
+ eq({ "originalJOINYiginal line 2", "orivery text line 3", "origi splitty",
+ "line l line 4", "was 5,6", " indented line" },
+ meths.buf_get_lines(0, 0, -1, true))
+
+ end)
+
+ it('nvim_buf_set_text delete', function()
+ local check_events = setup_eventcheck(verify, origlines)
+
+ -- really {""} but accepts {} as a shorthand
+ meths.buf_set_text(0, 0, 0, 1, 0, {})
+ check_events {
+ { "test1", "bytes", 1, 3, 0, 0, 0, 1, 0, 16, 0, 0, 0 };
+ }
+
+ -- TODO(bfredl): this works but is not as convenient as set_lines
+ meths.buf_set_text(0, 4, 15, 5, 17, {""})
+ check_events {
+ { "test1", "bytes", 1, 4, 4, 15, 79, 1, 17, 18, 0, 0, 0 };
+ }
+ eq({ "original line 2", "original line 3", "original line 4",
+ "original line 5", "original line 6" },
+ meths.buf_get_lines(0, 0, -1, true))
+ end)
end
describe('(with verify) handles', function()
generated by cgit (git 2.34.1) at 2025-05-03 16:53:26 +0000