Patch 8.2.4981

[Bram Moolenaar]

Patch 8.2.4981
Problem: It is not possible to manipulate autocommands.
Solution: Add functions to add, get and set autocommands. (Yegappan
Lakshmanan, closes #10291)
Files: runtime/doc/autocmd.txt, runtime/doc/builtin.txt,
runtime/doc/usr_41.txt, src/autocmd.c, src/evalfunc.c,
src/proto/autocmd.pro, src/testdir/test_autocmd.vim,
src/testdir/test_vim9_builtin.vim


*** ../vim-8.2.4980/runtime/doc/autocmd.txt 2022-04-09 11:37:08.196325535 +0100
--- runtime/doc/autocmd.txt 2022-05-19 10:22:46.206265964 +0100
***************
*** 82,89 ****
/<start
}

Note: The ":autocmd" command can only be followed by another command when the
! '|' appears before {cmd}. This works: >
:augroup mine | au! BufRead | augroup END
But this sees "augroup" as part of the defined command: >
:augroup mine | au! BufRead * | augroup END
--- 82,92 ----
/<start
}

+ The |autocmd_add()| function can be used to add a list of autocmds and autocmd
+ groups from a Vim script.
+
Note: The ":autocmd" command can only be followed by another command when the
! '|' appears where the pattern is expected. This works: >
:augroup mine | au! BufRead | augroup END
But this sees "augroup" as part of the defined command: >
:augroup mine | au! BufRead * | augroup END
***************
*** 145,163 ****
==============================================================================
3. Removing autocommands *autocmd-remove*

! :au[tocmd]! [group] {event} {pat} [++once] [++nested] {cmd}
Remove all autocommands associated with {event} and
! {pat}, and add the command {cmd}.
See |autocmd-once| for [++once].
See |autocmd-nested| for [++nested].

! :au[tocmd]! [group] {event} {pat}
Remove all autocommands associated with {event} and
! {pat}.

! :au[tocmd]! [group] * {pat}
! Remove all autocommands associated with {pat} for all
! events.

:au[tocmd]! [group] {event}
Remove ALL autocommands for {event}.
--- 149,170 ----
==============================================================================
3. Removing autocommands *autocmd-remove*

! In addition to the below described commands, the |autocmd_delete()| function can
! be used to remove a list of autocmds and autocmd groups from a Vim script.
!
! :au[tocmd]! [group] {event} {aupat} [++once] [++nested] {cmd}
Remove all autocommands associated with {event} and
! {aupat}, and add the command {cmd}.
See |autocmd-once| for [++once].
See |autocmd-nested| for [++nested].

! :au[tocmd]! [group] {event} {aupat}
Remove all autocommands associated with {event} and
! {aupat}.

! :au[tocmd]! [group] * {aupat}
! Remove all autocommands associated with {aupat} for
! all events.

:au[tocmd]! [group] {event}
Remove ALL autocommands for {event}.
***************
*** 197,202 ****
--- 204,212 ----
In order to list buffer-local autocommands, use a pattern in the form <buffer>
or <buffer=N>. See |autocmd-buflocal|.

+ The |autocmd_get()| function can be used from a Vim script to get a list of
+ autocmds.
+
*:autocmd-verbose*
When 'verbose' is non-zero, listing an autocommand will also display where it
was last defined. Example: >
*** ../vim-8.2.4980/runtime/doc/builtin.txt 2022-05-11 14:15:32.339235975 +0100
--- runtime/doc/builtin.txt 2022-05-19 10:22:46.206265964 +0100
***************
*** 60,65 ****
--- 60,68 ----
assert_true({actual} [, {msg}]) Number assert {actual} is true
atan({expr}) Float arc tangent of {expr}
atan2({expr1}, {expr2}) Float arc tangent of {expr1} / {expr2}
+ autocmd_add({acmds}) Bool add a list of autocmds and groups
+ autocmd_delete({acmds}) Bool delete a list of autocmds and groups
+ autocmd_get([{opts}]) List return a list of autocmds
balloon_gettext() String current text in the balloon
balloon_show({expr}) none show {expr} inside the balloon
balloon_split({msg}) List split {msg} as used for a balloon
***************
*** 922,927 ****
--- 925,1069 ----
<
{only available when compiled with the |+float| feature}

