github-mirror/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell.git synced 2024-11-25 00:57:25 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
3980e46d3a
fish-shell/tests/checks/indent.fish

467 lines
7.3 KiB
Fish
Raw Normal View History

fish_indent: Add check This isn't quite the old-style test, but it checks some of the line continuation stuff. Note that littlecheck ignores leading whitespace, so testing the actual indentation requires some more effort.
2020-03-15 22:29:23 +08:00
# RUN: %fish -C 'set -g fish_indent %fish_indent' %s
# Test file for fish_indent
Port fish_indent tests to littlecheck
2020-03-17 02:23:44 +08:00
# Note that littlecheck ignores leading whitespace, so we have to use {{ }} to explicitly match it.
fish_indent: Add check This isn't quite the old-style test, but it checks some of the line continuation stuff. Note that littlecheck ignores leading whitespace, so testing the actual indentation requires some more effort.
2020-03-15 22:29:23 +08:00
echo 'echo foo \\
| cat' | $fish_indent
#CHECK: echo foo \
#CHECK: | cat
echo 'echo foo | \\
cat' | $fish_indent
#CHECK: echo foo | cat
echo 'echo foo |
cat' | $fish_indent
#CHECK: echo foo |
#CHECK: cat
echo 'if true; \\
or false
echo something
end' | $fish_indent
#CHECK: if true; or false
#CHECK: echo something
#CHECK: end
echo '\\
echo wurst' | $fish_indent
#CHECK: echo wurst
echo 'echo foo \\
brot' | $fish_indent
#CHECK: echo foo \
#CHECK: brot
echo 'echo rabarber \\
banana' | $fish_indent
#CHECK: echo rabarber \
#CHECK: banana
echo 'for x in a \\
b \\
c
echo thing
end' | $fish_indent
#CHECK: for x in a \
#CHECK: b \
#CHECK: c
#CHECK: echo thing
#CHECK: end
Adopt the new AST in fish_indent This switches fish_indent from parsing with parse_tree to the new ast. This is the most difficult transition because the new ast retains less lexical information than the old parse tree. The strategy is: 1. Use parse_util_compute_indents to compute indenting for each token. 2. Compute the "gap text" between the text of significant tokens. This contains whitespace, comments, etc. 3. "Fix up" the gap text while leaving the significant tokens alone.
2020-06-29 05:48:16 +08:00
fish_indent: Add check This isn't quite the old-style test, but it checks some of the line continuation stuff. Note that littlecheck ignores leading whitespace, so testing the actual indentation requires some more effort.
2020-03-15 22:29:23 +08:00
echo 'echo foo |
echo banana' | $fish_indent
#CHECK: echo foo |
#CHECK: echo banana
echo 'echo foo \\
;' | $fish_indent
Adopt the new AST in fish_indent This switches fish_indent from parsing with parse_tree to the new ast. This is the most difficult transition because the new ast retains less lexical information than the old parse tree. The strategy is: 1. Use parse_util_compute_indents to compute indenting for each token. 2. Compute the "gap text" between the text of significant tokens. This contains whitespace, comments, etc. 3. "Fix up" the gap text while leaving the significant tokens alone.
2020-06-29 05:48:16 +08:00
#CHECK: echo foo
fish_indent: Add check This isn't quite the old-style test, but it checks some of the line continuation stuff. Note that littlecheck ignores leading whitespace, so testing the actual indentation requires some more effort.
2020-03-15 22:29:23 +08:00
echo 'echo foo \\
' | $fish_indent
Adopt the new AST in fish_indent This switches fish_indent from parsing with parse_tree to the new ast. This is the most difficult transition because the new ast retains less lexical information than the old parse tree. The strategy is: 1. Use parse_util_compute_indents to compute indenting for each token. 2. Compute the "gap text" between the text of significant tokens. This contains whitespace, comments, etc. 3. "Fix up" the gap text while leaving the significant tokens alone.
2020-06-29 05:48:16 +08:00
#CHECK: echo foo
Port fish_indent tests to littlecheck
2020-03-17 02:23:44 +08:00
echo -n '
begin
echo hi
end | cat | cat | begin ; echo hi ; end | begin ; begin ; echo hi ; end ; end arg
' | $fish_indent
#CHECK: begin
#CHECK: {{ }}echo hi
#CHECK:
#CHECK: end | cat | cat | begin
#CHECK: {{ }}echo hi
#CHECK: end | begin
#CHECK: {{ }}begin
#CHECK: {{ }}{{ }}echo hi
#CHECK: {{ }}end
#CHECK: end arg
echo -n '
switch aloha
case alpha
echo sup
case beta gamma
echo hi
end
' | $fish_indent
#CHECK: switch aloha
#CHECK: {{ }}case alpha
#CHECK: {{ }}{{ }}echo sup
#CHECK: {{ }}case beta gamma
#CHECK: {{ }}{{ }}echo hi
#CHECK:
#CHECK: end
echo -n '
function hello_world
\'begin\'
echo hi
end | cat
echo sup; echo sup
echo hello;
echo hello
end
' | $fish_indent
#CHECK: function hello_world
#CHECK:
#CHECK: {{ }}begin
#CHECK: {{ }}{{ }}echo hi
#CHECK: {{ }}end | cat
#CHECK:
#CHECK: {{ }}echo sup
#CHECK: {{ }}echo sup
#CHECK: {{ }}echo hello
#CHECK:
#CHECK: {{ }}echo hello
#CHECK: end
echo -n '
echo alpha #comment1
#comment2
#comment3
for i in abc #comment1
#comment2
echo hi
end
switch foo #abc
# bar
case bar
echo baz\
qqq
case "*"
echo sup
end' | $fish_indent
#CHECK: echo alpha #comment1
#CHECK: #comment2
#CHECK:
#CHECK: #comment3
#CHECK: for i in abc #comment1
#CHECK: {{ }}#comment2
#CHECK: {{ }}echo hi
#CHECK: end
#CHECK:
#CHECK: switch foo #abc
#CHECK: {{ }}# bar
#CHECK: {{ }}case bar
#CHECK: {{ }}{{ }}echo baz\
#CHECK: qqq
#CHECK: {{ }}case "*"
#CHECK: {{ }}{{ }}echo sup
#CHECK: end
# No indent
echo -n '
if true
else if false
echo alpha
switch beta
case gamma
echo delta
end
end
' | $fish_indent -i
#CHECK: if true
#CHECK: else if false
#CHECK: {{^}}echo alpha
#CHECK: {{^}}switch beta
#CHECK: {{^}}case gamma
#CHECK: {{^}}echo delta
#CHECK: {{^}}end
#CHECK: end
# Test errors
echo -n '
begin
echo hi
else
echo bye
end; echo alpha "
' | $fish_indent
#CHECK: begin
#CHECK: {{ }}echo hi
#CHECK: else
Adopt the new AST in fish_indent This switches fish_indent from parsing with parse_tree to the new ast. This is the most difficult transition because the new ast retains less lexical information than the old parse tree. The strategy is: 1. Use parse_util_compute_indents to compute indenting for each token. 2. Compute the "gap text" between the text of significant tokens. This contains whitespace, comments, etc. 3. "Fix up" the gap text while leaving the significant tokens alone.
2020-06-29 05:48:16 +08:00
#CHECK:
Port fish_indent tests to littlecheck
2020-03-17 02:23:44 +08:00
#CHECK: {{^}}echo bye
Adopt the new AST in fish_indent This switches fish_indent from parsing with parse_tree to the new ast. This is the most difficult transition because the new ast retains less lexical information than the old parse tree. The strategy is: 1. Use parse_util_compute_indents to compute indenting for each token. 2. Compute the "gap text" between the text of significant tokens. This contains whitespace, comments, etc. 3. "Fix up" the gap text while leaving the significant tokens alone.
2020-06-29 05:48:16 +08:00
#CHECK: end; echo alpha "
Port fish_indent tests to littlecheck
2020-03-17 02:23:44 +08:00
# issue 1665
echo -n '
if begin ; false; end; echo hi ; end
while begin ; false; end; echo hi ; end
' | $fish_indent
#CHECK: if begin
#CHECK: {{ }}{{ }}false
#CHECK: {{ }}end
#CHECK: {{ }}echo hi
#CHECK: end
#CHECK: while begin
#CHECK: {{ }}{{ }}false
#CHECK: {{ }}end
#CHECK: {{ }}echo hi
#CHECK: end
# issue 2899
echo -n '
echo < stdin >>appended yes 2>&1 no > stdout maybe 2>& 4 | cat 2>| cat
' | $fish_indent
#CHECK: echo <stdin >>appended yes 2>&1 no >stdout maybe 2>&4 | cat 2>| cat
fish_indent: Correct certain comment indenting Prior to this change, when emitting gap text (comments, newlines, etc), fish_indent would use the indentation of the text at the end of the gap. But this has the wrong result for this case: begin command # comment end as the comment would get the indent of the 'end'. Instead use the indent computed for the gap text itself. Addresses one case of #7252.
2020-08-09 07:16:02 +08:00
# issue 7252
echo -n '
begin
# comment
end
' | $fish_indent
Indent continuations after | and && This indents continuations after pipes and conjunctions if they contain a newline. Example: cmd1 && cmd2 But it avoids the "double indent" if it indented unconditionally: cmd1 | begin cmd2 end More work towards improving #7252
2020-08-10 03:15:14 +08:00
#CHECK: {{^}}begin
#CHECK: {{^ }}# comment
#CHECK: {{^}}end
fish_indent: Correct certain comment indenting Prior to this change, when emitting gap text (comments, newlines, etc), fish_indent would use the indentation of the text at the end of the gap. But this has the wrong result for this case: begin command # comment end as the comment would get the indent of the 'end'. Instead use the indent computed for the gap text itself. Addresses one case of #7252.
2020-08-09 07:16:02 +08:00
echo -n '
begin
cmd
# comment
end
' | $fish_indent
Indent continuations after | and && This indents continuations after pipes and conjunctions if they contain a newline. Example: cmd1 && cmd2 But it avoids the "double indent" if it indented unconditionally: cmd1 | begin cmd2 end More work towards improving #7252
2020-08-10 03:15:14 +08:00
#CHECK: {{^}}begin
#CHECK: {{^ }}cmd
#CHECK: {{^ }}# comment
#CHECK: {{^}}end
fish_indent: Correct certain comment indenting Prior to this change, when emitting gap text (comments, newlines, etc), fish_indent would use the indentation of the text at the end of the gap. But this has the wrong result for this case: begin command # comment end as the comment would get the indent of the 'end'. Instead use the indent computed for the gap text itself. Addresses one case of #7252.
2020-08-09 07:16:02 +08:00
fish_indent: indent line continuations For example: cmd \ arg Fixes one case from #7252
2020-08-09 09:29:50 +08:00
echo -n '
cmd \\
continuation
' | $fish_indent
Indent continuations after | and && This indents continuations after pipes and conjunctions if they contain a newline. Example: cmd1 && cmd2 But it avoids the "double indent" if it indented unconditionally: cmd1 | begin cmd2 end More work towards improving #7252
2020-08-10 03:15:14 +08:00
#CHECK: {{^}}cmd \
#CHECK: {{^ }}continuation
fish_indent: indent line continuations For example: cmd \ arg Fixes one case from #7252
2020-08-09 09:29:50 +08:00
echo -n '
begin
cmd \
continuation
end
' | $fish_indent
Indent continuations after | and && This indents continuations after pipes and conjunctions if they contain a newline. Example: cmd1 && cmd2 But it avoids the "double indent" if it indented unconditionally: cmd1 | begin cmd2 end More work towards improving #7252
2020-08-10 03:15:14 +08:00
#CHECK: {{^}}begin
#CHECK: {{^ }}cmd \
#CHECK: {{^ }}{{ }}continuation
#CHECK: {{^}}end
fish_indent: indent line continuations For example: cmd \ arg Fixes one case from #7252
2020-08-09 09:29:50 +08:00
Port fish_indent tests to littlecheck
2020-03-17 02:23:44 +08:00
echo -n '
i\
f true
echo yes
en\
d
"whil\
e" true
"builtin" yes
en"d"
alpha | \
beta
gamma | \
# comment3
delta
if true
echo abc
end
if false # comment4
and true && false
echo abc;end
echo hi |
echo bye
' | $fish_indent
#CHECK: i\
#CHECK: f true
#CHECK: {{ }}echo yes
#CHECK: en\
#CHECK: d
#CHECK:
#CHECK: while true
#CHECK: {{ }}builtin yes
#CHECK: end
#CHECK:
#CHECK: alpha | beta
#CHECK:
#CHECK: gamma | \
#CHECK: # comment3
#CHECK: delta
#CHECK:
#CHECK: if true
#CHECK: {{ }}echo abc
#CHECK: end
#CHECK:
#CHECK: if false # comment4
#CHECK: {{ }}and true && false
#CHECK: {{ }}echo abc
#CHECK: end
#CHECK:
#CHECK: echo hi |
Adopt the new AST in fish_indent This switches fish_indent from parsing with parse_tree to the new ast. This is the most difficult transition because the new ast retains less lexical information than the old parse tree. The strategy is: 1. Use parse_util_compute_indents to compute indenting for each token. 2. Compute the "gap text" between the text of significant tokens. This contains whitespace, comments, etc. 3. "Fix up" the gap text while leaving the significant tokens alone.
2020-06-29 05:48:16 +08:00
#CHECK: {{ }}echo bye
Port fish_indent tests to littlecheck
2020-03-17 02:23:44 +08:00
echo 'a;;;;;;' | $fish_indent
#CHECK: a
echo 'echo; echo' | $fish_indent
#CHECK: echo
#CHECK: echo
# Check that we keep semicolons for and and or, but only on the same line.
printf '%s\n' "a; and b" | $fish_indent
#CHECK: a; and b
printf '%s\n' "a;" "and b" | $fish_indent
#CHECK: a
#CHECK: and b
Allow newlines after && and || We do the same for pipes (#1285). This matches POSIX sh behavior.
2020-08-05 03:39:37 +08:00
printf '%s\n' a "; and b" | $fish_indent
Port fish_indent tests to littlecheck
2020-03-17 02:23:44 +08:00
#CHECK: a
#CHECK: and b
printf '%s\n' "a; b" | $fish_indent
#CHECK: a
#CHECK: b
Allow newlines after && and || We do the same for pipes (#1285). This matches POSIX sh behavior.
2020-08-05 03:39:37 +08:00
echo 'foo &&
#
bar' | $fish_indent
#CHECK: {{^}}foo &&
Indent continuations after | and && This indents continuations after pipes and conjunctions if they contain a newline. Example: cmd1 && cmd2 But it avoids the "double indent" if it indented unconditionally: cmd1 | begin cmd2 end More work towards improving #7252
2020-08-10 03:15:14 +08:00
#CHECK: {{^ }}#
#CHECK: {{ }}bar
Allow newlines after && and || We do the same for pipes (#1285). This matches POSIX sh behavior.
2020-08-05 03:39:37 +08:00
echo 'command 1 |
command 1 cont ||
command 2' | $fish_indent
#CHECK: {{^}}command 1 |
#CHECK: {{^ }}command 1 cont ||
Indent continuations after | and && This indents continuations after pipes and conjunctions if they contain a newline. Example: cmd1 && cmd2 But it avoids the "double indent" if it indented unconditionally: cmd1 | begin cmd2 end More work towards improving #7252
2020-08-10 03:15:14 +08:00
#CHECK: {{^ }}command 2
fish_indent: Add a "--check" option to only test indentation Fixes #7251.
2020-08-09 02:22:18 +08:00
Use variable in tests/checks/indent.fish
2020-08-10 05:06:41 +08:00
echo " foo" | $fish_indent --check
fish_indent: Add a "--check" option to only test indentation Fixes #7251.
2020-08-09 02:22:18 +08:00
echo $status
#CHECK: 1
Use variable in tests/checks/indent.fish
2020-08-10 05:06:41 +08:00
echo foo | $fish_indent --check
fish_indent: Add a "--check" option to only test indentation Fixes #7251.
2020-08-09 02:22:18 +08:00
echo $status
#CHECK: 0
fish_indent: no extra newline at comment after pipe Fixes the unstable case in #7252
2020-08-10 03:14:00 +08:00
echo 'thing | # comment
thing' | $fish_indent --check
echo $status
#CHECK: 0
fish_indent: indent comments before line continuation See #7252
2020-08-10 05:37:09 +08:00
echo 'echo \
# first indented comment
# second indented comment
indented argument
echo' | $fish_indent --check
echo $status
#CHECK: 0
fish_indent: preserve semis in if and while conditions It could be nice to use a heuristic for this in future, but for now let's stick to the old behavior so we can keep formatting scripts without occasional bad formatting changes. A heuristic could also be used to break lines after |, && or || but I don't think there is much need for that at the moment. Closes #7252
2020-08-17 16:43:55 +08:00
echo 'if true;
end' | $fish_indent
#CHECK: if true{{$}}
#CHECK: end
echo 'if true; and false; or true
end' | $fish_indent --check
echo $status
#CHECK: 0
fish_indent: fix extra indent of continuation lines inside blocks fish_indent used to increment the indentation level whenever we saw an escaped newline. This broke because of recent changes to parse_util_compute_indents(). Since parse_util_compute_indents() function already indents continuations there is not much to do for fish_indent - we can simply query the indentation level of the newline. Reshuffle the code since we need to pass the offset of the newline. Maybe this can even be simplified further. Fixes #7720
2021-02-17 01:29:43 +08:00
echo -n '
function hello_continuations
echo cmd \
echo --opt1 \
echo --opt2 \
echo --opt3
end
' | $fish_indent
#CHECK: function hello_continuations
#CHECK: {{^}} echo cmd \
#CHECK: {{^}} echo --opt1 \
#CHECK: {{^}} echo --opt2 \
#CHECK: {{^}} echo --opt3
#CHECK: end
fish_indent: preserve escaped newlines around variable assignments In many cases we currently discard escaped newlines, since they are often unnecessary (when used around &|;). Escaped newlines are useful for structuring argument lists. Allow them for variable assignments since they are similar. Closes #7955
2021-04-27 06:00:32 +08:00
echo "\
a=1 \\
a=2 \\
echo" | $fish_indent --check
echo $status #CHECK: 0
echo "\
a=1 \\
a=2 echo" | $fish_indent --check
echo $status #CHECK: 0
fish_indent: handle tokens with trailing escaped newlines Fixes #8197
2021-08-02 00:38:18 +08:00
echo 'first-word\\
second-word' | $fish_indent
# CHECK: first-word \
# CHECK: {{^}} second-word
echo 'begin
first-indented-word\\
second-indented-word' | $fish_indent
# CHECK: begin
# CHECK: {{^}} first-indented-word \
# CHECK: {{^}} second-indented-word
echo 'multiline-\\
-word' | $fish_indent --check
echo $status #CHECK: 0
Fix tokenizer crash This would crash from the highlighter for something like `PATH={$PATH[echo " "` The underlying cause is that we use "char_at" which panics on overread. So instead this implements try_char_at and then just returns None.
2024-01-10 02:12:16 +08:00
echo 'PATH={$PATH[echo " "' | $fish_indent --ansi
# CHECK: PATH={$PATH[echo " "
fish_indent: Fix crash with redirection at the end of the source
2024-01-11 01:54:25 +08:00
echo a\> | $fish_indent
# CHECK: a >
Add tests
2024-01-11 02:36:06 +08:00
echo a\<\) | $fish_indent
# CHECK: a < )
echo b\|\{ | $fish_indent
# CHECK: b | {
fish_indent: Fix crash with NUL in the source Really we should *reject* this
2024-01-11 03:47:39 +08:00
echo "\'\\\\\x00\'" | string unescape | $fish_indent | string escape
# CHECK: \'\\\x00\'
fish_indent: Another crash NUL at the end, which is now ignored. Not *great*, but better than crashing.
2024-01-11 03:56:13 +08:00
echo '\"\"\|\x00' | string unescape | $fish_indent | string unescape
# CHECK: |
fish_indent: Collapse successive newlines This makes it so code like ```fish echo foo echo bar ``` is collapsed into ```fish echo foo echo bar ``` One empty line is allowed, more is overkill. We could also allow more than one for e.g. function endings.
2024-02-26 23:12:42 +08:00
echo 'a
;
b
' | $fish_indent
#CHECK: a
#CHECK:
#CHECK: b
echo "
echo this file starts late
" | $fish_indent
#CHECK: echo this file starts late
Reference in New Issue Copy Permalink