aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--runtime/doc/msgpack_rpc.txt124
-rw-r--r--src/nvim/CMakeLists.txt2
-rw-r--r--src/nvim/api/buffer.c28
-rw-r--r--src/nvim/buffer.c10
-rw-r--r--src/nvim/buffer_defs.h4
-rw-r--r--src/nvim/buffer_updates.c (renamed from src/nvim/liveupdate.c)62
-rw-r--r--src/nvim/buffer_updates.h13
-rw-r--r--src/nvim/ex_cmds.c24
-rw-r--r--src/nvim/fold.c14
-rw-r--r--src/nvim/liveupdate.h13
-rw-r--r--src/nvim/misc1.c14
-rw-r--r--src/nvim/terminal.c2
-rw-r--r--src/nvim/undo.c20
-rw-r--r--test/functional/api/buffer_updates_spec.lua (renamed from test/functional/api/liveupdate_spec.lua)294
14 files changed, 312 insertions, 312 deletions
diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index 8781c4589c..bf7c63710f 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -242,44 +242,44 @@ the type codes, because a client may be built against one Nvim version but
connect to another with different type codes.
==============================================================================
-6. Live Updates *live-updates* *rpc-live-updates*
+6. Buffer Updates *buffer-updates* *rpc-buffer-updates*
A dedicated API has been created to allow co-processes to be notified when a
buffer is changed in any way. It is difficult and error-prone to try and do
this with autocommands such as |TextChanged|.
- *live-updates-api*
-LiveUpdate Functions~
+ *buffer-updates-api*
+BufferUpdates Functions~
-nvim_buf_live_updates_start({send_buffer}) *nvim_buf_live_updates_start()*
+nvim_buf_attach({send_buffer}) *nvim_buf_attach()*
Register a plugin to receive notifications on buffer changes. An
- initial |LiveUpdateStart| notification will be sent as a
- confirmation. After that, |LiveUpdate| notifications will be
- sent for buffer updates, and |LiveUpdateTick| notifications for
- a new changedtick without buffer change.
+ initial |nvim_buf_updates_start| notification will be sent as a
+ confirmation. After that, |nvim_buf_update| notifications will be
+ sent for buffer updates, and |nvim_buf_update_tick| notifications
+ for a new changedtick without buffer change.
Parameters:~
{send_buffer} Bool. If `"True"`, the initial
- |LiveUpdateStart| notification will also send the full
- buffer's content. If `"False"`, the notification will
- contain an empty list instead.
+ |nvim_buf_updates_start| notification will also send the full
+ buffer's content. If `"False"`, the notification will contain
+ an empty list instead.
-nvim_buf_live_updates_stop() *nvim_buf_live_updates_stop()*
+nvim_buf_detach() *nvim_buf_detach()*
Unregister a plugin from buffer change notifications. A final
- |LiveUpdateEnd| notification will be sent as confirmation.
+ |nvim_buf_updates_end| notification will be sent as confirmation.
- *live-updates-events*
-LiveUpdate Events~
+ *buffer-updates-events*
+BufferUpdates Events~
The co-process will start receiving the following notification events:
-LiveUpdateStart[{buf}, {changedtick}, {linedata}, {more}] *LiveUpdateStart*
+nvim_buf_updates_start[{buf}, {changedtick}, {linedata}, {more}] *nvim_buf_updates_start*
Neovim will send at least one of these notifications to confirm that
- liveupdates are registered for this plugin, and possibly send the buffer's
+ buffer updates are registered for this plugin, and possibly send the buffer's
contents. If the buffer is very large, neovim might send the contents through
- in multiple events to avoid loading the entire buffer's contents into memory
- at once.
+ in multiple events to avoid loading the entire buffer's contents into
+ memory at once.
{buf} is an API handle for the buffer.
@@ -288,27 +288,27 @@ LiveUpdateStart[{buf}, {changedtick}, {linedata}, {more}] *LiveUpdateStart*
|b:changedtick| as part of your request to ensure that no other
changes have been made.
- {linedata} is a list of strings containing the buffer's contents. If
- this list contains 100 strings, then they represent lines 1-100 of the
- buffer. Newline characters are not included in the strings, so empty
- lines will be given as empty strings. If you receive another
- |LiveUpdateStart| notification with another {linedata} list, then
- these lines represent the next N lines of the buffer. I.e., a second
- notification with another list of 100 strings will represent lines 101-200
- of the buffer. If you send the |nvim_buf_live_updates_start| request with
- its argument set to `"False"`, this will be empty.
-
- {linedata} will always have at least 1 item, but the maximum length is
- determined by neovim and not guaranteed to be any particular size.
- Also the number of {linedata} items may vary between notifications, so
- your plugin must be prepared to receive the line data in whatever size
- lists neovim decides to split it into.
+ {linedata} is a list of strings containing the buffer's contents. If this
+ list contains 100 strings, then they represent lines 1-100 of the buffer.
+ Newline characters are not included in the strings, so empty lines will be
+ given as empty strings. If you receive another |nvim_buf_updates_start|
+ notification with another {linedata} list, then these lines represent the
+ next N lines of the buffer. I.e., a second notification with another list of
+ 100 strings will represent lines 101-200 of the buffer. If you send the
+ |nvim_buf_updates_start| request with its argument set to `"False"`, this
+ will be empty.
+
+ {linedata} will always have at least 1 item, but the maximum length is
+ determined by neovim and not guaranteed to be any particular size. Also the
+ number of {linedata} items may vary between notifications, so your plugin
+ must be prepared to receive the line data in whatever size lists neovim
+ decides to split it into.
{more} is a boolean which tells you whether or not to expect more
- |LiveUpdateStart| notifications. When {more} is false, you can be certain
+ |nvim_buf_updates_start| notifications. When {more} is false, you can be certain
that you now have the entire buffer's contents.
-LiveUpdate[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *LiveUpdate*
+nvim_buf_update[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *nvim_buf_update*
Indicates that the lines between {firstline} and {lastline} (end-exclusive,
zero-indexed) have been replaced with the new line data contained in the
@@ -327,24 +327,24 @@ LiveUpdate[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *LiveUpdat
be less than or equal to the number of lines that were in the buffer before
the lines were replaced.
- {lastline} is the integer line number of the first line that was not
- replaced (i.e. the range {firstline}, {lastline} is end-exclusive). Note
- that {lastline} is zero-indexed, so if line numbers 2 to 5 were replaced,
- this will be `5` instead of `6`. {lastline} is guaranteed to always be less
- than or equal to the number of lines that were in the buffer before the
- lines were replaced.
+ {lastline} is the integer line number of the first line that was not replaced
+ (i.e. the range {firstline}, {lastline} is end-exclusive). Note that
+ {lastline} is zero-indexed, so if line numbers 2 to 5 were replaced, this
+ will be `5` instead of `6`. {lastline} is guaranteed to always be less than
+ or equal to the number of lines that were in the buffer before the lines were
+ replaced.
{linedata} is a list of strings containing the contents of the new buffer
lines. Newline characters are not included in the strings, so empty lines
will be given as empty strings.
Note: sometimes {changedtick} will be |v:null|, which means that the buffer
- text *looks* like it has changed, but actually hasn't. In this case the
- lines in {linedata} contain the modified text that is shown to the user, but
- doesn't reflect the actual buffer contents. Currently this behaviour is only
- used for the 'inccommand' option.
+ text *looks* like it has changed, but actually hasn't. In this case the lines
+ in {linedata} contain the modified text that is shown to the user, but
+ doesn't reflect the actual buffer contents. Currently this behaviour is
+ only used for the 'inccommand' option.
-LiveUpdateTick[{buf}, {changedtick}] *LiveUpdateTick*
+nvim_buf_update_tick[{buf}, {changedtick}] *nvim_buf_update_tick*
Indicates that |b:changedtick| was incremented for the buffer {buf}, but no
text was changed. This is currently only used by undo/redo.
@@ -353,60 +353,60 @@ LiveUpdateTick[{buf}, {changedtick}] *LiveUpdateTick*
{changedtick} is the new value of |b:changedtick| for that buffer.
-LiveUpdateEnd[{buf}] *LiveUpdateEnd*
+nvim_buf_updates_end[{buf}] *nvim_buf_updates_end*
{buf} is an API handle for the buffer.
- Indicates that live updates for the nominated buffer have been disabled,
- either by calling |nvim_buf_live_updates_stop| or because the buffer was
- unloaded (see |live-updates-limitations| for more information).
+ Indicates that buffer updates for the nominated buffer have been disabled,
+ either by calling |nvim_buf_detach| or because the buffer was unloaded
+ (see |buffer-updates-limitations| for more information).
- *live-updates-limitations*
+ *buffer-updates-limitations*
Limitations~
-Note that any of the following actions will also turn off live updates because
+Note that any of the following actions will also turn off buffer updates because
the buffer contents are unloaded from memory:
- Closing all a buffer's windows (unless 'hidden' is enabled).
- Using |:edit| to reload the buffer
- reloading the buffer after it is changed from outside neovim.
- *live-updates-examples*
+ *buffer-updates-examples*
Example Events~
-If live updates are activated a new empty buffer, the following
-|LiveUpdateStart| event will be sent: >
+If buffer updates are activated a new empty buffer, the following
+|nvim_buf_updates_start| event will be sent: >
- rpcnotify({channel}, "LiveUpdateStart", [{buf}, [""], v:false])
+ rpcnotify({channel}, "nvim_buf_updates_start", [{buf}, [""], v:false])
If the user adds 2 new lines to the start of a buffer, the following event
would be generated: >
- rpcnotify({channel}, "LiveUpdate", [{buf}, 0, 0, ["line1", "line2"]])
+ rpcnotify({channel}, "nvim_buf_update", [{buf}, 0, 0, ["line1", "line2"]])
If the puts the cursor on a line containing the text `"Hello world"` and adds
a `!` character to the end using insert mode, the following event would be
generated: >
- rpcnotify({channel}, "LiveUpdate", [{buf}, {linenr}, {linenr} + 1, ["Hello
+ rpcnotify({channel}, "nvim_buf_update", [{buf}, {linenr}, {linenr} + 1, ["Hello
world!"]])
If the user moves their cursor to line 3 of a buffer and deletes 20 lines
using `20dd`, the following event will be generated: >
- rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 20, []])
+ rpcnotify({channel}, "nvim_buf_update", [{buf}, 2, 20, []])
If the user selects lines 3-5 of a buffer using |linewise-visual| mode and
then presses `p` to paste in a new block of 6 lines, then the following event
would be sent to the co-process: >
- rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 5, ['pasted line 1', 'pasted
+ rpcnotify({channel}, "nvim_buf_update", [{buf}, 2, 5, ['pasted line 1', 'pasted
line 2', 'pasted line 3', 'pasted line 4', 'pasted line 5', 'pasted line
6']])
If the user uses :edit to reload a buffer then the following event would be
generated: >
- rpcnotify({channel}, "LiveUpdateEnd", [{buf}])
+ rpcnotify({channel}, "nvim_buf_updates_end", [{buf}])
vim:tw=78:ts=8:ft=help:norl:
diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index a8a52a8093..97495eec6d 100644
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -142,7 +142,7 @@ set(CONV_SOURCES
message.c
regexp.c
screen.c
- liveupdate.c
+ buffer_updates.c
search.c
spell.c
spellfile.c
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 6778227a27..d59ce1ce3d 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -25,7 +25,7 @@
#include "nvim/window.h"
#include "nvim/undo.h"
#include "nvim/ex_docmd.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "api/buffer.c.generated.h"
@@ -76,18 +76,18 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
return rv;
}
-/// Activate live updates from this buffer to the current channel.
+/// Activate updates from this buffer to the current channel.
///
/// @param buffer The buffer handle
/// @param send_buffer Set to true if the initial notification should contain
/// the whole buffer
/// @param[out] err Details of an error that may have occurred
-/// @return False when live updates couldn't be enabled because the buffer isn't
+/// @return False when updates couldn't be enabled because the buffer isn't
/// loaded; otherwise True.
-Boolean nvim_buf_live_updates_start(uint64_t channel_id,
- Buffer buffer,
- Boolean send_buffer,
- Error *err)
+Boolean nvim_buf_attach(uint64_t channel_id,
+ Buffer buffer,
+ Boolean send_buffer,
+ Error *err)
FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
{
buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -96,18 +96,18 @@ Boolean nvim_buf_live_updates_start(uint64_t channel_id,
return false;
}
- return liveupdate_register(buf, channel_id, send_buffer);
+ return buffer_updates_register(buf, channel_id, send_buffer);
}
//
-/// Deactivate live updates from this buffer to the current channel.
+/// Deactivate updates from this buffer to the current channel.
///
/// @param buffer The buffer handle
/// @param[out] err Details of an error that may have occurred
-/// @return False when live updates couldn't be disabled because the buffer
+/// @return False when updates couldn't be disabled because the buffer
/// isn't loaded; otherwise True.
-Boolean nvim_buf_live_updates_stop(uint64_t channel_id,
- Buffer buffer,
- Error *err)
+Boolean nvim_buf_detach(uint64_t channel_id,
+ Buffer buffer,
+ Error *err)
FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
{
buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -116,7 +116,7 @@ Boolean nvim_buf_live_updates_stop(uint64_t channel_id,
return false;
}
- liveupdate_unregister(buf, channel_id);
+ buffer_updates_unregister(buf, channel_id);
return true;
}
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index e7ff25ce6b..e5b7128248 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -73,7 +73,7 @@
#include "nvim/os/os.h"
#include "nvim/os/time.h"
#include "nvim/os/input.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
typedef enum {
kBLSUnchanged = 0,
@@ -576,7 +576,7 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last)
do_autochdir();
// disable live updates for the current buffer
- liveupdate_unregister_all(buf);
+ buffer_updates_unregister_all(buf);
/*
* Remove the buffer from the list.
@@ -789,7 +789,7 @@ free_buffer_stuff (
xfree(buf->b_start_fenc);
buf->b_start_fenc = NULL;
- liveupdate_unregister_all(buf);
+ buffer_updates_unregister_all(buf);
}
/*
@@ -1741,8 +1741,8 @@ buf_T * buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum, int flags)
clrallmarks(buf); // clear marks
fmarks_check_names(buf); // check file marks for this file
buf->b_p_bl = (flags & BLN_LISTED) ? true : false; // init 'buflisted'
- kv_destroy(buf->liveupdate_channels);
- kv_init(buf->liveupdate_channels);
+ kv_destroy(buf->update_channels);
+ kv_init(buf->update_channels);
if (!(flags & BLN_DUMMY)) {
// Tricky: these autocommands may change the buffer list. They could also
// split the window with re-using the one empty buffer. This may result in
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 9f6ac15308..50d8c822c1 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -774,9 +774,9 @@ struct file_buffer {
kvec_t(BufhlLine *) b_bufhl_move_space; // temporary space for highlights
- // array of channelids which have asked to receive live updates for this
+ // array of channelids which have asked to receive updates for this
// buffer.
- kvec_t(uint64_t) liveupdate_channels;
+ kvec_t(uint64_t) update_channels;
};
/*
diff --git a/src/nvim/liveupdate.c b/src/nvim/buffer_updates.c
index d587567e3f..d7bb11d125 100644
--- a/src/nvim/liveupdate.c
+++ b/src/nvim/buffer_updates.c
@@ -1,4 +1,4 @@
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
#include "nvim/memline.h"
#include "nvim/api/private/helpers.h"
#include "nvim/msgpack_rpc/channel.h"
@@ -6,7 +6,7 @@
// Register a channel. Return True if the channel was added, or already added.
// Return False if the channel couldn't be added because the buffer is
// unloaded.
-bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
+bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
{
// must fail if the buffer isn't loaded
if (buf->b_ml.ml_mfp == NULL) {
@@ -14,10 +14,10 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
}
// count how many channels are currently watching the buffer
- size_t size = kv_size(buf->liveupdate_channels);
+ size_t size = kv_size(buf->update_channels);
if (size) {
for (size_t i = 0; i < size; i++) {
- if (kv_A(buf->liveupdate_channels, i) == channel_id) {
+ if (kv_A(buf->update_channels, i) == channel_id) {
// buffer is already registered ... nothing to do
return true;
}
@@ -25,7 +25,7 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
}
// append the channelid to the list
- kv_push(buf->liveupdate_channels, channel_id);
+ kv_push(buf->update_channels, channel_id);
Array linedata = ARRAY_DICT_INIT;
if (send_buffer) {
@@ -56,22 +56,22 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
args.items[2] = ARRAY_OBJ(linedata);
args.items[3] = BOOLEAN_OBJ(false);
- rpc_send_event(channel_id, "LiveUpdateStart", args);
+ rpc_send_event(channel_id, "nvim_buf_updates_start", args);
return true;
}
-void liveupdate_send_end(buf_T *buf, uint64_t channelid)
+void buffer_updates_send_end(buf_T *buf, uint64_t channelid)
{
Array args = ARRAY_DICT_INIT;
args.size = 1;
args.items = xcalloc(sizeof(Object), args.size);
args.items[0] = BUFFER_OBJ(buf->handle);
- rpc_send_event(channelid, "LiveUpdateEnd", args);
+ rpc_send_event(channelid, "nvim_buf_updates_end", args);
}
-void liveupdate_unregister(buf_T *buf, uint64_t channelid)
+void buffer_updates_unregister(buf_T *buf, uint64_t channelid)
{
- size_t size = kv_size(buf->liveupdate_channels);
+ size_t size = kv_size(buf->update_channels);
if (!size) {
return;
}
@@ -81,12 +81,12 @@ void liveupdate_unregister(buf_T *buf, uint64_t channelid)
size_t j = 0;
size_t found = 0;
for (size_t i = 0; i < size; i++) {
- if (kv_A(buf->liveupdate_channels, i) == channelid) {
+ if (kv_A(buf->update_channels, i) == channelid) {
found++;
} else {
// copy item backwards into prior slot if needed
if (i != j) {
- kv_A(buf->liveupdate_channels, j) = kv_A(buf->liveupdate_channels, i);
+ kv_A(buf->update_channels, j) = kv_A(buf->update_channels, i);
}
j++;
}
@@ -94,39 +94,39 @@ void liveupdate_unregister(buf_T *buf, uint64_t channelid)
if (found) {
// remove X items from the end of the array
- buf->liveupdate_channels.size -= found;
+ buf->update_channels.size -= found;
// make a new copy of the active array without the channelid in it
- liveupdate_send_end(buf, channelid);
+ buffer_updates_send_end(buf, channelid);
if (found == size) {
- kv_destroy(buf->liveupdate_channels);
- kv_init(buf->liveupdate_channels);
+ kv_destroy(buf->update_channels);
+ kv_init(buf->update_channels);
}
}
}
-void liveupdate_unregister_all(buf_T *buf)
+void buffer_updates_unregister_all(buf_T *buf)
{
- size_t size = kv_size(buf->liveupdate_channels);
+ size_t size = kv_size(buf->update_channels);
if (size) {
for (size_t i = 0; i < size; i++) {
- liveupdate_send_end(buf, kv_A(buf->liveupdate_channels, i));
+ buffer_updates_send_end(buf, kv_A(buf->update_channels, i));
}
- kv_destroy(buf->liveupdate_channels);
- kv_init(buf->liveupdate_channels);
+ kv_destroy(buf->update_channels);
+ kv_init(buf->update_channels);
}
}
-void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
+void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
int64_t num_removed, bool send_tick)
{
// if one the channels doesn't work, put its ID here so we can remove it later
uint64_t badchannelid = 0;
// notify each of the active channels
- for (size_t i = 0; i < kv_size(buf->liveupdate_channels); i++) {
- uint64_t channelid = kv_A(buf->liveupdate_channels, i);
+ for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
+ uint64_t channelid = kv_A(buf->update_channels, i);
// send through the changes now channel contents now
Array args = ARRAY_DICT_INIT;
@@ -162,9 +162,9 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
}
}
args.items[4] = ARRAY_OBJ(linedata);
- if (!rpc_send_event(channelid, "LiveUpdate", args)) {
+ if (!rpc_send_event(channelid, "nvim_buf_update", args)) {
// We can't unregister the channel while we're iterating over the
- // liveupdate_channels array, so we remember its ID to unregister it at
+ // update_channels array, so we remember its ID to unregister it at
// the end.
badchannelid = channelid;
}
@@ -175,15 +175,15 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
// cleared up quickly.
if (badchannelid != 0) {
ELOG("Disabling live updates for dead channel %llu", badchannelid);
- liveupdate_unregister(buf, badchannelid);
+ buffer_updates_unregister(buf, badchannelid);
}
}
-void liveupdate_send_tick(buf_T *buf)
+void buffer_updates_send_tick(buf_T *buf)
{
// notify each of the active channels
- for (size_t i = 0; i < kv_size(buf->liveupdate_channels); i++) {
- uint64_t channelid = kv_A(buf->liveupdate_channels, i);
+ for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
+ uint64_t channelid = kv_A(buf->update_channels, i);
// send through the changes now channel contents now
Array args = ARRAY_DICT_INIT;
@@ -197,6 +197,6 @@ void liveupdate_send_tick(buf_T *buf)
args.items[1] = INTEGER_OBJ(buf->b_changedtick);
// don't try and clean up dead channels here
- rpc_send_event(channelid, "LiveUpdateTick", args);
+ rpc_send_event(channelid, "nvim_buf_update_tick", args);
}
}
diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h
new file mode 100644
index 0000000000..8fe33a0ebe
--- /dev/null
+++ b/src/nvim/buffer_updates.h
@@ -0,0 +1,13 @@
+#ifndef BUFFER_UPDATES_H
+#define BUFFER_UPDATES_H
+
+#include "nvim/buffer_defs.h"
+
+bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
+void buffer_updates_unregister(buf_T *buf, uint64_t channel_id);
+void buffer_updates_unregister_all(buf_T *buf);
+void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
+ int64_t num_removed, bool send_tick);
+void buffer_updates_send_tick(buf_T *buf);
+
+#endif // NVIM_BUFFER_UPDATES_H
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index e418e0c20e..fdb8c87213 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -35,7 +35,7 @@
#include "nvim/fold.h"
#include "nvim/getchar.h"
#include "nvim/indent.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
#include "nvim/main.h"
#include "nvim/mark.h"
#include "nvim/mbyte.h"
@@ -833,9 +833,9 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
-(last_line - dest - extra), 0L, true);
changed_lines(last_line - num_lines + 1, 0, last_line + 1, -extra, false);
- // send live update regarding the new lines that were added
- if (kv_size(curbuf->liveupdate_channels)) {
- liveupdate_send_changes(curbuf, dest + 1, num_lines, 0, true);
+ // send update regarding the new lines that were added
+ if (kv_size(curbuf->update_channels)) {
+ buffer_updates_send_changes(curbuf, dest + 1, num_lines, 0, true);
}
/*
@@ -872,9 +872,9 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
changed_lines(dest + 1, 0, line1 + num_lines, 0L, false);
}
- // send LiveUpdate regarding lines that were deleted
- if (kv_size(curbuf->liveupdate_channels)) {
- liveupdate_send_changes(curbuf, line1 + extra, 0, num_lines, true);
+ // send nvim_buf_update regarding lines that were deleted
+ if (kv_size(curbuf->update_channels)) {
+ buffer_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true);
}
return OK;
@@ -2442,7 +2442,7 @@ int do_ecmd(
goto theend;
}
u_unchanged(curbuf);
- liveupdate_unregister_all(curbuf);
+ buffer_updates_unregister_all(curbuf);
buf_freeall(curbuf, BFA_KEEP_UNDO);
// Tell readfile() not to clear or reload undo info.
@@ -3170,7 +3170,7 @@ static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags,
///
/// @return buffer used for 'inccommand' preview
static buf_T *do_sub(exarg_T *eap, proftime_T timeout,
- bool send_liveupdate_changedtick)
+ bool send_buffer_update_changedtick)
{
long i = 0;
regmmatch_T regmatch;
@@ -4018,11 +4018,11 @@ skip:
i = curbuf->b_ml.ml_line_count - old_line_count;
changed_lines(first_line, 0, last_line - i, i, false);
- if (kv_size(curbuf->liveupdate_channels)) {
+ if (kv_size(curbuf->update_channels)) {
int64_t num_added = last_line - first_line;
int64_t num_removed = num_added - i;
- liveupdate_send_changes(curbuf, first_line, num_added, num_removed,
- send_liveupdate_changedtick);
+ buffer_updates_send_changes(curbuf, first_line, num_added, num_removed,
+ send_buffer_update_changedtick);
}
}
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 5758a298ac..2cf1c6f394 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -20,7 +20,7 @@
#include "nvim/ex_docmd.h"
#include "nvim/func_attr.h"
#include "nvim/indent.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
#include "nvim/mark.h"
#include "nvim/memline.h"
#include "nvim/memory.h"
@@ -746,14 +746,14 @@ deleteFold (
if (last_lnum > 0) {
changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L, false);
- // send one LiveUpdate at the end
- if (kv_size(curbuf->liveupdate_channels)) {
+ // send one nvim_buf_update at the end
+ if (kv_size(curbuf->update_channels)) {
// last_lnum is the line *after* the last line of the outermost fold
// that was modified. Note also that deleting a fold might only require
// the modification of the *first* line of the fold, but we send through a
// notification that includes every line that was part of the fold
int64_t num_changed = last_lnum - first_lnum;
- liveupdate_send_changes(curbuf, first_lnum, num_changed,
+ buffer_updates_send_changes(curbuf, first_lnum, num_changed,
num_changed, true);
}
}
@@ -1605,12 +1605,12 @@ static void foldCreateMarkers(linenr_T start, linenr_T end)
* changed when the start marker is inserted and the end isn't. */
changed_lines(start, (colnr_T)0, end, 0L, false);
- if (kv_size(curbuf->liveupdate_channels)) {
+ if (kv_size(curbuf->update_channels)) {
// Note: foldAddMarker() may not actually change start and/or end if
- // u_save() is unable to save the buffer line, but we send the LiveUpdate
+ // u_save() is unable to save the buffer line, but we send the nvim_buf_update
// anyway since it won't do any harm.
int64_t num_changed = 1 + end - start;
- liveupdate_send_changes(curbuf, start, num_changed, num_changed, true);
+ buffer_updates_send_changes(curbuf, start, num_changed, num_changed, true);
}
}
diff --git a/src/nvim/liveupdate.h b/src/nvim/liveupdate.h
deleted file mode 100644
index 77fb420bf0..0000000000
--- a/src/nvim/liveupdate.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef NVIM_LIVEUPDATE_H
-#define NVIM_LIVEUPDATE_H
-
-#include "nvim/buffer_defs.h"
-
-bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
-void liveupdate_unregister(buf_T *buf, uint64_t channel_id);
-void liveupdate_unregister_all(buf_T *buf);
-void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
- int64_t num_removed, bool send_tick);
-void liveupdate_send_tick(buf_T *buf);
-
-#endif // NVIM_LIVEUPDATE_H
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index e2094d7293..7c9e728c92 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -28,7 +28,7 @@
#include "nvim/getchar.h"
#include "nvim/indent.h"
#include "nvim/indent_c.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
#include "nvim/main.h"
#include "nvim/mark.h"
#include "nvim/mbyte.h"
@@ -1822,8 +1822,8 @@ void changed_bytes(linenr_T lnum, colnr_T col)
changedOneline(curbuf, lnum);
changed_common(lnum, col, lnum + 1, 0L);
// notify any channels that are watching
- if (kv_size(curbuf->liveupdate_channels)) {
- liveupdate_send_changes(curbuf, lnum, 1, 1, true);
+ if (kv_size(curbuf->update_channels)) {
+ buffer_updates_send_changes(curbuf, lnum, 1, 1, true);
}
/* Diff highlighting in other diff windows may need to be updated too. */
@@ -1920,9 +1920,9 @@ changed_lines(
colnr_T col, // column in first line with change
linenr_T lnume, // line below last changed line
long xtra, // number of extra lines (negative when deleting)
- bool send_liveupdate // some callers like undo/redo call changed_lines()
+ bool send_update // some callers like undo/redo call changed_lines()
// and then increment b_changedtick *again*. This flag
- // allows these callers to send the LiveUpdate events
+ // allows these callers to send the nvim_buf_update events
// after they're done modifying b_changedtick.
)
{
@@ -1948,10 +1948,10 @@ changed_lines(
changed_common(lnum, col, lnume, xtra);
- if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) {
+ if (send_update && kv_size(curbuf->update_channels)) {
int64_t num_added = (int64_t)(lnume + xtra - lnum);
int64_t num_removed = lnume - lnum;
- liveupdate_send_changes(curbuf, lnum, num_added, num_removed, true);
+ buffer_updates_send_changes(curbuf, lnum, num_added, num_removed, true);
}
}
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 735f5a3829..9ab537d8b9 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -1234,7 +1234,7 @@ static void refresh_screen(Terminal *term, buf_T *buf)
int change_start = row_to_linenr(term, term->invalid_start);
int change_end = change_start + changed;
- // Note: don't send LiveUpdate event for a :terminal buffer
+ // Note: don't send nvim_buf_update event for a :terminal buffer
changed_lines(change_start, 0, change_end, added, false);
term->invalid_start = INT_MAX;
term->invalid_end = -1;
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 1c14e93211..9da9693c90 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -92,7 +92,7 @@
#include "nvim/eval.h"
#include "nvim/fileio.h"
#include "nvim/fold.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
#include "nvim/mark.h"
#include "nvim/memline.h"
#include "nvim/message.h"
@@ -1698,7 +1698,7 @@ bool u_undo_and_forget(int count)
count = 1;
}
undo_undoes = true;
- // don't send a LiveUpdate for this undo is part of 'inccommand' playing with
+ // don't send a nvim_buf_update for this undo is part of 'inccommand' playing with
// buffer contents
u_doit(count, true, false);
@@ -1735,7 +1735,7 @@ bool u_undo_and_forget(int count)
}
/// Undo or redo, depending on `undo_undoes`, `count` times.
-static void u_doit(int startcount, bool quiet, bool send_liveupdate)
+static void u_doit(int startcount, bool quiet, bool send_update)
{
int count = startcount;
@@ -1771,7 +1771,7 @@ static void u_doit(int startcount, bool quiet, bool send_liveupdate)
break;
}
- u_undoredo(true, send_liveupdate);
+ u_undoredo(true, send_update);
} else {
if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) {
beep_flush(); /* nothing to redo */
@@ -1782,7 +1782,7 @@ static void u_doit(int startcount, bool quiet, bool send_liveupdate)
break;
}
- u_undoredo(false, send_liveupdate);
+ u_undoredo(false, send_update);
/* Advance for next redo. Set "newhead" when at the end of the
* redoable changes. */
@@ -2117,7 +2117,7 @@ void undo_time(long step, int sec, int file, int absolute)
*
* When "undo" is TRUE we go up in the tree, when FALSE we go down.
*/
-static void u_undoredo(int undo, bool send_liveupdate)
+static void u_undoredo(int undo, bool send_update)
{
char_u **newarray = NULL;
linenr_T oldsize;
@@ -2245,7 +2245,7 @@ static void u_undoredo(int undo, bool send_liveupdate)
}
}
- changed_lines(top + 1, 0, bot, newsize - oldsize, send_liveupdate);
+ changed_lines(top + 1, 0, bot, newsize - oldsize, send_update);
/* set '[ and '] mark */
if (top + 1 < curbuf->b_op_start.lnum)
@@ -2281,10 +2281,10 @@ static void u_undoredo(int undo, bool send_liveupdate)
}
// because the calls to changed()/unchanged() above will bump b_changedtick
- // again, we need to send a LiveUpdate with just the new value of
+ // again, we need to send a nvim_buf_update with just the new value of
// b:changedtick
- if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) {
- liveupdate_send_tick(curbuf);
+ if (send_update && kv_size(curbuf->update_channels)) {
+ buffer_updates_send_tick(curbuf);
}
/*
diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/buffer_updates_spec.lua
index e674913464..c3a1754cf3 100644
--- a/test/functional/api/liveupdate_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -1,7 +1,7 @@
local helpers = require('test.functional.helpers')(after_each)
local eq, ok = helpers.eq, helpers.ok
local buffer, command, eval, nvim, next_message = helpers.buffer,
- helpers.command, helpers.eval, helpers.nvim, helpers.next_message
+ helpers.command, helpers.eval, helpers.nvim, helpers.next_msg
local origlines = {"original line 1",
"original line 2",
@@ -32,11 +32,11 @@ local function open(activate, lines)
-- what is the value of b:changedtick?
local tick = eval('b:changedtick')
- -- turn on live updates, ensure that the LiveUpdateStart messages
+ -- turn on live updates, ensure that the nvim_buf_updates_start messages
-- arrive as expectected
if activate then
- ok(buffer('live_updates_start', b, true))
- expectn('LiveUpdateStart', {b, tick, lines, false})
+ ok(buffer('attach', b, true))
+ expectn('nvim_buf_updates_start', {b, tick, lines, false})
end
return b, tick, filename
@@ -52,13 +52,13 @@ local function editoriginal(activate, lines)
end
local function reopen(buf, expectedlines)
- ok(buffer('live_updates_stop', buf))
- expectn('LiveUpdateEnd', {buf})
+ ok(buffer('detach', buf))
+ expectn('nvim_buf_updates_end', {buf})
-- for some reason the :edit! increments tick by 2
command('edit!')
local tick = eval('b:changedtick')
- ok(buffer('live_updates_start', buf, true))
- expectn('LiveUpdateStart', {buf, tick, expectedlines, false})
+ ok(buffer('attach', buf, true))
+ expectn('nvim_buf_updates_start', {buf, tick, expectedlines, false})
command('normal! gg')
return tick
end
@@ -73,13 +73,13 @@ local function reopenwithfolds(b)
-- add a fold
command('2,4fold')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 4, {'original line 2/*{{{*/',
+ expectn('nvim_buf_update', {b, tick, 1, 4, {'original line 2/*{{{*/',
'original line 3',
'original line 4/*}}}*/'}})
-- make a new fold that wraps lines 1-6
command('1,6fold')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 6, {'original line 1/*{{{*/',
+ expectn('nvim_buf_update', {b, tick, 0, 6, {'original line 1/*{{{*/',
'original line 2/*{{{*/',
'original line 3',
'original line 4/*}}}*/',
@@ -95,30 +95,30 @@ describe('liveupdate', function()
-- add a new line at the start of the buffer
command('normal! GyyggP')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 0, {'original line 6'}})
+ expectn('nvim_buf_update', {b, tick, 0, 0, {'original line 6'}})
-- add multiple lines at the start of the file
command('normal! GkkyGggP')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 0, {'original line 4',
+ expectn('nvim_buf_update', {b, tick, 0, 0, {'original line 4',
'original line 5',
'original line 6'}})
-- add one line to the middle of the file, several times
command('normal! ggYjjp')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4'}})
+ expectn('nvim_buf_update', {b, tick, 3, 3, {'original line 4'}})
command('normal! p')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 4, 4, {'original line 4'}})
+ expectn('nvim_buf_update', {b, tick, 4, 4, {'original line 4'}})
command('normal! p')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 5, 5, {'original line 4'}})
+ expectn('nvim_buf_update', {b, tick, 5, 5, {'original line 4'}})
-- add multiple lines to the middle of the file
command('normal! gg4Yjjp')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4',
+ expectn('nvim_buf_update', {b, tick, 3, 3, {'original line 4',
'original line 5',
'original line 6',
'original line 4'}})
@@ -126,16 +126,16 @@ describe('liveupdate', function()
-- add one line to the end of the file
command('normal! ggYGp')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 17, 17, {'original line 4'}})
+ expectn('nvim_buf_update', {b, tick, 17, 17, {'original line 4'}})
-- add one line to the end of the file, several times
command('normal! ggYGppp')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 18, 18, {'original line 4'}})
+ expectn('nvim_buf_update', {b, tick, 18, 18, {'original line 4'}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 19, 19, {'original line 4'}})
+ expectn('nvim_buf_update', {b, tick, 19, 19, {'original line 4'}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 20, 20, {'original line 4'}})
+ expectn('nvim_buf_update', {b, tick, 20, 20, {'original line 4'}})
-- add several lines to the end of the file, several times
command('normal! gg4YGp')
@@ -146,47 +146,47 @@ describe('liveupdate', function()
'original line 6',
'original line 4'}
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 21, 21, firstfour})
+ expectn('nvim_buf_update', {b, tick, 21, 21, firstfour})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 25, 25, firstfour})
+ expectn('nvim_buf_update', {b, tick, 25, 25, firstfour})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 29, 29, firstfour})
+ expectn('nvim_buf_update', {b, tick, 29, 29, firstfour})
-- create a new empty buffer and wipe out the old one ... this will
-- turn off live updates
command('enew!')
- expectn('LiveUpdateEnd', {b})
+ expectn('nvim_buf_updates_end', {b})
-- add a line at the start of an empty file
command('enew')
tick = eval('b:changedtick')
local b2 = nvim('get_current_buf')
- ok(buffer('live_updates_start', b2, true))
- expectn('LiveUpdateStart', {b2, tick, {""}, false})
+ ok(buffer('attach', b2, true))
+ expectn('nvim_buf_updates_start', {b2, tick, {""}, false})
eval('append(0, ["new line 1"])')
tick = tick + 1
- expectn('LiveUpdate', {b2, tick, 0, 0, {'new line 1'}})
+ expectn('nvim_buf_update', {b2, tick, 0, 0, {'new line 1'}})
-- turn off live updates manually
- buffer('live_updates_stop', b2)
- expectn('LiveUpdateEnd', {b2})
+ buffer('detach', b2)
+ expectn('nvim_buf_updates_end', {b2})
-- add multiple lines to a blank file
command('enew!')
local b3 = nvim('get_current_buf')
- ok(buffer('live_updates_start', b3, true))
+ ok(buffer('attach', b3, true))
tick = eval('b:changedtick')
- expectn('LiveUpdateStart', {b3, tick, {""}, false})
+ expectn('nvim_buf_updates_start', {b3, tick, {""}, false})
eval('append(0, ["new line 1", "new line 2", "new line 3"])')
tick = tick + 1
- expectn('LiveUpdate', {b3, tick, 0, 0, {'new line 1',
+ expectn('nvim_buf_update', {b3, tick, 0, 0, {'new line 1',
'new line 2',
'new line 3'}})
-- use the API itself to add a line to the start of the buffer
buffer('set_lines', b3, 0, 0, true, {'New First Line'})
tick = tick + 1
- expectn('LiveUpdate', {b3, tick, 0, 0, {"New First Line"}})
+ expectn('nvim_buf_update', {b3, tick, 0, 0, {"New First Line"}})
end)
it('knows when you remove lines from a buffer', function()
@@ -195,37 +195,37 @@ describe('liveupdate', function()
-- remove one line from start of file
command('normal! dd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {}})
-- remove multiple lines from the start of the file
command('normal! 4dd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 4, {}})
+ expectn('nvim_buf_update', {b, tick, 0, 4, {}})
-- remove multiple lines from middle of file
tick = reopen(b, origlines)
command('normal! jj3dd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 2, 5, {}})
+ expectn('nvim_buf_update', {b, tick, 2, 5, {}})
-- remove one line from the end of the file
tick = reopen(b, origlines)
command('normal! Gdd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 5, 6, {}})
+ expectn('nvim_buf_update', {b, tick, 5, 6, {}})
-- remove multiple lines from the end of the file
tick = reopen(b, origlines)
command('normal! 4G3dd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 6, {}})
+ expectn('nvim_buf_update', {b, tick, 3, 6, {}})
-- pretend to remove heaps lines from the end of the file but really
-- just remove two
tick = reopen(b, origlines)
command('normal! Gk5dd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 4, 6, {}})
+ expectn('nvim_buf_update', {b, tick, 4, 6, {}})
end)
it('knows when you modify lines of text', function()
@@ -234,53 +234,53 @@ describe('liveupdate', function()
-- some normal text editing
command('normal! A555')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'original line 1555'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'original line 1555'}})
command('normal! jj8X')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 2, 3, {'origin3'}})
+ expectn('nvim_buf_update', {b, tick, 2, 3, {'origin3'}})
-- modify multiple lines at once using visual block mode
tick = reopen(b, origlines)
command('normal! jjw')
sendkeys('\x16jjllx')
tick = tick + 1
- expectn('LiveUpdate',
+ expectn('nvim_buf_update',
{b, tick, 2, 5, {'original e 3', 'original e 4', 'original e 5'}})
-- replace part of a line line using :s
tick = reopen(b, origlines)
command('3s/line 3/foo/')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 2, 3, {'original foo'}})
+ expectn('nvim_buf_update', {b, tick, 2, 3, {'original foo'}})
-- replace parts of several lines line using :s
tick = reopen(b, origlines)
command('%s/line [35]/foo/')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 2, 5, {'original foo',
+ expectn('nvim_buf_update', {b, tick, 2, 5, {'original foo',
'original line 4',
'original foo'}})
-- type text into the first line of a blank file, one character at a time
command('enew!')
tick = 2
- expectn('LiveUpdateEnd', {b})
+ expectn('nvim_buf_updates_end', {b})
local bnew = nvim('get_current_buf')
- ok(buffer('live_updates_start', bnew, true))
- expectn('LiveUpdateStart', {bnew, tick, {''}, false})
+ ok(buffer('attach', bnew, true))
+ expectn('nvim_buf_updates_start', {bnew, tick, {''}, false})
sendkeys('i')
sendkeys('h')
sendkeys('e')
sendkeys('l')
sendkeys('l')
sendkeys('o\nworld')
- expectn('LiveUpdate', {bnew, tick + 1, 0, 1, {'h'}})
- expectn('LiveUpdate', {bnew, tick + 2, 0, 1, {'he'}})
- expectn('LiveUpdate', {bnew, tick + 3, 0, 1, {'hel'}})
- expectn('LiveUpdate', {bnew, tick + 4, 0, 1, {'hell'}})
- expectn('LiveUpdate', {bnew, tick + 5, 0, 1, {'hello'}})
- expectn('LiveUpdate', {bnew, tick + 6, 0, 1, {'hello', ''}})
- expectn('LiveUpdate', {bnew, tick + 7, 1, 2, {'world'}})
+ expectn('nvim_buf_update', {bnew, tick + 1, 0, 1, {'h'}})
+ expectn('nvim_buf_update', {bnew, tick + 2, 0, 1, {'he'}})
+ expectn('nvim_buf_update', {bnew, tick + 3, 0, 1, {'hel'}})
+ expectn('nvim_buf_update', {bnew, tick + 4, 0, 1, {'hell'}})
+ expectn('nvim_buf_update', {bnew, tick + 5, 0, 1, {'hello'}})
+ expectn('nvim_buf_update', {bnew, tick + 6, 0, 1, {'hello', ''}})
+ expectn('nvim_buf_update', {bnew, tick + 7, 1, 2, {'world'}})
end)
it('knows when you replace lines', function()
@@ -289,23 +289,23 @@ describe('liveupdate', function()
-- blast away parts of some lines with visual mode
command('normal! jjwvjjllx')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 2, 3, {'original '}})
+ expectn('nvim_buf_update', {b, tick, 2, 3, {'original '}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 4, {}})
+ expectn('nvim_buf_update', {b, tick, 3, 4, {}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 4, {'e 5'}})
+ expectn('nvim_buf_update', {b, tick, 3, 4, {'e 5'}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 2, 3, {'original e 5'}})
+ expectn('nvim_buf_update', {b, tick, 2, 3, {'original e 5'}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 4, {}})
+ expectn('nvim_buf_update', {b, tick, 3, 4, {}})
-- blast away a few lines using :g
tick = reopen(b, origlines)
command('global/line [35]/delete')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 2, 3, {}})
+ expectn('nvim_buf_update', {b, tick, 2, 3, {}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 4, {}})
+ expectn('nvim_buf_update', {b, tick, 3, 4, {}})
end)
it('knows when you filter lines', function()
@@ -317,9 +317,9 @@ describe('liveupdate', function()
-- 1) addition of the new lines after the filtered lines
-- 2) removal of the original lines
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 5, 5, {"C", "E", "B", "D"}})
+ expectn('nvim_buf_update', {b, tick, 5, 5, {"C", "E", "B", "D"}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 5, {}})
+ expectn('nvim_buf_update', {b, tick, 1, 5, {}})
end)
it('sends a sensible event when you use "o"', function()
@@ -329,37 +329,37 @@ describe('liveupdate', function()
-- use 'o' to start a new line from a line with no indent
command('normal! o')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 1, {""}})
+ expectn('nvim_buf_update', {b, tick, 1, 1, {""}})
-- undo the change, indent line 1 a bit, and try again
command('undo')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 2, {}})
+ expectn('nvim_buf_update', {b, tick, 1, 2, {}})
tick = tick + 1
- expectn('LiveUpdateTick', {b, tick})
+ expectn('nvim_buf_update_tick', {b, tick})
command('set autoindent')
command('normal! >>')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {"\tAAA"}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {"\tAAA"}})
command('normal! ommm')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 1, {"\t"}})
+ expectn('nvim_buf_update', {b, tick, 1, 1, {"\t"}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 2, {"\tmmm"}})
+ expectn('nvim_buf_update', {b, tick, 1, 2, {"\tmmm"}})
-- undo the change, and try again with 'O'
command('undo')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 2, {'\t'}})
+ expectn('nvim_buf_update', {b, tick, 1, 2, {'\t'}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 2, {}})
+ expectn('nvim_buf_update', {b, tick, 1, 2, {}})
tick = tick + 1
- expectn('LiveUpdateTick', {b, tick})
+ expectn('nvim_buf_update_tick', {b, tick})
command('normal! ggOmmm')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 0, {"\t"}})
+ expectn('nvim_buf_update', {b, tick, 0, 0, {"\t"}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {"\tmmm"}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {"\tmmm"}})
end)
it('deactivates when your buffer changes outside vim', function()
@@ -369,12 +369,12 @@ describe('liveupdate', function()
command('normal! x')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'ine 1'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'ine 1'}})
command('undo')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'Line 1'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'Line 1'}})
tick = tick + 1
- expectn('LiveUpdateTick', {b, tick})
+ expectn('nvim_buf_update_tick', {b, tick})
-- change the file directly
local f = io.open(filename, 'a')
@@ -384,7 +384,7 @@ describe('liveupdate', function()
-- reopen the file and watch live updates shut down
command('edit')
- expectn('LiveUpdateEnd', {b})
+ expectn('nvim_buf_updates_end', {b})
end)
it('allows a channel to watch multiple buffers at once', function()
@@ -405,32 +405,32 @@ describe('liveupdate', function()
command('b'..b1nr)
command('normal! x')
tick1 = tick1 + 1
- expectn('LiveUpdate', {b1, tick1, 0, 1, {'1'}})
+ expectn('nvim_buf_update', {b1, tick1, 0, 1, {'1'}})
command('undo')
tick1 = tick1 + 1
- expectn('LiveUpdate', {b1, tick1, 0, 1, {'A1'}})
+ expectn('nvim_buf_update', {b1, tick1, 0, 1, {'A1'}})
tick1 = tick1 + 1
- expectn('LiveUpdateTick', {b1, tick1})
+ expectn('nvim_buf_update_tick', {b1, tick1})
command('b'..b2nr)
command('normal! x')
tick2 = tick2 + 1
- expectn('LiveUpdate', {b2, tick2, 0, 1, {'1'}})
+ expectn('nvim_buf_update', {b2, tick2, 0, 1, {'1'}})
command('undo')
tick2 = tick2 + 1
- expectn('LiveUpdate', {b2, tick2, 0, 1, {'B1'}})
+ expectn('nvim_buf_update', {b2, tick2, 0, 1, {'B1'}})
tick2 = tick2 + 1
- expectn('LiveUpdateTick', {b2, tick2})
+ expectn('nvim_buf_update_tick', {b2, tick2})
command('b'..b3nr)
command('normal! x')
tick3 = tick3 + 1
- expectn('LiveUpdate', {b3, tick3, 0, 1, {'1'}})
+ expectn('nvim_buf_update', {b3, tick3, 0, 1, {'1'}})
command('undo')
tick3 = tick3 + 1
- expectn('LiveUpdate', {b3, tick3, 0, 1, {'C1'}})
+ expectn('nvim_buf_update', {b3, tick3, 0, 1, {'C1'}})
tick3 = tick3 + 1
- expectn('LiveUpdateTick', {b3, tick3})
+ expectn('nvim_buf_update_tick', {b3, tick3})
end)
it('doesn\'t get confused when you turn watching on/off many times',
@@ -439,22 +439,22 @@ describe('liveupdate', function()
local b, tick = editoriginal(false)
-- turn on live updates many times
- ok(buffer('live_updates_start', b, true))
- ok(buffer('live_updates_start', b, true))
- ok(buffer('live_updates_start', b, true))
- ok(buffer('live_updates_start', b, true))
- ok(buffer('live_updates_start', b, true))
- expectn('LiveUpdateStart', {b, tick, origlines, false})
+ ok(buffer('attach', b, true))
+ ok(buffer('attach', b, true))
+ ok(buffer('attach', b, true))
+ ok(buffer('attach', b, true))
+ ok(buffer('attach', b, true))
+ expectn('nvim_buf_updates_start', {b, tick, origlines, false})
eval('rpcnotify('..channel..', "Hello There")')
expectn('Hello There', {})
-- turn live updates off many times
- ok(buffer('live_updates_stop', b))
- ok(buffer('live_updates_stop', b))
- ok(buffer('live_updates_stop', b))
- ok(buffer('live_updates_stop', b))
- ok(buffer('live_updates_stop', b))
- expectn('LiveUpdateEnd', {b})
+ ok(buffer('detach', b))
+ ok(buffer('detach', b))
+ ok(buffer('detach', b))
+ ok(buffer('detach', b))
+ ok(buffer('detach', b))
+ expectn('nvim_buf_updates_end', {b})
eval('rpcnotify('..channel..', "Hello Again")')
expectn('Hello Again', {})
end)
@@ -488,46 +488,46 @@ describe('liveupdate', function()
local b, tick = open(false, lines)
-- turn on live updates for sessions 1, 2 and 3
- ok(request(1, 'nvim_buf_live_updates_start', b, true))
- ok(request(2, 'nvim_buf_live_updates_start', b, true))
- ok(request(3, 'nvim_buf_live_updates_start', b, true))
- wantn(1, 'LiveUpdateStart', {b, tick, lines, false})
- wantn(2, 'LiveUpdateStart', {b, tick, lines, false})
- wantn(3, 'LiveUpdateStart', {b, tick, lines, false})
+ ok(request(1, 'nvim_buf_attach', b, true))
+ ok(request(2, 'nvim_buf_attach', b, true))
+ ok(request(3, 'nvim_buf_attach', b, true))
+ wantn(1, 'nvim_buf_updates_start', {b, tick, lines, false})
+ wantn(2, 'nvim_buf_updates_start', {b, tick, lines, false})
+ wantn(3, 'nvim_buf_updates_start', {b, tick, lines, false})
-- make a change to the buffer
command('normal! x')
tick = tick + 1
- wantn(1, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
- wantn(2, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
- wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
+ wantn(1, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+ wantn(2, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+ wantn(3, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
-- stop watching on channel 1
- ok(request(1, 'nvim_buf_live_updates_stop', b))
- wantn(1, 'LiveUpdateEnd', {b})
+ ok(request(1, 'nvim_buf_detach', b))
+ wantn(1, 'nvim_buf_updates_end', {b})
-- undo the change to buffer 1
command('undo')
tick = tick + 1
- wantn(2, 'LiveUpdate', {b, tick, 0, 1, {'AAA'}})
- wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+ wantn(2, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
+ wantn(3, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
tick = tick + 1
- wantn(2, 'LiveUpdateTick', {b, tick})
- wantn(3, 'LiveUpdateTick', {b, tick})
+ wantn(2, 'nvim_buf_update_tick', {b, tick})
+ wantn(3, 'nvim_buf_update_tick', {b, tick})
- -- make sure there are no other pending LiveUpdate messages going to
+ -- make sure there are no other pending nvim_buf_update messages going to
-- channel 1
local channel1 = request(1, 'nvim_get_api_info')[1]
eval('rpcnotify('..channel1..', "Hello")')
wantn(1, 'Hello', {})
- -- close the buffer and channels 2 and 3 should get a LiveUpdateEnd
+ -- close the buffer and channels 2 and 3 should get a nvim_buf_updates_end
-- notification
command('edit')
- wantn(2, 'LiveUpdateEnd', {b})
- wantn(3, 'LiveUpdateEnd', {b})
+ wantn(2, 'nvim_buf_updates_end', {b})
+ wantn(3, 'nvim_buf_updates_end', {b})
- -- make sure there are no other pending LiveUpdate messages going to
+ -- make sure there are no other pending nvim_buf_update messages going to
-- channel 1
channel1 = request(1, 'nvim_get_api_info')[1]
eval('rpcnotify('..channel1..', "Hello Again")')
@@ -550,13 +550,13 @@ describe('liveupdate', function()
command('normal! gg')
command('diffput')
tick2 = tick2 + 1
- expectn('LiveUpdate', {b2, tick2, 0, 0, {"AAA"}})
+ expectn('nvim_buf_update', {b2, tick2, 0, 0, {"AAA"}})
-- use :diffget to grab the other change from buffer 2
command('normal! G')
command('diffget')
tick1 = tick1 + 1
- expectn('LiveUpdate', {b1, tick1, 2, 2, {"CCC"}})
+ expectn('nvim_buf_update', {b1, tick1, 2, 2, {"CCC"}})
eval('rpcnotify('..channel..', "Goodbye")')
expectn('Goodbye', {})
@@ -567,14 +567,14 @@ describe('liveupdate', function()
local b, tick = editoriginal(true, {"B", "D", "C", "A", "E"})
command('%sort')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 5, {"A", "B", "C", "D", "E"}})
+ expectn('nvim_buf_update', {b, tick, 0, 5, {"A", "B", "C", "D", "E"}})
end)
it('works with :left', function()
local b, tick = editoriginal(true, {" A", " B", "B", "\tB", "\t\tC"})
command('2,4left')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 4, {"B", "B", "B"}})
+ expectn('nvim_buf_update', {b, tick, 1, 4, {"B", "B", "B"}})
end)
it('works with :right', function()
@@ -586,7 +586,7 @@ describe('liveupdate', function()
command('set ts=2 et')
command('2,4retab')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 4, {" B", " BB", " B"}})
+ expectn('nvim_buf_update', {b, tick, 1, 4, {" B", " BB", " B"}})
end)
it('works with :move', function()
@@ -594,19 +594,19 @@ describe('liveupdate', function()
-- move text down towards the end of the file
command('2,3move 4')
tick = tick + 2
- expectn('LiveUpdate', {b, tick, 4, 4, {"original line 2",
+ expectn('nvim_buf_update', {b, tick, 4, 4, {"original line 2",
"original line 3"}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 3, {}})
+ expectn('nvim_buf_update', {b, tick, 1, 3, {}})
-- move text up towards the start of the file
tick = reopen(b, origlines)
command('4,5move 2')
tick = tick + 2
- expectn('LiveUpdate', {b, tick, 2, 2, {"original line 4",
+ expectn('nvim_buf_update', {b, tick, 2, 2, {"original line 4",
"original line 5"}})
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 5, 7, {}})
+ expectn('nvim_buf_update', {b, tick, 5, 7, {}})
end)
it('sends sensible events when you manually add/remove folds', function()
@@ -616,13 +616,13 @@ describe('liveupdate', function()
-- delete the inner fold
command('normal! zR3Gzd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 1, 4, {'original line 2',
+ expectn('nvim_buf_update', {b, tick, 1, 4, {'original line 2',
'original line 3',
'original line 4'}})
-- delete the outer fold
command('normal! zd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+ expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
-- discard changes and put the folds back
tick = reopenwithfolds(b)
@@ -630,7 +630,7 @@ describe('liveupdate', function()
-- remove both folds at once
command('normal! ggzczD')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+ expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
-- discard changes and put the folds back
tick = reopenwithfolds(b)
@@ -638,17 +638,17 @@ describe('liveupdate', function()
-- now delete all folds at once
command('normal! zE')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+ expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
-- create a fold from line 4 to the end of the file
command('normal! 4GA/*{{{*/')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 4, {'original line 4/*{{{*/'}})
+ expectn('nvim_buf_update', {b, tick, 3, 4, {'original line 4/*{{{*/'}})
-- delete the fold which only has one marker
command('normal! Gzd')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 3, 6, {'original line 4',
+ expectn('nvim_buf_update', {b, tick, 3, 6, {'original line 4',
'original line 5',
'original line 6'}})
end)
@@ -660,16 +660,16 @@ describe('liveupdate', function()
-- test live updates are working
command('normal! x')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
command('undo')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
tick = tick + 1
- expectn('LiveUpdateTick', {b, tick})
+ expectn('nvim_buf_update_tick', {b, tick})
-- close our buffer by creating a new one
command('enew')
- expectn('LiveUpdateEnd', {b})
+ expectn('nvim_buf_updates_end', {b})
-- reopen the original buffer, make sure there are no Live Updates sent
command('b1')
@@ -687,18 +687,18 @@ describe('liveupdate', function()
-- test live updates are working
command('normal! x')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
command('undo')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
tick = tick + 1
- expectn('LiveUpdateTick', {b, tick})
+ expectn('nvim_buf_update_tick', {b, tick})
-- close our buffer by creating a new one
command('set hidden')
command('enew')
- -- note that no LiveUpdateEnd is sent
+ -- note that no nvim_buf_updates_end is sent
eval('rpcnotify('..channel..', "Hello There")')
expectn('Hello There', {})
@@ -706,7 +706,7 @@ describe('liveupdate', function()
command('b1')
command('normal! x')
tick = tick + 1
- expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+ expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
end)
it('turns off live updates when a buffer is unloaded, deleted, or wiped',
@@ -721,17 +721,17 @@ describe('liveupdate', function()
local b = open(true, {'AAA'})
-- call :bunload or whatever the command is, and then check that we
- -- receive a LiveUpdateEnd
+ -- receive a nvim_buf_updates_end
command(cmd)
- expectn('LiveUpdateEnd', {b})
+ expectn('nvim_buf_updates_end', {b})
end
end)
it('doesn\'t send the buffer\'s content when not requested', function()
helpers.clear()
local b, tick = editoriginal(false)
- ok(buffer('live_updates_start', b, false))
- expectn('LiveUpdateStart', {b, tick, {}, false})
+ ok(buffer('attach', b, false))
+ expectn('nvim_buf_updates_start', {b, tick, {}, false})
end)
end)
generated by cgit (git 2.34.1) at 2025-04-28 22:10:57 +0000