+
+ autocmd_add({acmds}) *autocmd_add()*
+ Adds a List of autocmds and autocmd groups.
+
+ The {acmds} argument is a List where each item is a Dict with
+ the following optional items:
+ bufnr buffer number to add a buffer-local autocmd.
+ If this item is specified, then the "pattern"
+ item is ignored.
+ cmd Ex command to execute for this autocmd event
+ event autocmd event name. Refer to |autocmd-events|.
+ group autocmd group name. Refer to |autocmd-groups|.
+ If this group doesn't exist then it is
+ created. If not specified or empty, then the
+ default group is used.
+ nested set to v:true to add a nested autocmd.
+ Refer to |autocmd-nested|.
+ once set to v:true to add a autocmd which executes
+ only once. Refer to |autocmd-once|.
+ pattern autocmd pattern string. Refer to
+ |autocmd-patterns|. If "bufnr" item is
+ present, then this item is ignored.
+
+ Returns v:true on success and v:false on failure.
+ Examples: >
+ " Create a buffer-local autocmd for buffer 5
+ let acmd = {}
+ let acmd.group = 'MyGroup'
+ let acmd.event = 'BufEnter'
+ let acmd.bufnr = 5
+ let acmd.cmd = 'call BufEnterFunc()'
+ call autocmd_add([acmd])
+
+ Can also be used as a |method|: >
+ GetAutocmdList()->autocmd_add()
+ <
+ autocmd_delete({acmds}) *autocmd_delete()*
+ Deletes a List of autocmds and autocmd groups.
+
+ The {acmds} argument is a List where each item is a Dict with
+ the following optional items:
+ bufnr buffer number to delete a buffer-local autocmd.
+ If this item is specified, then the "pattern"
+ item is ignored.
+ cmd Ex command for this autocmd event
+ event autocmd event name. Refer to |autocmd-events|.
+ If '*' then all the autocmd events in this
+ group are deleted.
+ group autocmd group name. Refer to |autocmd-groups|.
+ If not specified or empty, then the default
+ group is used.
+ nested set to v:true for a nested autocmd.
+ Refer to |autocmd-nested|.
+ once set to v:true for an autocmd which executes
+ only once. Refer to |autocmd-once|.
+ pattern autocmd pattern string. Refer to
+ |autocmd-patterns|. If "bufnr" item is
+ present, then this item is ignored.
+
+ If only {group} is specified in a {acmds} entry and {event},
+ {pattern} and {cmd} are not specified, then that autocmd group
+ is deleted.
+
+ Returns v:true on success and v:false on failure.
+ Examples: >
+ " :autocmd! BufLeave *.vim
+ let acmd = #{event: 'BufLeave', pattern: '*.vim'}
+ call autocmd_delete([acmd]})
+ " :autocmd! MyGroup1 BufLeave
+ let acmd = #{group: 'MyGroup1', event: 'BufLeave'}
+ call autocmd_delete([acmd])
+ " :autocmd! MyGroup2 BufEnter *.c
+ let acmd = #{group: 'MyGroup2', event: 'BufEnter',
+ \ pattern: '*.c'}
+ " :autocmd! MyGroup2 * *.c
+ let acmd = #{group: 'MyGroup2', event: '*',
+ \ pattern: '*.c'}
+ call autocmd_delete([acmd])
+ " :autocmd! MyGroup3
+ let acmd = #{group: 'MyGroup3'}
+ call autocmd_delete([acmd])
+ <
+ Can also be used as a |method|: >
+ GetAutocmdList()->autocmd_delete()
+
+ autocmd_get([{opts}]) *autocmd_get()*
+ Returns a |List| of autocmds. If {opts} is not supplied, then
+ returns the autocmds for all the events in all the groups.
+
+ The optional {opts} Dict argument supports the following
+ items:
+ group Autocmd group name. If specified, returns only
+ the autocmds defined in this group. If the
+ specified group doesn't exist, results in an
+ error message. If set to an empty string,
+ then the default autocmd group is used.
+ event Autocmd event name. If specified, returns only
+ the autocmds defined for this event. If set
+ to "*", then returns autocmds for all the
+ events. If the specified event doesn't exist,
+ results in an error message.
+ pattern Autocmd pattern. If specified, returns only
+ the autocmds defined for this pattern.
+ A combination of the above three times can be supplied in
+ {opts}.
+
+ Each Dict in the returned List contains the following items:
+ bufnr For buffer-local autocmds, buffer number where
+ the autocmd is defined.
+ cmd Command executed for this autocmd.
+ event Autocmd event name.
+ group Autocmd group name.
+ nested Set to v:true for a nested autocmd. See
+ |autocmd-nested|.
+ once Set to v:true, if the autocmd will be executed
+ only once. See |autocmd-once|.
+ pattern Autocmd pattern. For a buffer-local
+ autocmd, this will be of the form "<buffer=n>".
+ If there are multiple commands for an autocmd event in a
+ group, then separate items are returned for each command.
+
+ Examples: >
+ " :autocmd MyGroup
+ echo autocmd_get(#{group: 'Mygroup'})
+ " :autocmd G BufUnload
+ echo autocmd_get(#{group: 'G', event: 'BufUnload'})
+ " :autocmd G * *.ts
+ let acmd = #{group: 'G', event: '*', pattern: '*.ts'}
+ echo autocmd_get(acmd)
+ " :autocmd Syntax
+ echo autocmd_get(#{event: 'Syntax'})
+ " :autocmd G BufEnter *.ts
+ let acmd = #{group: 'G', event: 'BufEnter',
+ \ pattern: '*.ts'}
+ echo autocmd_get(acmd)
+ <
+ Can also be used as a |method|: >
+ Getopts()->autocmd_get()
+ <
balloon_gettext() *balloon_gettext()*
Return the current text in the balloon. Only for the string,
not used for the List.
*** ../vim-8.2.4980/runtime/doc/usr_41.txt 2022-05-07 12:48:24.070194799 +0100
--- runtime/doc/usr_41.txt 2022-05-19 10:22:46.206265964 +0100
***************
*** 844,849 ****
--- 925,935 ----
reltimestr() convert reltime() result to a string
reltimefloat() convert reltime() result to a Float

+ Autocmds: *autocmd-functions*
+ autocmd_add() add a list of autocmds and groups
+ autocmd_delete() delete a list of autocmds and groups
+ autocmd_get() return a list of autocmds
+
*buffer-functions* *window-functions* *arg-functions*
Buffers, windows and the argument list:
argc() number of entries in the argument list
*** ../vim-8.2.4980/src/autocmd.c 2022-05-07 20:01:10.050731702 +0100
--- src/autocmd.c 2022-05-19 10:27:53.505876019 +0100
***************
*** 2562,2568 ****
{
if (idx == augroups.ga_len) // add "END" add the end
return (char_u *)"END";
! if (idx >= augroups.ga_len) // end of list
return NULL;
if (AUGROUP_NAME(idx) == NULL || AUGROUP_NAME(idx) == get_deleted_augroup())
// skip deleted entries
--- 2562,2568 ----
{
if (idx == augroups.ga_len) // add "END" add the end
return (char_u *)"END";
! if (idx < 0 || idx >= augroups.ga_len) // end of list
return NULL;
if (AUGROUP_NAME(idx) == NULL || AUGROUP_NAME(idx) == get_deleted_augroup())
// skip deleted entries
***************
*** 2747,2750 ****
--- 2747,3101 ----
vim_free(arg_save);
return retval;
}
+
+ /*
+ * autocmd_add() and autocmd_delete() functions
+ */
+ static void
+ autocmd_add_or_delete(typval_T *argvars, typval_T *rettv, int delete)
+ {
+ list_T *event_list;
+ listitem_T *li;
+ dict_T *event_dict;
+ char_u *event_name = NULL;
+ event_T event;
+ char_u *group_name = NULL;
+ int group;
+ char_u *pat = NULL;
+ char_u *cmd = NULL;
+ char_u *end;
+ int once;
+ int nested;
+ int retval = VVAL_TRUE;
+ int save_augroup = current_augroup;
+
+ rettv->v_type = VAR_BOOL;
+ rettv->vval.v_number = VVAL_FALSE;
+
+ if (check_for_list_arg(argvars, 0) == FAIL)
+ return;
+
+ event_list = argvars[0].vval.v_list;
+ if (event_list == NULL)
+ return;
+
+ FOR_ALL_LIST_ITEMS(event_list, li)
+ {
+ VIM_CLEAR(event_name);
+ VIM_CLEAR(group_name);
+ VIM_CLEAR(pat);
+ VIM_CLEAR(cmd);
+
+ if (li->li_tv.v_type != VAR_DICT)
+ continue;
+
+ event_dict = li->li_tv.vval.v_dict;
+ if (event_dict == NULL)
+ continue;
+
+ event_name = dict_get_string(event_dict, (char_u *)"event", TRUE);
+ if (event_name == NULL)
+ {
+ if (delete)
+ // if the event name is not specified, delete all the events
+ event = NUM_EVENTS;
+ else
+ continue;
+ }
+ else
+ {
+ if (delete && event_name[0] == '*' && event_name[1] == NUL)
+ // if the event name is '*', delete all the events
+ event = NUM_EVENTS;
+ else
+ {
+ event = event_name2nr(event_name, &end);
+ if (event == NUM_EVENTS)
+ {
+ semsg(_(e_no_such_event_str), event_name);
+ retval = VVAL_FALSE;
+ break;
+ }
+ }
+ }
+
+ group_name = dict_get_string(event_dict, (char_u *)"group", TRUE);
+ if (group_name == NULL || *group_name == NUL)
+ // if the autocmd group name is not specified, then use the current
+ // autocmd group
+ group = current_augroup;
+ else
+ {
+ group = au_find_group(group_name);
+ if (group == AUGROUP_ERROR)
+ {
+ if (delete)
+ {
+ semsg(_(e_no_such_group_str), group_name);
+ retval = VVAL_FALSE;
+ break;
+ }
+ // group is not found, create it now
+ group = au_new_group(group_name);
+ if (group == AUGROUP_ERROR)
+ {
+ semsg(_(e_no_such_group_str), group_name);
+ retval = VVAL_FALSE;
+ break;
+ }
+
+ current_augroup = group;
+ }
+ }
+
+ // if a buffer number is specified, then generate a pattern of the form
+ // "<buffer=n>. Otherwise, use the pattern supplied by the user.
+ if (dict_has_key(event_dict, "bufnr"))
+ {
+ varnumber_T bnum;
+
+ bnum = dict_get_number_def(event_dict, (char_u *)"bufnr", -1);
+ if (bnum == -1)
+ continue;
+
+ pat = alloc(128 + 1);
+ if (pat == NULL)
+ continue;
+ vim_snprintf((char *)pat, 128, "<buffer=%d>", (int)bnum);
+ }
+ else
+ {
+ pat = dict_get_string(event_dict, (char_u *)"pattern", TRUE);
+ if (pat == NULL)
+ {
+ if (delete)
+ pat = vim_strsave((char_u *)"");
+ else
+ continue;
+ }
+ }
+
+ once = dict_get_bool(event_dict, (char_u *)"once", FALSE);
+ nested = dict_get_bool(event_dict, (char_u *)"nested", FALSE);
+
+ cmd = dict_get_string(event_dict, (char_u *)"cmd", TRUE);
+ if (cmd == NULL)
+ {
+ if (delete)
+ cmd = vim_strsave((char_u *)"");
+ else
+ continue;
+ }
+
+ if (event == NUM_EVENTS)
+ {
+ // event is '*', apply for all the events
+ for (event = (event_T)0; (int)event < NUM_EVENTS;
+ event = (event_T)((int)event + 1))
+ {
+ if (do_autocmd_event(event, pat, once, nested, cmd, delete,
+ group, 0) == FAIL)
+ {
+ retval = VVAL_FALSE;
+ break;
+ }
+ }
+ }
+ else
+ {
+ if (do_autocmd_event(event, pat, once, nested, cmd, delete, group,
+ 0) == FAIL)
+ {
+ retval = VVAL_FALSE;
+ break;
+ }
+ }
+
+ // if only the autocmd group name is specified for delete and the
+ // autocmd event, pattern and cmd are not specified, then delete the
+ // autocmd group.
+ if (delete && group_name != NULL &&
+ (event_name == NULL || event_name[0] == NUL)
+ && (pat == NULL || pat[0] == NUL)
+ && (cmd == NULL || cmd[0] == NUL))
+ au_del_group(group_name);
+ }
+
+ VIM_CLEAR(event_name);
+ VIM_CLEAR(group_name);
+ VIM_CLEAR(pat);
+ VIM_CLEAR(cmd);
+
+ current_augroup = save_augroup;
+ rettv->vval.v_number = retval;
+ }
+
+ /*
+ * autocmd_add() function
+ */
+ void
+ f_autocmd_add(typval_T *argvars, typval_T *rettv)
+ {
+ autocmd_add_or_delete(argvars, rettv, FALSE);
+ }
+
+ /*
+ * autocmd_delete() function
+ */
+ void
+ f_autocmd_delete(typval_T *argvars, typval_T *rettv)
+ {
+ autocmd_add_or_delete(argvars, rettv, TRUE);
+ }
+
+ /*
+ * autocmd_get() function
+ * Returns a List of autocmds.
+ */
+ void
+ f_autocmd_get(typval_T *argvars, typval_T *rettv)
+ {
+ event_T event_arg = NUM_EVENTS;
+ event_T event;
+ AutoPat *ap;
+ AutoCmd *ac;
+ list_T *event_list;
+ dict_T *event_dict;
+ char_u *event_name = NULL;
+ char_u *pat = NULL;
+ char_u *name = NULL;
+ int group = AUGROUP_ALL;
+
+ if (check_for_opt_dict_arg(argvars, 0) == FAIL)
+ return;
+
+ if (argvars[0].v_type == VAR_DICT)
+ {
+ // return only the autocmds in the specified group
+ if (dict_has_key(argvars[0].vval.v_dict, "group"))
+ {
+ name = dict_get_string(argvars[0].vval.v_dict,
+ (char_u *)"group", TRUE);
+ if (name == NULL)
+ return;
+
+ if (*name == NUL)
+ group = AUGROUP_DEFAULT;
+ else
+ {
+ group = au_find_group(name);
+ if (group == AUGROUP_ERROR)
+ {
+ semsg(_(e_no_such_group_str), name);
+ vim_free(name);
+ return;
+ }
+ }
+ vim_free(name);
+ }
+
+ // return only the autocmds for the specified event
+ if (dict_has_key(argvars[0].vval.v_dict, "event"))
+ {
+ int i;
+
+ name = dict_get_string(argvars[0].vval.v_dict,
+ (char_u *)"event", TRUE);
+ if (name == NULL)
+ return;
+
+ if (name[0] == '*' && name[1] == NUL)
+ event_arg = NUM_EVENTS;
+ else
+ {
+ for (i = 0; event_names[i].name != NULL; i++)
+ if (STRICMP(event_names[i].name, name) == 0)
+ break;
+ if (event_names[i].name == NULL)
+ {
+ semsg(_(e_no_such_event_str), name);
+ vim_free(name);
+ return;
+ }
+ event_arg = event_names[i].event;
+ }
+ vim_free(name);
+ }
+
+ // return only the autocmds for the specified pattern
+ if (dict_has_key(argvars[0].vval.v_dict, "pattern"))
+ {
+ pat = dict_get_string(argvars[0].vval.v_dict,
+ (char_u *)"pattern", TRUE);
+ if (pat == NULL)
+ return;
+ }
+ }
+
+ if (rettv_list_alloc(rettv) == FAIL)
+ return;
+ event_list = rettv->vval.v_list;
+
+ // iterate through all the autocmd events
+ for (event = (event_T)0; (int)event < NUM_EVENTS;
+ event = (event_T)((int)event + 1))
+ {
+ if (event_arg != NUM_EVENTS && event != event_arg)
+ continue;
+
+ event_name = event_nr2name(event);
+
+ // iterate through all the patterns for this autocmd event
+ FOR_ALL_AUTOCMD_PATTERNS(event, ap)
+ {
+ char_u *group_name;
+
+ if (group != AUGROUP_ALL && group != ap->group)
+ continue;
+
+ if (pat != NULL && STRCMP(pat, ap->pat) != 0)
+ continue;
+
+ group_name = get_augroup_name(NULL, ap->group);
+
+ // iterate through all the commands for this pattern and add one
+ // item for each cmd.
+ for (ac = ap->cmds; ac != NULL; ac = ac->next)
+ {
+ event_dict = dict_alloc();
+ if (event_dict == NULL)
+ return;
+
+ if (list_append_dict(event_list, event_dict) == FAIL)
+ return;
+
+ if (dict_add_string(event_dict, "event", event_name) == FAIL)
+ return;
+
+ if (dict_add_string(event_dict, "group", group_name == NULL
+ ? (char_u *)"" : group_name) == FAIL)
+ return;
+
+ if (ap->buflocal_nr != 0)
+ if (dict_add_number(event_dict, "bufnr", ap->buflocal_nr)
+ == FAIL)
+ return;
+
+ if (dict_add_string(event_dict, "pattern", ap->pat) == FAIL)
+ return;
+
+ if (dict_add_string(event_dict, "cmd", ac->cmd) == FAIL)
+ return;
+
+ if (dict_add_bool(event_dict, "once", ac->once) == FAIL)
+ return;
+ if (dict_add_bool(event_dict, "nested", ac->nested) == FAIL)
+ return;
+ }
+ }
+ }
+
+ vim_free(pat);
+ }
+
#endif
*** ../vim-8.2.4980/src/evalfunc.c 2022-05-15 13:59:08.700167480 +0100
--- src/evalfunc.c 2022-05-19 10:22:46.206265964 +0100
***************
*** 1587,1592 ****
--- 1587,1598 ----
ret_float, FLOAT_FUNC(f_atan)},
{"atan2", 2, 2, FEARG_1, arg2_float_or_nr,
ret_float, FLOAT_FUNC(f_atan2)},
+ {"autocmd_add", 1, 1, FEARG_1, arg1_list_any,
+ ret_number_bool, f_autocmd_add},
+ {"autocmd_delete", 1, 1, FEARG_1, arg1_list_any,
+ ret_number_bool, f_autocmd_delete},
+ {"autocmd_get", 0, 1, FEARG_1, arg1_dict_any,
+ ret_list_dict_any, f_autocmd_get},
{"balloon_gettext", 0, 0, 0, NULL,
ret_string,
#ifdef FEAT_BEVAL
*** ../vim-8.2.4980/src/proto/autocmd.pro 2022-04-14 15:39:39.281754582 +0100
--- src/proto/autocmd.pro 2022-05-19 10:22:46.210265958 +0100
***************
*** 38,41 ****
--- 38,44 ----
char_u *get_event_name(expand_T *xp, int idx);
int autocmd_supported(char_u *name);
int au_exists(char_u *arg);
+ void f_autocmd_add(typval_T *argvars, typval_T *rettv);
+ void f_autocmd_delete(typval_T *argvars, typval_T *rettv);
+ void f_autocmd_get(typval_T *argvars, typval_T *rettv);
/* vim: set ft=c : */
*** ../vim-8.2.4980/src/testdir/test_autocmd.vim 2022-04-21 22:52:07.062317208 +0100
--- src/testdir/test_autocmd.vim 2022-05-19 10:22:46.210265958 +0100
***************
*** 3210,3213 ****
--- 3210,3483 ----
augroup! test_noname_autocmd_group
endfunc

+ " Test for the autocmd_get() function
+ func Test_autocmd_get()
+ augroup TestAutoCmdFns
+ au!
+ autocmd BufAdd *.vim echo "bufadd-vim"
+ autocmd BufAdd *.py echo "bufadd-py"
+ autocmd BufHidden *.vim echo "bufhidden"
+ augroup END
+ augroup TestAutoCmdFns2
+ autocmd BufAdd *.vim echo "bufadd-vim-2"
+ autocmd BufRead *.a1b2c3 echo "bufadd-vim-2"
+ augroup END
+
+ let l = autocmd_get()
+ call assert_true(l->len() > 0)
+
+ " Test for getting all the autocmds in a group
+ let expected = [
+ \ #{cmd: 'echo "bufadd-vim"', group: 'TestAutoCmdFns',
+ \ pattern: '*.vim', nested: v:false, once: v:false,
+ \ event: 'BufAdd'},
+ \ #{cmd: 'echo "bufadd-py"', group: 'TestAutoCmdFns',
+ \ pattern: '*.py', nested: v:false, once: v:false,
+ \ event: 'BufAdd'},
+ \ #{cmd: 'echo "bufhidden"', group: 'TestAutoCmdFns',
+ \ pattern: '*.vim', nested: v:false,
+ \ once: v:false, event: 'BufHidden'}]
+ call assert_equal(expected, autocmd_get(#{group: 'TestAutoCmdFns'}))
+
+ " Test for getting autocmds for all the patterns in a group
+ call assert_equal(expected, autocmd_get(#{group: 'TestAutoCmdFns',
+ \ event: '*'}))
+
+ " Test for getting autocmds for an event in a group
+ let expected = [
+ \ #{cmd: 'echo "bufadd-vim"', group: 'TestAutoCmdFns',
+ \ pattern: '*.vim', nested: v:false, once: v:false,
+ \ event: 'BufAdd'},
+ \ #{cmd: 'echo "bufadd-py"', group: 'TestAutoCmdFns',
+ \ pattern: '*.py', nested: v:false, once: v:false,
+ \ event: 'BufAdd'}]
+ call assert_equal(expected, autocmd_get(#{group: 'TestAutoCmdFns',
+ \ event: 'BufAdd'}))
+
+ " Test for getting the autocmds for all the events in a group for particular
+ " pattern
+ call assert_equal([{'cmd': 'echo "bufadd-py"', 'group': 'TestAutoCmdFns',
+ \ 'pattern': '*.py', 'nested': v:false, 'once': v:false,
+ \ 'event': 'BufAdd'}],
+ \ autocmd_get(#{group: 'TestAutoCmdFns', event: '*', pattern: '*.py'}))
+
+ " Test for getting the autocmds for an events in a group for particular
+ " pattern
+ let l = autocmd_get(#{group: 'TestAutoCmdFns', event: 'BufAdd',
+ \ pattern: '*.vim'})
+ call assert_equal([
+ \ #{cmd: 'echo "bufadd-vim"', group: 'TestAutoCmdFns',
+ \ pattern: '*.vim', nested: v:false, once: v:false,
+ \ event: 'BufAdd'}], l)
+
+ " Test for getting the autocmds for a pattern in a group
+ let l = autocmd_get(#{group: 'TestAutoCmdFns', pattern: '*.vim'})
+ call assert_equal([
+ \ #{cmd: 'echo "bufadd-vim"', group: 'TestAutoCmdFns',
+ \ pattern: '*.vim', nested: v:false, once: v:false,
+ \ event: 'BufAdd'},
+ \ #{cmd: 'echo "bufhidden"', group: 'TestAutoCmdFns',
+ \ pattern: '*.vim', nested: v:false,
+ \ once: v:false, event: 'BufHidden'}], l)
+
+ " Test for getting the autocmds for a pattern in all the groups
+ let l = autocmd_get(#{pattern: '*.a1b2c3'})
+ call assert_equal([{'cmd': 'echo "bufadd-vim-2"', 'group': 'TestAutoCmdFns2',
+ \ 'pattern': '*.a1b2c3', 'nested': v:false, 'once': v:false,
+ \ 'event': 'BufRead'}], l)
+
+ " Test for getting autocmds for a pattern without any autocmds
+ call assert_equal([], autocmd_get(#{group: 'TestAutoCmdFns',
+ \ pattern: '*.abc'}))
+ call assert_equal([], autocmd_get(#{group: 'TestAutoCmdFns',
+ \ event: 'BufAdd', pattern: '*.abc'}))
+ call assert_equal([], autocmd_get(#{group: 'TestAutoCmdFns',
+ \ event: 'BufWipeout'}))
+ call assert_fails("call autocmd_get(#{group: 'abc', event: 'BufAdd'})",
+ \ 'E367:')
+ let cmd = "echo autocmd_get(#{group: 'TestAutoCmdFns', event: 'abc'})"
+ call assert_fails(cmd, 'E216:')
+ call assert_fails("call autocmd_get(#{group: 'abc'})", 'E367:')
+ call assert_fails("echo autocmd_get(#{event: 'abc'})", 'E216:')
+
+ augroup TestAutoCmdFns
+ au!
+ augroup END
+ call assert_equal([], autocmd_get(#{group: 'TestAutoCmdFns'}))
+
+ " Test for nested and once autocmds
+ augroup TestAutoCmdFns
+ au!
+ autocmd VimSuspend * ++nested echo "suspend"
+ autocmd VimResume * ++once echo "resume"
+ augroup END
+
+ let expected = [
+ \ {'cmd': 'echo "suspend"', 'group': 'TestAutoCmdFns', 'pattern': '*',
+ \ 'nested': v:true, 'once': v:false, 'event': 'VimSuspend'},
+ \ {'cmd': 'echo "resume"', 'group': 'TestAutoCmdFns', 'pattern': '*',
+ \ 'nested': v:false, 'once': v:true, 'event': 'VimResume'}]
+ call assert_equal(expected, autocmd_get(#{group: 'TestAutoCmdFns'}))
+
+ " Test for buffer-local autocmd
+ augroup TestAutoCmdFns
+ au!
+ autocmd TextYankPost <buffer> echo "textyankpost"
+ augroup END
+
+ let expected = [
+ \ {'cmd': 'echo "textyankpost"', 'group': 'TestAutoCmdFns',
+ \ 'pattern': '<buffer=' .. bufnr() .. '>', 'nested': v:false,
+ \ 'once': v:false, 'bufnr': bufnr(), 'event': 'TextYankPost'}]
+ call assert_equal(expected, autocmd_get(#{group: 'TestAutoCmdFns'}))
+
+ augroup TestAutoCmdFns
+ au!
+ augroup END
+ augroup! TestAutoCmdFns
+ augroup TestAutoCmdFns2
+ au!
+ augroup END
+ augroup! TestAutoCmdFns2
+
+ call assert_fails("echo autocmd_get(#{group: []})", 'E730:')
+ call assert_fails("echo autocmd_get(#{event: {}})", 'E731:')
+ call assert_fails("echo autocmd_get([])", 'E1206:')
+ endfunc
+
+ " Test for the autocmd_add() function
+ func Test_autocmd_add()
+ " Define a single autocmd in a group
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufAdd', pattern: '*.sh',
+ \ cmd: 'echo "bufadd"', once: v:true, nested: v:true}])
+ call assert_equal([#{cmd: 'echo "bufadd"', group: 'TestAcSet',
+ \ pattern: '*.sh', nested: v:true, once: v:true,
+ \ event: 'BufAdd'}], autocmd_get(#{group: 'TestAcSet'}))
+
+ " Define two autocmds in the same group
+ call autocmd_delete([#{group: 'TestAcSet'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufAdd', pattern: '*.sh',
+ \ cmd: 'echo "bufadd"'},
+ \ #{group: 'TestAcSet', event: 'BufEnter', pattern: '*.sh',
+ \ cmd: 'echo "bufenter"'}])
+ call assert_equal([
+ \ #{cmd: 'echo "bufadd"', group: 'TestAcSet', pattern: '*.sh',
+ \ nested: v:false, once: v:false, event: 'BufAdd'},
+ \ #{cmd: 'echo "bufenter"', group: 'TestAcSet', pattern: '*.sh',
+ \ nested: v:false, once: v:false, event: 'BufEnter'}],
+ \ autocmd_get(#{group: 'TestAcSet'}))
+
+ " Define a buffer-local autocmd
+ call autocmd_delete([#{group: 'TestAcSet'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'CursorHold',
+ \ bufnr: bufnr(), cmd: 'echo "cursorhold"'}])
+ call assert_equal([
+ \ #{cmd: 'echo "cursorhold"', group: 'TestAcSet',
+ \ pattern: '<buffer=' .. bufnr() .. '>', nested: v:false,
+ \ once: v:false, bufnr: bufnr(), event: 'CursorHold'}],
+ \ autocmd_get(#{group: 'TestAcSet'}))
+
+ " Use an invalid buffer number
+ call autocmd_delete([#{group: 'TestAcSet'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufEnter',
+ \ bufnr: -1, cmd: 'echo "bufenter"'}])
+ let l = [#{group: 'TestAcSet', event: 'BufAdd', bufnr: 9999,
+ \ cmd: 'echo "bufadd"'}]
+ call assert_fails("echo autocmd_add(l)", 'E680:')
+ let l = [#{group: 'TestAcSet', event: 'BufRead', bufnr: [],
+ \ cmd: 'echo "bufread"'}]
+ call assert_fails("echo autocmd_add(l)", 'E745:')
+ call assert_equal([], autocmd_get(#{group: 'TestAcSet'}))
+
+ " Add two commands to the same group, event and pattern
+ call autocmd_delete([#{group: 'TestAcSet'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufUnload',
+ \ pattern: 'abc', cmd: 'echo "cmd1"'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufUnload',
+ \ pattern: 'abc', cmd: 'echo "cmd2"'}])
+ call assert_equal([
+ \ #{cmd: 'echo "cmd1"', group: 'TestAcSet', pattern: 'abc',
+ \ nested: v:false, once: v:false, event: 'BufUnload'},
+ \ #{cmd: 'echo "cmd2"', group: 'TestAcSet', pattern: 'abc',
+ \ nested: v:false, once: v:false, event: 'BufUnload'}],
+ \ autocmd_get(#{group: 'TestAcSet'}))
+
+ " When adding a new autocmd, if the autocmd 'group' is not specified, then
+ " the current autocmd group should be used.
+ call autocmd_delete([#{group: 'TestAcSet'}])
+ augroup TestAcSet
+ call autocmd_add([#{event: 'BufHidden', pattern: 'abc', cmd: 'echo "abc"'}])
+ augroup END
+ call assert_equal([
+ \ #{cmd: 'echo "abc"', group: 'TestAcSet', pattern: 'abc',
+ \ nested: v:false, once: v:false, event: 'BufHidden'}],
+ \ autocmd_get(#{group: 'TestAcSet'}))
+
+ let l = [#{group: 'TestAcSet', event: 'abc', pattern: '*.sh',
+ \ cmd: 'echo "bufadd"'}]
+ call assert_fails('call autocmd_add(l)', 'E216:')
+
+ call assert_fails("call autocmd_add({})", 'E1211:')
+ call assert_equal(v:false, autocmd_add(test_null_list()))
+ call assert_true(autocmd_add([[]]))
+ call assert_true(autocmd_add([test_null_dict()]))
+
+ augroup TestAcSet
+ au!
+ augroup END
+
+ call autocmd_add([#{group: 'TestAcSet'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufAdd'}])
+ call autocmd_add([#{group: 'TestAcSet', pat: '*.sh'}])
+ call autocmd_add([#{group: 'TestAcSet', cmd: 'echo "a"'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufAdd', pat: '*.sh'}])
+ call autocmd_add([#{group: 'TestAcSet', event: 'BufAdd', cmd: 'echo "a"'}])
+ call autocmd_add([#{group: 'TestAcSet', pat: '*.sh', cmd: 'echo "a"'}])
+ call assert_equal([], autocmd_get(#{group: 'TestAcSet'}))
+
+ augroup! TestAcSet
+ endfunc
+
+ " Test for deleting autocmd events and groups
+ func Test_autocmd_delete()
+ " Delete an event in an autocmd group
+ augroup TestAcSet
+ au!
+ au BufAdd *.sh echo "bufadd"
+ au BufEnter *.sh echo "bufenter"
+ augroup END
+ call autocmd_delete([#{group: 'TestAcSet', event: 'BufAdd'}])
+ call assert_equal([#{cmd: 'echo "bufenter"', group: 'TestAcSet',
+ \ pattern: '*.sh', nested: v:false, once: v:false,
+ \ event: 'BufEnter'}], autocmd_get(#{group: 'TestAcSet'}))
+
+ " Delete all the events in an autocmd group
+ augroup TestAcSet
+ au BufAdd *.sh echo "bufadd"
+ augroup END
+ call autocmd_delete([#{group: 'TestAcSet', event: '*'}])
+ call assert_equal([], autocmd_get(#{group: 'TestAcSet'}))
+
+ " Delete a non-existing autocmd group
+ call assert_fails("call autocmd_delete([#{group: 'abc'}])", 'E367:')
+ " Delete a non-existing autocmd event
+ let l = [#{group: 'TestAcSet', event: 'abc'}]
+ call assert_fails("call autocmd_delete(l)", 'E216:')
+ " Delete a non-existing autocmd pattern
+ let l = [#{group: 'TestAcSet', event: 'BufAdd', pat: 'abc'}]
+ call assert_true(autocmd_delete(l))
+
+ " Delete an autocmd group
+ augroup TestAcSet
+ au!
+ au BufAdd *.sh echo "bufadd"
+ au BufEnter *.sh echo "bufenter"
+ augroup END
+ call autocmd_delete([#{group: 'TestAcSet'}])
+ call assert_fails("call autocmd_get(#{group: 'TestAcSet'})", 'E367:')
+
+ call assert_true(autocmd_delete([[]]))
+ call assert_true(autocmd_delete([test_null_dict()]))
+ endfunc
+
" vim: shiftwidth=2 sts=2 expandtab
*** ../vim-8.2.4980/src/testdir/test_vim9_builtin.vim 2022-05-12 22:02:53.287681016 +0100
--- src/testdir/test_vim9_builtin.vim 2022-05-19 10:22:46.210265958 +0100
***************
*** 304,309 ****
--- 304,321 ----
v9.CheckDefAndScriptFailure(['assert_report([1, 2])'], ['E1013: Argument 1: type mismatch, expected string but got list<number>', 'E1174: String required for argument 1'])
enddef

+ def Test_autocmd_add()
+ v9.CheckDefAndScriptFailure(['autocmd_add({})'], ['E1013: Argument 1: type mismatch, expected list<any> but got dict<unknown>', 'E1211: List required for argument 1'])
+ enddef
+
+ def Test_autocmd_delete()
+ v9.CheckDefAndScriptFailure(['autocmd_delete({})'], ['E1013: Argument 1: type mismatch, expected list<any> but got dict<unknown>', 'E1211: List required for argument 1'])
+ enddef
+
+ def Test_autocmd_get()
+ v9.CheckDefAndScriptFailure(['autocmd_get(10)'], ['E1013: Argument 1: type mismatch, expected dict<any> but got number', 'E1206: Dictionary required for argument 1'])
+ enddef
+
def Test_balloon_show()
CheckGui
CheckFeature balloon_eval
*** ../vim-8.2.4980/src/version.c 2022-05-18 22:07:44.079562195 +0100
--- src/version.c 2022-05-19 10:26:11.686005228 +0100
***************
*** 748,749 ****
--- 748,751 ----
{ /* Add new patch number below this line */
+ /**/
+ 4981,
/**/

--
hundred-and-one symptoms of being an internet addict:
233. You start dreaming about web pages...in html.

/// Bram Moolenaar -- Br...@Moolenaar.net -- http://www.Moolenaar.net \\\
/// \\\
\\\ sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ ///
\\\ help me help AIDS victims -- http://ICCF-Holland.org ///