Mirrors/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell synced 2024-12-27 05:13:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
fish-shell/tests/checks/wraps.fish

92 lines
2.7 KiB
Fish
Raw Normal View History

tests: filter control sequences only when interactive This demonstrates that we only write control sequences when interactive.
2024-04-12 10:19:32 +00:00
#RUN: %fish %s
Do not try the same (command, wraps) pair more than once when completing This prevents runaway wrap chains. Fixes #5638.
2019-09-21 20:38:59 +00:00
# Validate some things about command wrapping.
Consolidate complete cycle detection and always report error on cycle Detect recursive calls to builtin complete and the internal completion in the same place. In 0a0149cc2 (Prevent infinite recursion when completion wraps variable assignment) we don't print an error when completing certain aliases like: alias vim "A=B vim" But we also gave no completions. We could make this case work, but I think that trying to salvage situations like this one is way too complex. Instead, let the user know by printing an error. Not sure if the style of the error fits. We could add some heuristic to alias to not add --wraps in some cyclic cases.
2020-09-26 12:13:56 +00:00
set -g LANG C # For predictable error messages.
Do not try the same (command, wraps) pair more than once when completing This prevents runaway wrap chains. Fixes #5638.
2019-09-21 20:38:59 +00:00
# This tests that we do not trigger a combinatorial explosion - see #5638.
Amend typos and grammar errors
2019-11-25 11:03:25 +00:00
# Ensure it completes successfully.
Do not try the same (command, wraps) pair more than once when completing This prevents runaway wrap chains. Fixes #5638.
2019-09-21 20:38:59 +00:00
complete -c testcommand --wraps "testcommand x "
complete -c testcommand --wraps "testcommand y "
complete -c testcommand --no-files -a normal
complete -C'testcommand '
# CHECK: normal
Completion wrap chain visited set to store only wrapped command The "wrap chain" refers to a sequence of commands which wrap other commands, for completion purposes. One possibility is that a wrap chain will produce a combinatorial explosion or even an infinite loop, so there needs to be logic to prevent that. Part of that logic is encapsulated in a visited set (wrap_chain_visited_set_t) to prevent exploring the same item twice. Prior to this change, we stored pairs (command, wrapped_command). But we only really need to store the wrapped command. Switch to that. One consequence is that if a command wraps another command in more than one way, we won't explore both ways. This seems unlikely in practice.
2020-09-26 20:39:47 +00:00
# Test double wraps.
complete -c testcommand0 -x -a crosswalk
complete -c testcommand1 -x --wraps testcommand0
complete -c testcommand2 -x --wraps testcommand1
complete -C 'testcommand 0'
# CHECK: crosswalk
Do not try the same (command, wraps) pair more than once when completing This prevents runaway wrap chains. Fixes #5638.
2019-09-21 20:38:59 +00:00
# This tests that a call to complete from within a completion doesn't trigger
# wrap chain explosion - #5638 again.
function testcommand2_complete
completion: adopt commandline -x replacing deprecated -o This gives us more accurate completions because completion scripts get expanded paths
2024-01-22 06:42:45 +00:00
set -l tokens (commandline -xpc) (commandline -ct)
Do not try the same (command, wraps) pair more than once when completing This prevents runaway wrap chains. Fixes #5638.
2019-09-21 20:38:59 +00:00
set -e tokens[1]
echo $tokens 1>&2
end
complete -c testcommand2 -x -a "(testcommand2_complete)"
complete -c testcommand2 --wraps "testcommand2 from_wraps "
complete -C'testcommand2 explicit '
# CHECKERR: explicit
# CHECKERR: from_wraps explicit
Prevent infinite recursion when completion wraps variable assignment Closes #7344 Apply a targeted fix to the place where complete() is called to handle nested variable assignments. Sadly, reporting an error is probably not okay here, because people might legitimately use aliases like: alias vim "A=B command vim" This is all a bit ugly, and I hope to find a cleaner solution. Supporting completions on commandlines like `x=$PWD cd $x/ ` is a nice feature but it comes with some complexity.
2020-09-21 22:55:28 +00:00
Separate out variable assignments when completing In preparation for applying variable assignments (VAR=VAL cmd), separate them out from the command when performing completions. This includes both those that the user typed, and any that come about through completion --wraps.
2020-09-27 00:21:22 +00:00
# Test that prefixing with a variable assignment works - see #7344.
complete -c recvar --exclusive -a recvar_comp
Prevent infinite recursion when completion wraps variable assignment Closes #7344 Apply a targeted fix to the place where complete() is called to handle nested variable assignments. Sadly, reporting an error is probably not okay here, because people might legitimately use aliases like: alias vim "A=B command vim" This is all a bit ugly, and I hope to find a cleaner solution. Supporting completions on commandlines like `x=$PWD cd $x/ ` is a nice feature but it comes with some complexity.
2020-09-21 22:55:28 +00:00
complete -c recvar --wraps 'A=B recvar'
complete -C 'recvar '
Separate out variable assignments when completing In preparation for applying variable assignments (VAR=VAL cmd), separate them out from the command when performing completions. This includes both those that the user typed, and any that come about through completion --wraps.
2020-09-27 00:21:22 +00:00
# CHECK: recvar_comp
Rework variable assignments during tab completion Prior to this change, tab completing with a variable assignment like `VAR=val cmd<tab>` would parse out and apply VAR=val, then recursively invoke completions. This caused some awkwardness around the wrap chain - if a wrapped command had a variable completion we risked infinite recursion. A secondary problem is that we would run any command substitutions inside variable assignment, which the user does not expect to run until pressing enter. With this change, we explicitly track variable assignments encountered during tab completion, including both those explicitly given on the command line and those found during wrap chain walk. We then apply them while suppressing command substitutions.
2020-09-27 01:39:29 +00:00
# Test that completions do not perform subcommands.
# That is, `FOO=(launch_missiles) command<tab>` does not launch any missiles.
set -g missile_count 0
function launch_missiles
set -g missile_count (math "$missile_count + 1")
end
# Ensure missile launching work.
launch_missiles
echo $missile_count
# CHECK: 1
set -g GOOD global_good
set -g BAD global_bad
function do_print_good_bad
echo "GOOD:$GOOD"
echo "BAD:$BAD"
end
complete -c print_good_bad -x -a '(do_print_good_bad)'
complete -C 'print_good_bad '
# CHECK: BAD:global_bad
Sort and deduplicate output of `complete -C` This addresses a long-standing TODO where `complete -C` output isn't deduplicated. With this patch, the same deduplication and sort procedure that is run on actual pager completions is also executed for `complete -C` completions (with a `-C` payload specified). This makes it possible to use `complete -C` to test what completions will actually be generated by the completions pager instead of it displaying something completely divorced from reality, improving the productivity of fish completions developers. Note that completions that wouldn't be shown in the pager are also omitted from the results, e.g. `test/buildroot/` and `test/fish_expand_test/` are omitted from the check matches in `checks/complete_directories.fish` because even if they were generated, the pager wouldn't have shown them. This again makes reasoning about and debugging completions much easier and more sane.
2022-10-26 19:05:09 +00:00
# CHECK: GOOD:global_good
Rework variable assignments during tab completion Prior to this change, tab completing with a variable assignment like `VAR=val cmd<tab>` would parse out and apply VAR=val, then recursively invoke completions. This caused some awkwardness around the wrap chain - if a wrapped command had a variable completion we risked infinite recursion. A secondary problem is that we would run any command substitutions inside variable assignment, which the user does not expect to run until pressing enter. With this change, we explicitly track variable assignments encountered during tab completion, including both those explicitly given on the command line and those found during wrap chain walk. We then apply them while suppressing command substitutions.
2020-09-27 01:39:29 +00:00
# Key check is completions should expand GOOD but not BAD,
# because GOOD is just a string but BAD contains a cmdsub
# which may do arbitrary things.
complete -C 'GOOD=local_good BAD=(launch_missiles) print_good_bad '
# CHECK: BAD:
Sort and deduplicate output of `complete -C` This addresses a long-standing TODO where `complete -C` output isn't deduplicated. With this patch, the same deduplication and sort procedure that is run on actual pager completions is also executed for `complete -C` completions (with a `-C` payload specified). This makes it possible to use `complete -C` to test what completions will actually be generated by the completions pager instead of it displaying something completely divorced from reality, improving the productivity of fish completions developers. Note that completions that wouldn't be shown in the pager are also omitted from the results, e.g. `test/buildroot/` and `test/fish_expand_test/` are omitted from the check matches in `checks/complete_directories.fish` because even if they were generated, the pager wouldn't have shown them. This again makes reasoning about and debugging completions much easier and more sane.
2022-10-26 19:05:09 +00:00
# CHECK: GOOD:local_good
Rework variable assignments during tab completion Prior to this change, tab completing with a variable assignment like `VAR=val cmd<tab>` would parse out and apply VAR=val, then recursively invoke completions. This caused some awkwardness around the wrap chain - if a wrapped command had a variable completion we risked infinite recursion. A secondary problem is that we would run any command substitutions inside variable assignment, which the user does not expect to run until pressing enter. With this change, we explicitly track variable assignments encountered during tab completion, including both those explicitly given on the command line and those found during wrap chain walk. We then apply them while suppressing command substitutions.
2020-09-27 01:39:29 +00:00
# Completion should not have launched any missiles.
echo $missile_count
# CHECK: 1
# Torture test with a bunch of variable assignments.
# Note this tests the existing behavior when there's conflicts
# (innermost wrapped command wins) but it's not clear that this is desirable.
function show_vars
echo "AAA:$AAA"
echo "BBB:$BBB"
echo "CCC:$CCC"
end
complete -c show_vars_cmd0 -x -a '(show_vars)'
complete -c show_vars_cmd1 -x --wraps 'AAA=aaa show_vars_cmd0'
complete -c show_vars_cmd2 -x --wraps 'AAA=nope BBB=bbb show_vars_cmd1'
complete -c show_vars_cmd3 -x --wraps 'BBB=nope show_vars_cmd2'
complete -C 'CCC=ccc show_vars_cmd3 '
# CHECK: AAA:aaa
# CHECK: BBB:bbb
# CHECK: CCC:ccc
Reference in a new issue Copy permalink