mirror of
https://github.com/neovim/neovim.git
synced 2025-10-03 16:36:30 +00:00
Björn Linse
@@ -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,23 +383,10 @@ 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");
|
||||
bool disallow_nl = (channel_id != VIML_INTERNAL_CALL);
|
||||
if (!check_string_array(replacement, disallow_nl, err)) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t new_len = replacement.size;
|
||||
size_t old_len = (size_t)(end - start);
|
||||
@@ -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.
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user