pagedmov/shed
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: pagedmov:main
Branches Tags
pagedmov:main
..
compare: pagedmov:bc30521e47f92cd58a71e550889c8200326c486a
Branches Tags
pagedmov:main

1 Commits
main ... bc30521e47

Author SHA1 Message Date
pagedmov
bc30521e47 Add ! negation support, fix POSIX exit statuses, and improve vi emulation with comprehensive tests 2026-03-07 21:57:04 -05:00
63 changed files with 4479 additions and 8524 deletions
Expand all files Collapse all files

1
Cargo.toml
View File

@@ -35,7 +35,6 @@ rand = "0.10.0"
regex = "1.11.1" regex = "1.11.1"
scopeguard = "1.2.0" scopeguard = "1.2.0"
serde_json = "1.0.149" serde_json = "1.0.149"
tempfile = "3.24.0"
unicode-segmentation = "1.12.0" unicode-segmentation = "1.12.0"
unicode-width = "0.2.0" unicode-width = "0.2.0"
vte = "0.15" vte = "0.15"

8
README.md
View File

@@ -1,8 +1,6 @@
# shed # shed
A Linux shell written in Rust. The name is a nod to the original Unix utilities `sh` and `ed`. It's a shell with a heavy emphasis on smooth line editing and general interactive UX improvements over existing shells. A Linux shell written in Rust. The name is a nod to the original Unix utilities `sh` and `ed`. It's a shell with a heavy emphasis on smooth line editing.
<sub>btw if you don't use `vim` this probably isn't your shell</sub>
<img width="506" height="407" alt="shed" src="https://github.com/user-attachments/assets/3945f663-a361-4418-bf20-0c4eaa2a36d2" /> <img width="506" height="407" alt="shed" src="https://github.com/user-attachments/assets/3945f663-a361-4418-bf20-0c4eaa2a36d2" />
@@ -10,7 +8,7 @@ A Linux shell written in Rust. The name is a nod to the original Unix utilities
### Line Editor ### Line Editor
`shed` includes a built-in `vim` emulator as its line editor, written from scratch. It aims to provide a more precise vim-like editing experience at the shell prompt than conventional `vi` mode implementations. `shed` includes a built-in `vim` emulator as its line editor, written from scratch. It aims to provide a more precise vim-like editing experience at the shell prompt.
- **Normal mode** - motions (`w`, `b`, `e`, `f`, `t`, `%`, `0`, `$`, etc.), verbs (`d`, `c`, `y`, `p`, `r`, `x`, `~`, etc.), text objects (`iw`, `aw`, `i"`, `a{`, `is`, etc.), registers, `.` repeat, `;`/`,` repeat, and counts - **Normal mode** - motions (`w`, `b`, `e`, `f`, `t`, `%`, `0`, `$`, etc.), verbs (`d`, `c`, `y`, `p`, `r`, `x`, `~`, etc.), text objects (`iw`, `aw`, `i"`, `a{`, `is`, etc.), registers, `.` repeat, `;`/`,` repeat, and counts
- **Insert mode** - insert, append, replace, with Ctrl+W word deletion and undo/redo - **Insert mode** - insert, append, replace, with Ctrl+W word deletion and undo/redo
@@ -42,8 +40,6 @@ gitbranch() { git branch --show-current 2>/dev/null; }
export PS1='\u@\h \W \@gitbranch \$ ' export PS1='\u@\h \W \@gitbranch \$ '
``` ```
If `shed` receives `SIGUSR1` while in interactive mode, it will refresh and redraw the prompt. This can be used to create asynchronous, dynamic prompt content.
Additionally, `echo` now has a `-p` flag that expands prompt escape sequences, similar to how the `-e` flag expands conventional escape sequences. Additionally, `echo` now has a `-p` flag that expands prompt escape sequences, similar to how the `-e` flag expands conventional escape sequences.
--- ---

76
doc/arith.txt
View File

@@ -1,76 +0,0 @@
*arith* *arithmetic* *arithmetic-expansion*
#ARITHMETIC EXPANSION#
Arithmetic expansion evaluates a mathematical expression and substitutes
the result. The expression is subject to parameter expansion and command
substitution before evaluation.
`$((expression))`
Example:
`echo $((2 + 3))` # prints: 5
`x=$((width * height))`
==============================================================================
1. Operators *arith-operators*
The following operators are supported, listed from highest to lowest
precedence:
`( )` *arith-parens*
Grouping. Override default precedence.
Example:
`echo $(( (2+3) * 4 ))` # prints: 20
`*` `/` `%` *arith-muldivmod*
Multiplication, division, and modulo (remainder).
Example:
`echo $((10 / 3))` # prints: 3
`echo $((10 % 3))` # prints: 1
`+` `-` *arith-addsub*
Addition and subtraction.
Example:
`echo $((10 - 3 + 1))` # prints: 8
==============================================================================
2. Variables in Expressions *arith-variables*
Variables can be referenced by name inside arithmetic expressions.
They are expanded and converted to numbers.
`x=10`
`echo $(($x + 5))` # prints: 15
`echo $((x + 5))` # also works
If a variable is unset or not a valid number, an error is reported.
==============================================================================
3. Nesting *arith-nesting*
Arithmetic expressions can be nested with parentheses to any depth:
`echo $(( (1+2) * (3+4) ))` # prints: 21
Arithmetic expansion can also appear inside other expansions:
`echo "Total: $((price * qty))"`
==============================================================================
4. Whitespace *arith-whitespace*
Whitespace inside `$((...))` is ignored and can be used freely for
readability:
`echo $((2+3))` # prints: 5
`echo $(( 2 + 3 ))` # same result
==============================================================================
See also: |param| |redirect| |glob|

155
doc/glob.txt
View File

@@ -1,155 +0,0 @@
*glob* *globbing* *pathname-expansion* *filename-expansion*
#PATHNAME EXPANSION#
After word splitting, the shell scans each word for the characters `*`,
`?`, and `[`. If any appear (and are not quoted), the word is treated as a
pattern and replaced with an alphabetically sorted list of matching file
names. If no files match, the pattern is left unchanged.
==============================================================================
1. Wildcards *glob-wildcards*
`*` *glob-star*
Matches any string of zero or more characters, except that it does
not match a leading `.` (see |glob-dotglob|) or a `/`.
Example:
`echo *.txt` # all .txt files
`ls src/*.rs` # all .rs files in src/
`?` *glob-question*
Matches exactly one character, with the same restrictions as `*`.
Example:
`ls file?.txt` # file1.txt, fileA.txt, etc.
`[...]` *glob-bracket*
Matches any one of the enclosed characters. A range can be specified
with a hyphen.
`[abc]` matches `a`, `b`, or `c`
`[a-z]` matches any lowercase letter
`[0-9]` matches any digit
`[A-Za-z]` matches any letter
`[!...]` `[^...]` *glob-bracket-negate*
Matches any character NOT in the set.
Example:
`ls [!.]*.txt` # .txt files not starting with dot
`echo file[^0-9].txt` # files without a digit
==============================================================================
2. Hidden Files *glob-dotglob*
By default, patterns do not match files whose names begin with `.`
(hidden files). A leading dot must be matched explicitly:
`echo .*` # only hidden files
`echo .* *` # hidden and non-hidden files
The `dotglob` shell option changes this behavior:
`shopt core.dotglob true`
When enabled, `*` and `?` will also match files starting with `.`.
==============================================================================
3. Brace Expansion *brace* *brace-expansion*
Brace expansion is performed before globbing and generates multiple
words from a single pattern. It is not a POSIX feature.
`{a,b,c}` *brace-list*
Comma-separated list. Each item becomes a separate word.
Example:
`echo {a,b,c}` # prints: a b c
`echo file.{txt,log}` # prints: file.txt file.log
`mkdir -p src/{bin,lib}`
`{N..M}` *brace-range*
Numeric or character range.
Example:
`echo {1..5}` # prints: 1 2 3 4 5
`echo {a..f}` # prints: a b c d e f
`echo {5..1}` # prints: 5 4 3 2 1
`{N..M..S}` *brace-range-step*
Numeric range with step {S}.
Example:
`echo {0..10..2}` # prints: 0 2 4 6 8 10
`echo {1..20..5}` # prints: 1 6 11 16
`{01..10}` *brace-range-pad*
Zero-padded ranges. If either endpoint has leading zeros, all
generated values are padded to the same width.
Example:
`echo {01..05}` # prints: 01 02 03 04 05
`echo {001..3}` # prints: 001 002 003
Brace expansion can be nested and combined with other expansions:
`echo {a,b{1..3},c}` # prints: a b1 b2 b3 c
==============================================================================
4. Quoting and Escaping *glob-quoting*
Glob characters lose their special meaning when quoted:
`echo "*"` # prints literal *
`echo '*.txt'` # prints literal *.txt
`echo \*` # prints literal *
This is important when passing patterns to commands like `find` or
`grep` where you want the command (not the shell) to interpret the
pattern.
==============================================================================
5. Tilde Expansion *tilde* *tilde-expansion*
Tilde expansion is performed before pathname expansion.
`~` *tilde-home*
Expands to the value of `$HOME`.
`~/path` *tilde-home-path*
Expands `~` to `$HOME`, then appends the path.
Example:
`cd ~/projects`
`ls ~/.config`
`~user` *tilde-user*
Expands to the home directory of {user}.
Example:
`ls ~root` # /root
`cat ~nobody/.profile`
`~uid` *tilde-uid*
Expands to the home directory of the user with numeric uid {uid}.
This is a shed-specific extension.
Example:
`echo ~0` # /root (uid 0)
`echo ~1000` # first normal user's home
==============================================================================
See also: |param| |redirect| |arith|

197
doc/param.txt
View File

@@ -1,197 +0,0 @@
*param* *parameter-expansion* *param-expansion*
#PARAMETER EXPANSION#
The shell provides several forms of parameter expansion for working with
variables. In each form, {word} is subject to tilde expansion, parameter
expansion, command substitution, and arithmetic expansion.
If {parameter} is unset or null, the behavior depends on the operator used.
"Unset" means the variable has never been assigned. "Null" means the variable
is set but its value is the empty string.
==============================================================================
1. Basic Forms *param-basic*
`$var` Value of {var}
`${var}` Same, with explicit braces (needed for `${var}foo`)
Braces are required when {var} is followed by characters that could be part
of the name, or when using any of the operators below.
==============================================================================
2. Default Values *param-default*
`${var:-word}` *param-default-val*
Use default value. If {var} is unset or null, expand to {word}.
Otherwise, expand to the value of {var}.
Example:
`name=${1:-world}`
`echo "hello $name"` # prints "hello world" if \$1 is unset
`${var-word}` *param-default-nonnull*
Like `:-` but only substitutes {word} if {var} is completely unset,
not if it is null.
==============================================================================
3. Assign Defaults *param-assign*
`${var:=word}` *param-assign-val*
Assign default value. If {var} is unset or null, assign {word} to
{var} and then expand to the new value.
Note: This cannot be used with positional parameters or special
parameters.
Example:
`echo ${cache:=/tmp/cache}` # sets and uses \$cache
`${var=word}` *param-assign-nonnull*
Like `:=` but only assigns if {var} is completely unset.
==============================================================================
4. Error on Unset *param-error*
`${var:?word}` *param-error-val*
Display error. If {var} is unset or null, print {word} to stderr
and exit (in a non-interactive shell). If {word} is omitted, a
default message is printed.
Example:
`input=${1:?usage: myscript \<filename\>}`
`${var?word}` *param-error-nonnull*
Like `:?` but only errors if {var} is completely unset.
==============================================================================
5. Alternate Value *param-alt*
`${var:+word}` *param-alt-val*
Use alternate value. If {var} is unset or null, expand to nothing.
Otherwise, expand to {word}.
Example:
`echo ${verbose:+--verbose}` # flag only if \$verbose is set
`${var+word}` *param-alt-nonnull*
Like `:+` but substitutes {word} only if {var} is set (even if null).
==============================================================================
6. String Length *param-length*
`${#var}` *param-strlen*
Expands to the length of the value of {var} in characters.
Example:
`str="hello"`
`echo ${#str}` # prints 5
==============================================================================
7. Substring Removal *param-substring*
`${var#pattern}` *param-trim-short-left*
Remove shortest matching prefix. Removes the shortest match of
{pattern} from the beginning of the value of {var}.
`${var##pattern}` *param-trim-long-left*
Remove longest matching prefix.
Example:
`path="/home/user/file.txt"`
`echo ${path##*/}` # prints "file.txt"
`${var%pattern}` *param-trim-short-right*
Remove shortest matching suffix. Removes the shortest match of
{pattern} from the end of the value of {var}.
`${var%%pattern}` *param-trim-long-right*
Remove longest matching suffix.
Example:
`file="archive.tar.gz"`
`echo ${file%%.*}` # prints "archive"
`echo ${file%.*}` # prints "archive.tar"
==============================================================================
8. Search and Replace *param-replace*
`${var/pattern/replacement}` *param-replace-first*
Replace first match. Replaces the first occurrence of {pattern}
in the value of {var} with {replacement}.
`${var//pattern/replacement}` *param-replace-all*
Replace all matches.
Example:
`str="hello world"`
`echo ${str/o/0}` # prints "hell0 world"
`echo ${str//o/0}` # prints "hell0 w0rld"
`${var/#pattern/replacement}` *param-replace-prefix*
Replace if matching at the beginning.
`${var/%pattern/replacement}` *param-replace-suffix*
Replace if matching at the end.
==============================================================================
9. Case Modification *param-case*
`${var^}` *param-upper-first*
Uppercase the first character of {var}.
`${var^^}` *param-upper-all*
Uppercase all characters.
`${var,}` *param-lower-first*
Lowercase the first character of {var}.
`${var,,}` *param-lower-all*
Lowercase all characters.
Example:
`name="john doe"`
`echo ${name^}` # prints "John doe"
`echo ${name^^}` # prints "JOHN DOE"
==============================================================================
10. Substrings *param-slice*
`${var:offset}` *param-slice-from*
Substring starting at {offset} (0-indexed).
`${var:offset:length}` *param-slice-range*
Substring of {length} characters starting at {offset}.
Negative offsets count from the end (note the space before the minus
to distinguish from `:-`):
`str="hello world"`
`echo ${str: -5}` # prints "world"
`echo ${str:0:5}` # prints "hello"
==============================================================================
See also: |redirect| |glob| |arith|

181
doc/redirect.txt
View File

@@ -1,181 +0,0 @@
*redirect* *redirection* *redir*
#REDIRECTION#
Redirections allow you to control where a command reads its input from and
where it sends its output. A redirection applies to a specific file
descriptor; if no descriptor number is given, output redirections default
to stdout (fd 1) and input redirections default to stdin (fd 0).
==============================================================================
1. Output Redirection *redir-output*
`command > file` *redir-out*
Redirect stdout to {file}, creating it if it does not exist or
truncating it if it does.
Example:
`echo hello > out.txt`
`ls 2> errors.txt` # redirect stderr
`command >| file` *redir-out-force*
Like `>` but overrides the {noclobber} option. If {noclobber} is set,
`>` will refuse to overwrite an existing file; `>|` forces the
overwrite.
`command >> file` *redir-append*
Append stdout to {file}, creating it if it does not exist.
Example:
`echo line >> log.txt`
==============================================================================
2. Input Redirection *redir-input*
`command < file` *redir-in*
Redirect {file} to stdin.
Example:
`sort < unsorted.txt`
==============================================================================
3. Read-Write Redirection *redir-readwrite*
`command <> file` *redir-rw*
Open {file} for both reading and writing on the specified file
descriptor (default fd 0). The file is created if it does not exist
but is not truncated.
Useful with the `seek` builtin for random-access file operations.
Example:
`exec 3<> data.bin`
`seek 3 0 set` # seek to beginning
==============================================================================
4. File Descriptor Duplication *redir-dup*
`command N>&M` *redir-dup-out*
Duplicate output file descriptor {M} onto {N}. After this, writing
to fd {N} goes to the same place as fd {M}.
Example:
`command > out.txt 2>&1` # stderr goes where stdout goes
`command N<&M` *redir-dup-in*
Duplicate input file descriptor {M} onto {N}.
`command N>&-` *redir-close-out*
`command N<&-` *redir-close-in*
Close file descriptor {N}.
Example:
`exec 3>&-` # close fd 3
==============================================================================
5. Pipelines *redir-pipe*
`command1 | command2` *pipe*
Connect stdout of {command1} to stdin of {command2}. Both commands
run concurrently.
Example:
`cat file.txt | grep pattern | sort`
`command1 |& command2` *pipe-and*
Connect both stdout and stderr of {command1} to stdin of {command2}.
Equivalent to `command1 2>&1 | command2`.
==============================================================================
6. Here Documents *heredoc*
`command << DELIM` *redir-heredoc*
Read input from the script body until a line containing only {DELIM}
is found. The text between is fed to stdin of {command}.
Parameter expansion, command substitution, and arithmetic expansion
are performed in the body unless the delimiter is quoted.
Example:
`cat << EOF`
`Hello $USER`
`EOF`
`command << 'DELIM'` *redir-heredoc-literal*
Quoting the delimiter (single or double quotes) suppresses all
expansion in the heredoc body. The text is passed literally.
Example:
`cat << 'EOF'`
`This $variable is not expanded`
`EOF`
`command <<- DELIM` *redir-heredoc-indent*
Like `<<` but strips leading tab characters from each line of the
body and from the closing delimiter. This allows heredocs to be
indented for readability without affecting the content.
Example:
`if true; then`
` cat <<- EOF`
` indented content`
` EOF`
`fi`
==============================================================================
7. Here Strings *herestring*
`command <<< word` *redir-herestring*
Feed {word} as a single string to stdin of {command}, with a
trailing newline appended. {word} is subject to the usual expansions.
Example:
`read first rest <<< "hello world"`
`bc <<< "2 + 2"`
==============================================================================
8. File Descriptor Numbers *redir-fd*
Any redirection operator can be prefixed with a file descriptor number:
`2> file` redirect stderr to file
`3< file` open file on fd 3
`4>> file` append to file on fd 4
`5<> file` open file read-write on fd 5
Standard file descriptors:
0 stdin
1 stdout
2 stderr
File descriptors 3 and above are available for general use with `exec`.
==============================================================================
9. Combining Redirections *redir-combine*
Multiple redirections can appear on a single command, processed left
to right:
`command > out.txt 2>&1` # stdout to file, stderr to same file
`command 2>&1 > out.txt` # different! stderr to terminal,
# stdout to file
Order matters: each redirection is applied in sequence.
==============================================================================
See also: |param| |glob| |arith|

315
nix/hm-module.nix
View File

@@ -2,14 +2,325 @@
let let
cfg = config.programs.shed; cfg = config.programs.shed;
boolToString = b:
if b then "true" else "false";
mkAutoCmd = cfg:
lib.concatLines (map (hook: "autocmd ${hook} ${lib.optionalString (cfg.pattern != null) "-p \"${cfg.pattern}\""} '${cfg.command}'") cfg.hooks);
mkFunctionDef = name: body:
let
indented = "\t" + lib.concatStringsSep "\n\t" (lib.splitString "\n" body);
in
''
${name}() {
${indented}
}'';
mkKeymapCmd = cfg: let
flags = "-${lib.concatStrings cfg.modes}";
keys = "'${cfg.keys}'";
action = "'${cfg.command}'";
in
"keymap ${flags} ${keys} ${action}";
mkCompleteCmd = name: cfg: let
flags = lib.concatStrings [
(lib.optionalString cfg.files " -f")
(lib.optionalString cfg.dirs " -d")
(lib.optionalString cfg.commands " -c")
(lib.optionalString cfg.variables " -v")
(lib.optionalString cfg.users " -u")
(lib.optionalString cfg.jobs " -j")
(lib.optionalString cfg.aliases " -a")
(lib.optionalString cfg.signals " -S")
(lib.optionalString cfg.noSpace " -n")
(lib.optionalString (cfg.function != null) " -F ${cfg.function}")
(lib.optionalString (cfg.fallback != "no") " -o ${cfg.fallback}")
(lib.optionalString (cfg.wordList != []) " -W '${lib.concatStringsSep " " cfg.wordList}'")
];
in "complete${flags} ${name}";
in in
{ {
options.programs.shed = import ./shed_opts.nix { inherit pkgs lib; }; options.programs.shed = {
enable = lib.mkEnableOption "shed shell";
package = lib.mkOption {
type = lib.types.package;
default = pkgs.shed;
description = "The shed package to use";
};
aliases = lib.mkOption {
type = lib.types.attrsOf lib.types.str;
default = {};
description = "Aliases to set when shed starts";
};
functions = lib.mkOption {
type = lib.types.attrsOf lib.types.str;
default = {};
description = "Shell functions to set when shed starts";
};
autocmds = lib.mkOption {
type = lib.types.listOf (lib.types.submodule {
options = {
hooks = lib.mkOption {
type = lib.types.addCheck (lib.types.listOf (lib.types.enum [
"pre-cmd"
"post-cmd"
"pre-change-dir"
"post-change-dir"
"on-job-finish"
"pre-prompt"
"post-prompt"
"pre-mode-change"
"post-mode-change"
"on-exit"
"on-history-open"
"on-history-close"
"on-history-select"
"on-completion-start"
"on-completion-cancel"
"on-completion-select"
])) (list: list != []);
description = "The events that trigger this autocmd";
};
pattern = lib.mkOption {
type = lib.types.nullOr lib.types.str;
default = null;
description = "A regex pattern to use in the hook to determine whether it runs or not. What it's compared to differs by hook, for instance 'pre-change-dir' compares it to the new directory, pre-cmd compares it to the command, etc";
};
command = lib.mkOption {
type = lib.types.addCheck lib.types.str (cmd: cmd != "");
description = "The shell command to execute when the hook is triggered and the pattern (if provided) matches";
};
};
});
default = [];
description = "Custom autocmds to set when shed starts";
};
keymaps = lib.mkOption {
type = lib.types.listOf (lib.types.submodule {
options = {
modes = lib.mkOption {
type = lib.types.listOf (lib.types.enum [ "n" "i" "x" "v" "o" "r" ]);
default = [];
description = "The editing modes this keymap can be used in";
};
keys = lib.mkOption {
type = lib.types.str;
default = "";
description = "The sequence of keys that trigger this keymap";
};
command = lib.mkOption {
type = lib.types.str;
default = "";
description = "The sequence of characters to send to the line editor when the keymap is triggered.";
};
};
});
default = [];
description = "Custom keymaps to set when shed starts";
};
extraCompletion = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule {
options = {
files = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete file names in the current directory";
};
dirs = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete directory names in the current directory";
};
commands = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete executable commands in the PATH";
};
variables = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete variable names";
};
users = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete user names from /etc/passwd";
};
jobs = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete job names or pids from the current shell session";
};
aliases = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete alias names defined in the current shell session";
};
signals = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete signal names for commands like kill";
};
wordList = lib.mkOption {
type = lib.types.listOf lib.types.str;
default = [];
description = "Complete from a custom list of words";
};
function = lib.mkOption {
type = lib.types.nullOr lib.types.str;
default = null;
description = "Complete using a custom shell function (should be defined in extraCompletionPreConfig)";
};
noSpace = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Don't append a space after completion";
};
fallback = lib.mkOption {
type = lib.types.enum [ "no" "default" "dirnames" ];
default = "no";
description = "Fallback behavior when no matches are found: 'no' means no fallback, 'default' means fall back to the default shell completion behavior, and 'directories' means fall back to completing directory names";
};
};
});
default = {};
description = "Additional completion scripts to source when shed starts (e.g. for custom tools or functions)";
};
environmentVars = lib.mkOption {
type = lib.types.attrsOf lib.types.str;
default = {};
description = "Environment variables to set when shed starts";
};
settings = {
dotGlob = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to include hidden files in glob patterns";
};
autocd = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to automatically change into directories when they are entered as commands";
};
historyIgnoresDupes = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to ignore duplicate entries in the command history";
};
maxHistoryEntries = lib.mkOption {
type = lib.types.int;
default = 10000;
description = "The maximum number of entries to keep in the command history";
};
interactiveComments = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to allow comments in interactive mode";
};
autoHistory = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to automatically add commands to the history as they are executed";
};
bellEnabled = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to allow shed to ring the terminal bell on certain events (e.g. command completion, errors, etc.)";
};
maxRecurseDepth = lib.mkOption {
type = lib.types.int;
default = 1000;
description = "The maximum depth to allow when recursively executing shell functions";
};
leaderKey = lib.mkOption {
type = lib.types.str;
default = "\\\\";
description = "The leader key to use for custom keymaps (e.g. if set to '\\\\', then a keymap with keys='x' would be triggered by '\\x')";
};
promptPathSegments = lib.mkOption {
type = lib.types.int;
default = 4;
description = "The maximum number of path segments to show in the prompt";
};
completionLimit = lib.mkOption {
type = lib.types.int;
default = 1000;
description = "The maximum number of completion candidates to show before truncating the list";
};
syntaxHighlighting = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to enable syntax highlighting in the shell";
};
linebreakOnIncomplete = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to automatically insert a newline when the input is incomplete";
};
extraPostConfig = lib.mkOption {
type = lib.types.str;
default = "";
description = "Additional configuration to append to the shed configuration file";
};
extraPreConfig = lib.mkOption {
type = lib.types.str;
default = "";
description = "Additional configuration to prepend to the shed configuration file";
};
};
};
config = config =
let
completeLines = lib.concatLines (lib.mapAttrsToList mkCompleteCmd cfg.extraCompletion);
keymapLines = lib.concatLines (map mkKeymapCmd cfg.keymaps);
functionLines = lib.concatLines (lib.mapAttrsToList mkFunctionDef cfg.functions);
autocmdLines = lib.concatLines (map mkAutoCmd cfg.autocmds);
in
lib.mkIf cfg.enable { lib.mkIf cfg.enable {
home.packages = [ cfg.package ]; home.packages = [ cfg.package ];
home.file.".shedrc".text = import ./render_rc.nix lib cfg; home.file.".shedrc".text = lib.concatLines [
cfg.settings.extraPreConfig
(lib.concatLines (lib.mapAttrsToList (name: value: "export ${name}=\"${value}\"") cfg.environmentVars))
(lib.concatLines (lib.mapAttrsToList (name: value: "alias ${name}=\"${value}\"") cfg.aliases))
(lib.concatLines [
"shopt core.dotglob=${boolToString cfg.settings.dotGlob}"
"shopt core.autocd=${boolToString cfg.settings.autocd}"
"shopt core.hist_ignore_dupes=${boolToString cfg.settings.historyIgnoresDupes}"
"shopt core.max_hist=${toString cfg.settings.maxHistoryEntries}"
"shopt core.interactive_comments=${boolToString cfg.settings.interactiveComments}"
"shopt core.auto_hist=${boolToString cfg.settings.autoHistory}"
"shopt core.bell_enabled=${boolToString cfg.settings.bellEnabled}"
"shopt core.max_recurse_depth=${toString cfg.settings.maxRecurseDepth}"
"shopt prompt.leader='${cfg.settings.leaderKey}'"
"shopt prompt.trunc_prompt_path=${toString cfg.settings.promptPathSegments}"
"shopt prompt.comp_limit=${toString cfg.settings.completionLimit}"
"shopt prompt.highlight=${boolToString cfg.settings.syntaxHighlighting}"
"shopt prompt.linebreak_on_incomplete=${boolToString cfg.settings.linebreakOnIncomplete}"
functionLines
completeLines
keymapLines
autocmdLines
])
cfg.settings.extraPostConfig
];
}; };
} }

11
nix/module.nix
View File

@@ -4,11 +4,18 @@ let
cfg = config.programs.shed; cfg = config.programs.shed;
in in
{ {
options.programs.shed = import ./shed_opts.nix { inherit pkgs lib; }; options.programs.shed = {
enable = lib.mkEnableOption "shed shell";
package = lib.mkOption {
type = lib.types.package;
default = pkgs.shed;
description = "The shed package to use";
};
};
config = lib.mkIf cfg.enable { config = lib.mkIf cfg.enable {
environment.systemPackages = [ cfg.package ]; environment.systemPackages = [ cfg.package ];
environment.shells = [ cfg.package ]; environment.shells = [ cfg.package ];
environment.etc."shed/shedrc".text = import ./render_rc.nix lib cfg;
}; };
} }

83
nix/render_rc.nix
View File

@@ -1,83 +0,0 @@
lib: cfg:
let
boolToString = b:
if b then "true" else "false";
mkAutoCmd = cfg:
lib.concatLines (map (hook: "autocmd ${hook} ${lib.optionalString (cfg.pattern != null) "-p \"${cfg.pattern}\""} '${cfg.command}'") cfg.hooks);
mkFunctionDef = name: body:
let
indented = "\t" + lib.concatStringsSep "\n\t" (lib.splitString "\n" body);
in
''
${name}() {
${indented}
}'';
mkKeymapCmd = cfg: let
flags = "-${lib.concatStrings cfg.modes}";
keys = "'${cfg.keys}'";
action = "'${cfg.command}'";
in
"keymap ${flags} ${keys} ${action}";
mkCompleteCmd = name: cfg: let
flags = lib.concatStrings [
(lib.optionalString cfg.files " -f")
(lib.optionalString cfg.dirs " -d")
(lib.optionalString cfg.commands " -c")
(lib.optionalString cfg.variables " -v")
(lib.optionalString cfg.users " -u")
(lib.optionalString cfg.jobs " -j")
(lib.optionalString cfg.aliases " -a")
(lib.optionalString cfg.signals " -S")
(lib.optionalString cfg.noSpace " -n")
(lib.optionalString (cfg.function != null) " -F ${cfg.function}")
(lib.optionalString (cfg.fallback != "no") " -o ${cfg.fallback}")
(lib.optionalString (cfg.wordList != []) " -W '${lib.concatStringsSep " " cfg.wordList}'")
];
in "complete${flags} ${name}";
completeLines = lib.concatLines (lib.mapAttrsToList mkCompleteCmd cfg.extraCompletion);
keymapLines = lib.concatLines (map mkKeymapCmd cfg.keymaps);
functionLines = lib.concatLines (lib.mapAttrsToList mkFunctionDef cfg.functions);
autocmdLines = lib.concatLines (map mkAutoCmd cfg.autocmds);
in
lib.concatLines [
cfg.settings.extraPreConfig
(lib.concatLines (lib.mapAttrsToList (name: value: "export ${name}=\"${value}\"") cfg.environmentVars))
(lib.concatLines (lib.mapAttrsToList (name: value: "alias ${name}=\"${value}\"") cfg.aliases))
(lib.concatLines [
"shopt core.dotglob=${boolToString cfg.settings.dotGlob}"
"shopt core.autocd=${boolToString cfg.settings.autocd}"
"shopt core.hist_ignore_dupes=${boolToString cfg.settings.historyIgnoresDupes}"
"shopt core.max_hist=${toString cfg.settings.maxHistoryEntries}"
"shopt core.interactive_comments=${boolToString cfg.settings.interactiveComments}"
"shopt core.auto_hist=${boolToString cfg.settings.autoHistory}"
"shopt core.bell_enabled=${boolToString cfg.settings.bellEnabled}"
"shopt core.max_recurse_depth=${toString cfg.settings.maxRecurseDepth}"
"shopt core.xpg_echo=${boolToString cfg.settings.echoExpandsEscapes}"
"shopt core.noclobber=${boolToString cfg.settings.noClobber}"
"shopt prompt.leader='${cfg.settings.leaderKey}'"
"shopt prompt.trunc_prompt_path=${toString cfg.settings.promptPathSegments}"
"shopt prompt.comp_limit=${toString cfg.settings.completionLimit}"
"shopt prompt.highlight=${boolToString cfg.settings.syntaxHighlighting}"
"shopt prompt.linebreak_on_incomplete=${boolToString cfg.settings.linebreakOnIncomplete}"
"shopt prompt.line_numbers=${boolToString cfg.settings.lineNumbers}"
"shopt prompt.screensaver_idle_time=${toString cfg.settings.screensaverIdleTime}"
"shopt prompt.screensaver_cmd='${cfg.settings.screensaverCmd}'"
"shopt prompt.completion_ignore_case=${boolToString cfg.settings.completionIgnoreCase}"
"shopt prompt.auto_indent=${boolToString cfg.settings.autoIndent}"
functionLines
completeLines
keymapLines
autocmdLines
])
cfg.settings.extraPostConfig
]

279
nix/shed_opts.nix
View File

@@ -1,279 +0,0 @@
{ pkgs, lib }:
{
enable = lib.mkEnableOption "shed shell";
package = lib.mkOption {
type = lib.types.package;
default = pkgs.shed;
description = "The shed package to use";
};
aliases = lib.mkOption {
type = lib.types.attrsOf lib.types.str;
default = {};
description = "Aliases to set when shed starts";
};
functions = lib.mkOption {
type = lib.types.attrsOf lib.types.str;
default = {};
description = "Shell functions to set when shed starts";
};
autocmds = lib.mkOption {
type = lib.types.listOf (lib.types.submodule {
options = {
hooks = lib.mkOption {
type = lib.types.addCheck (lib.types.listOf (lib.types.enum [
"pre-cmd"
"post-cmd"
"pre-change-dir"
"post-change-dir"
"on-job-finish"
"pre-prompt"
"post-prompt"
"pre-mode-change"
"post-mode-change"
"on-exit"
"on-history-open"
"on-history-close"
"on-history-select"
"on-completion-start"
"on-completion-cancel"
"on-completion-select"
])) (list: list != []);
description = "The events that trigger this autocmd";
};
pattern = lib.mkOption {
type = lib.types.nullOr lib.types.str;
default = null;
description = "A regex pattern to use in the hook to determine whether it runs or not. What it's compared to differs by hook, for instance 'pre-change-dir' compares it to the new directory, pre-cmd compares it to the command, etc";
};
command = lib.mkOption {
type = lib.types.addCheck lib.types.str (cmd: cmd != "");
description = "The shell command to execute when the hook is triggered and the pattern (if provided) matches";
};
};
});
default = [];
description = "Custom autocmds to set when shed starts";
};
keymaps = lib.mkOption {
type = lib.types.listOf (lib.types.submodule {
options = {
modes = lib.mkOption {
type = lib.types.listOf (lib.types.enum [ "n" "i" "x" "v" "o" "r" ]);
default = [];
description = "The editing modes this keymap can be used in";
};
keys = lib.mkOption {
type = lib.types.str;
default = "";
description = "The sequence of keys that trigger this keymap";
};
command = lib.mkOption {
type = lib.types.str;
default = "";
description = "The sequence of characters to send to the line editor when the keymap is triggered.";
};
};
});
default = [];
description = "Custom keymaps to set when shed starts";
};
extraCompletion = lib.mkOption {
type = lib.types.attrsOf (lib.types.submodule {
options = {
files = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete file names in the current directory";
};
dirs = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete directory names in the current directory";
};
commands = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete executable commands in the PATH";
};
variables = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete variable names";
};
users = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete user names from /etc/passwd";
};
jobs = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete job names or pids from the current shell session";
};
aliases = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete alias names defined in the current shell session";
};
signals = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Complete signal names for commands like kill";
};
wordList = lib.mkOption {
type = lib.types.listOf lib.types.str;
default = [];
description = "Complete from a custom list of words";
};
function = lib.mkOption {
type = lib.types.nullOr lib.types.str;
default = null;
description = "Complete using a custom shell function (should be defined in extraCompletionPreConfig)";
};
noSpace = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Don't append a space after completion";
};
fallback = lib.mkOption {
type = lib.types.enum [ "no" "default" "dirnames" ];
default = "no";
description = "Fallback behavior when no matches are found: 'no' means no fallback, 'default' means fall back to the default shell completion behavior, and 'directories' means fall back to completing directory names";
};
};
});
default = {};
description = "Additional completion scripts to source when shed starts (e.g. for custom tools or functions)";
};
environmentVars = lib.mkOption {
type = lib.types.attrsOf lib.types.str;
default = {};
description = "Environment variables to set when shed starts";
};
settings = {
dotGlob = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to include hidden files in glob patterns";
};
autocd = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to automatically change into directories when they are entered as commands";
};
historyIgnoresDupes = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to ignore duplicate entries in the command history";
};
maxHistoryEntries = lib.mkOption {
type = lib.types.int;
default = 10000;
description = "The maximum number of entries to keep in the command history";
};
interactiveComments = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to allow comments in interactive mode";
};
autoHistory = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to automatically add commands to the history as they are executed";
};
bellEnabled = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to allow shed to ring the terminal bell on certain events (e.g. command completion, errors, etc.)";
};
maxRecurseDepth = lib.mkOption {
type = lib.types.int;
default = 1000;
description = "The maximum depth to allow when recursively executing shell functions";
};
echoExpandsEscapes = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to have the 'echo' builtin expand escape sequences like \\n and \\t (if false, it will print them verbatim)";
};
noClobber = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to prevent redirection from overwriting existing files by default (i.e. behave as if 'set -o noclobber' is always in effect)";
};
leaderKey = lib.mkOption {
type = lib.types.str;
default = "\\\\";
description = "The leader key to use for custom keymaps (e.g. if set to '\\\\', then a keymap with keys='x' would be triggered by '\\x')";
};
promptPathSegments = lib.mkOption {
type = lib.types.int;
default = 4;
description = "The maximum number of path segments to show in the prompt";
};
completionLimit = lib.mkOption {
type = lib.types.int;
default = 1000;
description = "The maximum number of completion candidates to show before truncating the list";
};
syntaxHighlighting = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to enable syntax highlighting in the shell";
};
linebreakOnIncomplete = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to automatically insert a newline when the input is incomplete";
};
lineNumbers = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to show line numbers in the prompt";
};
screensaverCmd = lib.mkOption {
type = lib.types.str;
default = "";
description = "A shell command to execute after a period of inactivity (i.e. a custom screensaver)";
};
screensaverIdleTime = lib.mkOption {
type = lib.types.int;
default = 0;
description = "The amount of inactivity time in seconds before the screensaver command is executed";
};
completionIgnoreCase = lib.mkOption {
type = lib.types.bool;
default = false;
description = "Whether to ignore case when completing commands and file names";
};
autoIndent = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Whether to automatically indent new lines based on the previous line";
};
extraPostConfig = lib.mkOption {
type = lib.types.str;
default = "";
description = "Additional configuration to append to the shed configuration file";
};
extraPreConfig = lib.mkOption {
type = lib.types.str;
default = "";
description = "Additional configuration to prepend to the shed configuration file";
};
};
}

32
src/builtin/alias.rs
View File

@@ -38,30 +38,28 @@ pub fn alias(node: Node) -> ShResult<()> {
write(stdout, alias_output.as_bytes())?; // Write it write(stdout, alias_output.as_bytes())?; // Write it
} else { } else {
for (arg, span) in argv { for (arg, span) in argv {
let Some((name, body)) = arg.split_once('=') else { let Some((name, body)) = arg.split_once('=') else {
let Some(alias) = read_logic(|l| l.get_alias(&arg)) else { let Some(alias) = read_logic(|l| l.get_alias(&arg)) else {
return Err(ShErr::at( return Err(ShErr::at(
ShErrKind::SyntaxErr, ShErrKind::SyntaxErr,
span, span,
"alias: Expected an assignment in alias args", "alias: Expected an assignment in alias args",
)); ));
}; };
let alias_output = format!("{arg}='{alias}'"); let alias_output = format!("{arg}='{alias}'");
let stdout = borrow_fd(STDOUT_FILENO); let stdout = borrow_fd(STDOUT_FILENO);
write(stdout, alias_output.as_bytes())?; // Write it write(stdout, alias_output.as_bytes())?; // Write it
state::set_status(0); state::set_status(0);
return Ok(()); return Ok(());
}; };
if name == "command" || name == "builtin" { if name == "command" || name == "builtin" {
return Err(ShErr::at( return Err(ShErr::at(
ShErrKind::ExecFail, ShErrKind::ExecFail,
span, span,
format!( format!("alias: Cannot assign alias to reserved name '{}'", name.fg(next_color())),
"alias: Cannot assign alias to reserved name '{}'",
name.fg(next_color())
),
)); ));
} }
write_logic(|l| l.insert_alias(name, body, span.clone())); write_logic(|l| l.insert_alias(name, body, span.clone()));
@@ -120,7 +118,7 @@ pub fn unalias(node: Node) -> ShResult<()> {
mod tests { mod tests {
use crate::state::{self, read_logic}; use crate::state::{self, read_logic};
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
use pretty_assertions::assert_eq; use pretty_assertions::assert_eq;
#[test] #[test]
fn alias_set_and_expand() { fn alias_set_and_expand() {

4
src/builtin/arrops.rs
View File

@@ -229,9 +229,9 @@ pub fn get_arr_op_opts(opts: Vec<Opt>) -> ShResult<ArrOpOpts> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::state::{self, VarFlags, VarKind, read_vars, write_vars};
use crate::testutil::{TestGuard, test_input};
use std::collections::VecDeque; use std::collections::VecDeque;
use crate::state::{self, read_vars, write_vars, VarFlags, VarKind};
use crate::testutil::{TestGuard, test_input};
fn set_arr(name: &str, elems: &[&str]) { fn set_arr(name: &str, elems: &[&str]) {
let arr = VecDeque::from_iter(elems.iter().map(|s| s.to_string())); let arr = VecDeque::from_iter(elems.iter().map(|s| s.to_string()));

30
src/builtin/autocmd.rs
View File

@@ -159,10 +159,7 @@ mod tests {
test_input("autocmd post-cmd 'echo post'").unwrap(); test_input("autocmd post-cmd 'echo post'").unwrap();
assert_eq!(read_logic(|l| l.get_autocmds(AutoCmdKind::PreCmd)).len(), 1); assert_eq!(read_logic(|l| l.get_autocmds(AutoCmdKind::PreCmd)).len(), 1);
assert_eq!( assert_eq!(read_logic(|l| l.get_autocmds(AutoCmdKind::PostCmd)).len(), 1);
read_logic(|l| l.get_autocmds(AutoCmdKind::PostCmd)).len(),
1
);
} }
// ===================== Pattern ===================== // ===================== Pattern =====================
@@ -208,10 +205,7 @@ mod tests {
test_input("autocmd -c pre-cmd").unwrap(); test_input("autocmd -c pre-cmd").unwrap();
assert_eq!(read_logic(|l| l.get_autocmds(AutoCmdKind::PreCmd)).len(), 0); assert_eq!(read_logic(|l| l.get_autocmds(AutoCmdKind::PreCmd)).len(), 0);
assert_eq!( assert_eq!(read_logic(|l| l.get_autocmds(AutoCmdKind::PostCmd)).len(), 1);
read_logic(|l| l.get_autocmds(AutoCmdKind::PostCmd)).len(),
1
);
} }
#[test] #[test]
@@ -251,21 +245,11 @@ mod tests {
fn all_kinds_parse() { fn all_kinds_parse() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
let kinds = [ let kinds = [
"pre-cmd", "pre-cmd", "post-cmd", "pre-change-dir", "post-change-dir",
"post-cmd", "on-job-finish", "pre-prompt", "post-prompt",
"pre-change-dir", "pre-mode-change", "post-mode-change",
"post-change-dir", "on-history-open", "on-history-close", "on-history-select",
"on-job-finish", "on-completion-start", "on-completion-cancel", "on-completion-select",
"pre-prompt",
"post-prompt",
"pre-mode-change",
"post-mode-change",
"on-history-open",
"on-history-close",
"on-history-select",
"on-completion-start",
"on-completion-cancel",
"on-completion-select",
"on-exit", "on-exit",
]; ];
for kind in kinds { for kind in kinds {

242
src/builtin/cd.rs
View File

@@ -78,165 +78,159 @@ pub fn cd(node: Node) -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
pub mod tests { pub mod tests {
use std::env; use std::env;
use std::fs; use std::fs;
use tempfile::TempDir; use tempfile::TempDir;
use crate::state; use crate::state;
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
// ===================== Basic Navigation ===================== // ===================== Basic Navigation =====================
#[test] #[test]
fn cd_simple() { fn cd_simple() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let old_dir = env::current_dir().unwrap(); let old_dir = env::current_dir().unwrap();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
test_input(format!("cd {}", temp_dir.path().display())).unwrap(); test_input(format!("cd {}", temp_dir.path().display())).unwrap();
let new_dir = env::current_dir().unwrap(); let new_dir = env::current_dir().unwrap();
assert_ne!(old_dir, new_dir); assert_ne!(old_dir, new_dir);
assert_eq!( assert_eq!(new_dir.display().to_string(), temp_dir.path().display().to_string());
new_dir.display().to_string(), }
temp_dir.path().display().to_string()
);
}
#[test] #[test]
fn cd_no_args_goes_home() { fn cd_no_args_goes_home() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
unsafe { env::set_var("HOME", temp_dir.path()) }; unsafe { env::set_var("HOME", temp_dir.path()) };
test_input("cd").unwrap(); test_input("cd").unwrap();
let cwd = env::current_dir().unwrap(); let cwd = env::current_dir().unwrap();
assert_eq!( assert_eq!(cwd.display().to_string(), temp_dir.path().display().to_string());
cwd.display().to_string(), }
temp_dir.path().display().to_string()
);
}
#[test] #[test]
fn cd_relative_path() { fn cd_relative_path() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
let sub = temp_dir.path().join("child"); let sub = temp_dir.path().join("child");
fs::create_dir(&sub).unwrap(); fs::create_dir(&sub).unwrap();
test_input(format!("cd {}", temp_dir.path().display())).unwrap(); test_input(format!("cd {}", temp_dir.path().display())).unwrap();
test_input("cd child").unwrap(); test_input("cd child").unwrap();
let cwd = env::current_dir().unwrap(); let cwd = env::current_dir().unwrap();
assert_eq!(cwd.display().to_string(), sub.display().to_string()); assert_eq!(cwd.display().to_string(), sub.display().to_string());
} }
// ===================== Environment ===================== // ===================== Environment =====================
#[test] #[test]
fn cd_sets_pwd_env() { fn cd_sets_pwd_env() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
test_input(format!("cd {}", temp_dir.path().display())).unwrap(); test_input(format!("cd {}", temp_dir.path().display())).unwrap();
let pwd = env::var("PWD").unwrap(); let pwd = env::var("PWD").unwrap();
assert_eq!(pwd, env::current_dir().unwrap().display().to_string()); assert_eq!(pwd, env::current_dir().unwrap().display().to_string());
} }
#[test] #[test]
fn cd_status_zero_on_success() { fn cd_status_zero_on_success() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
test_input(format!("cd {}", temp_dir.path().display())).unwrap(); test_input(format!("cd {}", temp_dir.path().display())).unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
// ===================== Error Cases ===================== // ===================== Error Cases =====================
#[test] #[test]
fn cd_nonexistent_dir_fails() { fn cd_nonexistent_dir_fails() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let result = test_input("cd /nonexistent_path_that_does_not_exist_xyz"); let result = test_input("cd /nonexistent_path_that_does_not_exist_xyz");
assert!(result.is_err()); assert!(result.is_err());
} }
#[test] #[test]
fn cd_file_not_directory_fails() { fn cd_file_not_directory_fails() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
let file_path = temp_dir.path().join("afile.txt"); let file_path = temp_dir.path().join("afile.txt");
fs::write(&file_path, "hello").unwrap(); fs::write(&file_path, "hello").unwrap();
let result = test_input(format!("cd {}", file_path.display())); let result = test_input(format!("cd {}", file_path.display()));
assert!(result.is_err()); assert!(result.is_err());
} }
// ===================== Multiple cd ===================== // ===================== Multiple cd =====================
#[test] #[test]
fn cd_multiple_times() { fn cd_multiple_times() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let dir_a = TempDir::new().unwrap(); let dir_a = TempDir::new().unwrap();
let dir_b = TempDir::new().unwrap(); let dir_b = TempDir::new().unwrap();
test_input(format!("cd {}", dir_a.path().display())).unwrap(); test_input(format!("cd {}", dir_a.path().display())).unwrap();
assert_eq!( assert_eq!(
env::current_dir().unwrap().display().to_string(), env::current_dir().unwrap().display().to_string(),
dir_a.path().display().to_string() dir_a.path().display().to_string()
); );
test_input(format!("cd {}", dir_b.path().display())).unwrap(); test_input(format!("cd {}", dir_b.path().display())).unwrap();
assert_eq!( assert_eq!(
env::current_dir().unwrap().display().to_string(), env::current_dir().unwrap().display().to_string(),
dir_b.path().display().to_string() dir_b.path().display().to_string()
); );
} }
#[test] #[test]
fn cd_nested_subdirectories() { fn cd_nested_subdirectories() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
let deep = temp_dir.path().join("a").join("b").join("c"); let deep = temp_dir.path().join("a").join("b").join("c");
fs::create_dir_all(&deep).unwrap(); fs::create_dir_all(&deep).unwrap();
test_input(format!("cd {}", deep.display())).unwrap(); test_input(format!("cd {}", deep.display())).unwrap();
assert_eq!( assert_eq!(
env::current_dir().unwrap().display().to_string(), env::current_dir().unwrap().display().to_string(),
deep.display().to_string() deep.display().to_string()
); );
} }
// ===================== Autocmd Integration ===================== // ===================== Autocmd Integration =====================
#[test] #[test]
fn cd_fires_post_change_dir_autocmd() { fn cd_fires_post_change_dir_autocmd() {
let guard = TestGuard::new(); let guard = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
test_input("autocmd post-change-dir 'echo cd-hook-fired'").unwrap(); test_input("autocmd post-change-dir 'echo cd-hook-fired'").unwrap();
guard.read_output(); guard.read_output();
test_input(format!("cd {}", temp_dir.path().display())).unwrap(); test_input(format!("cd {}", temp_dir.path().display())).unwrap();
let out = guard.read_output(); let out = guard.read_output();
assert!(out.contains("cd-hook-fired")); assert!(out.contains("cd-hook-fired"));
} }
#[test] #[test]
fn cd_fires_pre_change_dir_autocmd() { fn cd_fires_pre_change_dir_autocmd() {
let guard = TestGuard::new(); let guard = TestGuard::new();
let temp_dir = TempDir::new().unwrap(); let temp_dir = TempDir::new().unwrap();
test_input("autocmd pre-change-dir 'echo pre-cd'").unwrap(); test_input("autocmd pre-change-dir 'echo pre-cd'").unwrap();
guard.read_output(); guard.read_output();
test_input(format!("cd {}", temp_dir.path().display())).unwrap(); test_input(format!("cd {}", temp_dir.path().display())).unwrap();
let out = guard.read_output(); let out = guard.read_output();
assert!(out.contains("pre-cd")); assert!(out.contains("pre-cd"));
} }
} }

16
src/builtin/complete.rs
View File

@@ -176,20 +176,20 @@ pub fn complete_builtin(node: Node) -> ShResult<()> {
read_meta(|m| -> ShResult<()> { read_meta(|m| -> ShResult<()> {
let specs = m.comp_specs().values(); let specs = m.comp_specs().values();
for spec in specs { for spec in specs {
let stdout = borrow_fd(STDOUT_FILENO); let stdout = borrow_fd(STDOUT_FILENO);
write(stdout, spec.source().as_bytes())?; write(stdout, spec.source().as_bytes())?;
} }
Ok(()) Ok(())
})?; })?;
} else { } else {
read_meta(|m| -> ShResult<()> { read_meta(|m| -> ShResult<()> {
for (cmd, _) in &argv { for (cmd, _) in &argv {
if let Some(spec) = m.comp_specs().get(cmd) { if let Some(spec) = m.comp_specs().get(cmd) {
let stdout = borrow_fd(STDOUT_FILENO); let stdout = borrow_fd(STDOUT_FILENO);
write(stdout, spec.source().as_bytes())?; write(stdout, spec.source().as_bytes())?;
} }
} }
Ok(()) Ok(())
})?; })?;
} }
@@ -316,10 +316,10 @@ pub fn get_comp_opts(opts: Vec<Opt>) -> ShResult<CompOpts> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::state::{self, VarFlags, VarKind, read_meta, write_vars};
use crate::testutil::{TestGuard, test_input};
use std::fs; use std::fs;
use tempfile::TempDir; use tempfile::TempDir;
use crate::state::{self, read_meta, write_vars, VarFlags, VarKind};
use crate::testutil::{TestGuard, test_input};
// ===================== complete: Registration ===================== // ===================== complete: Registration =====================

317
src/builtin/dirstack.rs
View File

@@ -12,13 +12,12 @@ use crate::{
}; };
pub fn truncate_home_path(path: String) -> String { pub fn truncate_home_path(path: String) -> String {
if let Ok(home) = env::var("HOME") if let Ok(home) = env::var("HOME")
&& path.starts_with(&home) && path.starts_with(&home) {
{ let new = path.strip_prefix(&home).unwrap();
let new = path.strip_prefix(&home).unwrap(); return format!("~{new}");
return format!("~{new}"); }
} path.to_string()
path.to_string()
} }
enum StackIdx { enum StackIdx {
@@ -377,7 +376,8 @@ pub fn dirs(node: Node) -> ShResult<()> {
.map(|d| d.to_string_lossy().to_string()); .map(|d| d.to_string_lossy().to_string());
if abbreviate_home { if abbreviate_home {
stack.map(truncate_home_path).collect() stack.map(truncate_home_path)
.collect()
} else { } else {
stack.collect() stack.collect()
} }
@@ -428,198 +428,189 @@ pub fn dirs(node: Node) -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
pub mod tests { pub mod tests {
use crate::{ use std::{env, path::PathBuf};
state::{self, read_meta}, use crate::{state::{self, read_meta}, testutil::{TestGuard, test_input}};
testutil::{TestGuard, test_input}, use pretty_assertions::{assert_ne,assert_eq};
}; use tempfile::TempDir;
use pretty_assertions::{assert_eq, assert_ne};
use std::{env, path::PathBuf};
use tempfile::TempDir;
#[test] #[test]
fn test_pushd_interactive() { fn test_pushd_interactive() {
let g = TestGuard::new(); let g = TestGuard::new();
let current_dir = env::current_dir().unwrap(); let current_dir = env::current_dir().unwrap();
test_input("pushd /tmp").unwrap(); test_input("pushd /tmp").unwrap();
let new_dir = env::current_dir().unwrap(); let new_dir = env::current_dir().unwrap();
assert_ne!(new_dir, current_dir); assert_ne!(new_dir, current_dir);
assert_eq!(new_dir, PathBuf::from("/tmp")); assert_eq!(new_dir, PathBuf::from("/tmp"));
let dir_stack = read_meta(|m| m.dirs().clone()); let dir_stack = read_meta(|m| m.dirs().clone());
assert_eq!(dir_stack.len(), 1); assert_eq!(dir_stack.len(), 1);
assert_eq!(dir_stack[0], current_dir); assert_eq!(dir_stack[0], current_dir);
let out = g.read_output(); let out = g.read_output();
let path = super::truncate_home_path(current_dir.to_string_lossy().to_string()); let path = super::truncate_home_path(current_dir.to_string_lossy().to_string());
assert_eq!(out, format!("/tmp {path}\n")); assert_eq!(out, format!("/tmp {path}\n"));
} }
#[test] #[test]
fn test_popd_interactive() { fn test_popd_interactive() {
let g = TestGuard::new(); let g = TestGuard::new();
let current_dir = env::current_dir().unwrap(); let current_dir = env::current_dir().unwrap();
let tempdir = TempDir::new().unwrap(); let tempdir = TempDir::new().unwrap();
let tempdir_raw = tempdir.path().to_path_buf().to_string_lossy().to_string(); let tempdir_raw = tempdir.path().to_path_buf().to_string_lossy().to_string();
test_input(format!("pushd {tempdir_raw}")).unwrap(); test_input(format!("pushd {tempdir_raw}")).unwrap();
let dir_stack = read_meta(|m| m.dirs().clone()); let dir_stack = read_meta(|m| m.dirs().clone());
assert_eq!(dir_stack.len(), 1); assert_eq!(dir_stack.len(), 1);
assert_eq!(dir_stack[0], current_dir); assert_eq!(dir_stack[0], current_dir);
assert_eq!(env::current_dir().unwrap(), tempdir.path()); assert_eq!(env::current_dir().unwrap(), tempdir.path());
g.read_output(); // consume output of pushd g.read_output(); // consume output of pushd
test_input("popd").unwrap(); test_input("popd").unwrap();
assert_eq!(env::current_dir().unwrap(), current_dir); assert_eq!(env::current_dir().unwrap(), current_dir);
let out = g.read_output(); let out = g.read_output();
let path = super::truncate_home_path(current_dir.to_string_lossy().to_string()); let path = super::truncate_home_path(current_dir.to_string_lossy().to_string());
assert_eq!(out, format!("{path}\n")); assert_eq!(out, format!("{path}\n"));
} }
#[test] #[test]
fn test_popd_empty_stack() { fn test_popd_empty_stack() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("popd").unwrap_err(); test_input("popd").unwrap_err();
assert_ne!(state::get_status(), 0); assert_ne!(state::get_status(), 0);
} }
#[test] #[test]
fn test_pushd_multiple_then_popd() { fn test_pushd_multiple_then_popd() {
let g = TestGuard::new(); let g = TestGuard::new();
let original = env::current_dir().unwrap(); let original = env::current_dir().unwrap();
let tmp1 = TempDir::new().unwrap(); let tmp1 = TempDir::new().unwrap();
let tmp2 = TempDir::new().unwrap(); let tmp2 = TempDir::new().unwrap();
let path1 = tmp1.path().to_path_buf(); let path1 = tmp1.path().to_path_buf();
let path2 = tmp2.path().to_path_buf(); let path2 = tmp2.path().to_path_buf();
test_input(format!("pushd {}", path1.display())).unwrap(); test_input(format!("pushd {}", path1.display())).unwrap();
test_input(format!("pushd {}", path2.display())).unwrap(); test_input(format!("pushd {}", path2.display())).unwrap();
g.read_output(); g.read_output();
assert_eq!(env::current_dir().unwrap(), path2); assert_eq!(env::current_dir().unwrap(), path2);
let stack = read_meta(|m| m.dirs().clone()); let stack = read_meta(|m| m.dirs().clone());
assert_eq!(stack.len(), 2); assert_eq!(stack.len(), 2);
assert_eq!(stack[0], path1); assert_eq!(stack[0], path1);
assert_eq!(stack[1], original); assert_eq!(stack[1], original);
test_input("popd").unwrap(); test_input("popd").unwrap();
assert_eq!(env::current_dir().unwrap(), path1); assert_eq!(env::current_dir().unwrap(), path1);
test_input("popd").unwrap(); test_input("popd").unwrap();
assert_eq!(env::current_dir().unwrap(), original); assert_eq!(env::current_dir().unwrap(), original);
let stack = read_meta(|m| m.dirs().clone()); let stack = read_meta(|m| m.dirs().clone());
assert_eq!(stack.len(), 0); assert_eq!(stack.len(), 0);
} }
#[test] #[test]
fn test_pushd_rotate_plus() { fn test_pushd_rotate_plus() {
let g = TestGuard::new(); let g = TestGuard::new();
let original = env::current_dir().unwrap(); let original = env::current_dir().unwrap();
let tmp1 = TempDir::new().unwrap(); let tmp1 = TempDir::new().unwrap();
let tmp2 = TempDir::new().unwrap(); let tmp2 = TempDir::new().unwrap();
let path1 = tmp1.path().to_path_buf(); let path1 = tmp1.path().to_path_buf();
let path2 = tmp2.path().to_path_buf(); let path2 = tmp2.path().to_path_buf();
// Build stack: cwd=original, then pushd path1, pushd path2 // Build stack: cwd=original, then pushd path1, pushd path2
// Stack after: cwd=path2, [path1, original] // Stack after: cwd=path2, [path1, original]
test_input(format!("pushd {}", path1.display())).unwrap(); test_input(format!("pushd {}", path1.display())).unwrap();
test_input(format!("pushd {}", path2.display())).unwrap(); test_input(format!("pushd {}", path2.display())).unwrap();
g.read_output(); g.read_output();
// pushd +1 rotates: [path2, path1, original] -> rotate_left(1) -> [path1, original, path2] // pushd +1 rotates: [path2, path1, original] -> rotate_left(1) -> [path1, original, path2]
// pop front -> cwd=path1, stack=[original, path2] // pop front -> cwd=path1, stack=[original, path2]
test_input("pushd +1").unwrap(); test_input("pushd +1").unwrap();
assert_eq!(env::current_dir().unwrap(), path1); assert_eq!(env::current_dir().unwrap(), path1);
let stack = read_meta(|m| m.dirs().clone()); let stack = read_meta(|m| m.dirs().clone());
assert_eq!(stack.len(), 2); assert_eq!(stack.len(), 2);
assert_eq!(stack[0], original); assert_eq!(stack[0], original);
assert_eq!(stack[1], path2); assert_eq!(stack[1], path2);
} }
#[test] #[test]
fn test_pushd_no_cd_flag() { fn test_pushd_no_cd_flag() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let original = env::current_dir().unwrap(); let original = env::current_dir().unwrap();
let tmp = TempDir::new().unwrap(); let tmp = TempDir::new().unwrap();
let path = tmp.path().to_path_buf(); let path = tmp.path().to_path_buf();
test_input(format!("pushd -n {}", path.display())).unwrap(); test_input(format!("pushd -n {}", path.display())).unwrap();
// -n means don't cd, but the dir should still be on the stack // -n means don't cd, but the dir should still be on the stack
assert_eq!(env::current_dir().unwrap(), original); assert_eq!(env::current_dir().unwrap(), original);
} }
#[test] #[test]
fn test_dirs_clear() { fn test_dirs_clear() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let tmp = TempDir::new().unwrap(); let tmp = TempDir::new().unwrap();
test_input(format!("pushd {}", tmp.path().display())).unwrap(); test_input(format!("pushd {}", tmp.path().display())).unwrap();
assert_eq!(read_meta(|m| m.dirs().len()), 1); assert_eq!(read_meta(|m| m.dirs().len()), 1);
test_input("dirs -c").unwrap(); test_input("dirs -c").unwrap();
assert_eq!(read_meta(|m| m.dirs().len()), 0); assert_eq!(read_meta(|m| m.dirs().len()), 0);
} }
#[test] #[test]
fn test_dirs_one_per_line() { fn test_dirs_one_per_line() {
let g = TestGuard::new(); let g = TestGuard::new();
let original = env::current_dir().unwrap(); let original = env::current_dir().unwrap();
let tmp = TempDir::new().unwrap(); let tmp = TempDir::new().unwrap();
let path = tmp.path().to_path_buf(); let path = tmp.path().to_path_buf();
test_input(format!("pushd {}", path.display())).unwrap(); test_input(format!("pushd {}", path.display())).unwrap();
g.read_output(); g.read_output();
test_input("dirs -p").unwrap(); test_input("dirs -p").unwrap();
let out = g.read_output(); let out = g.read_output();
let lines: Vec<&str> = out.split('\n').filter(|l| !l.is_empty()).collect(); let lines: Vec<&str> = out.split('\n').filter(|l| !l.is_empty()).collect();
assert_eq!(lines.len(), 2); assert_eq!(lines.len(), 2);
assert_eq!( assert_eq!(lines[0], super::truncate_home_path(path.to_string_lossy().to_string()));
lines[0], assert_eq!(lines[1], super::truncate_home_path(original.to_string_lossy().to_string()));
super::truncate_home_path(path.to_string_lossy().to_string()) }
);
assert_eq!(
lines[1],
super::truncate_home_path(original.to_string_lossy().to_string())
);
}
#[test] #[test]
fn test_popd_indexed_from_top() { fn test_popd_indexed_from_top() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let original = env::current_dir().unwrap(); let original = env::current_dir().unwrap();
let tmp1 = TempDir::new().unwrap(); let tmp1 = TempDir::new().unwrap();
let tmp2 = TempDir::new().unwrap(); let tmp2 = TempDir::new().unwrap();
let path1 = tmp1.path().to_path_buf(); let path1 = tmp1.path().to_path_buf();
let path2 = tmp2.path().to_path_buf(); let path2 = tmp2.path().to_path_buf();
// Stack: cwd=path2, [path1, original] // Stack: cwd=path2, [path1, original]
test_input(format!("pushd {}", path1.display())).unwrap(); test_input(format!("pushd {}", path1.display())).unwrap();
test_input(format!("pushd {}", path2.display())).unwrap(); test_input(format!("pushd {}", path2.display())).unwrap();
// popd +1 removes index (1-1)=0 from stored dirs, i.e. path1 // popd +1 removes index (1-1)=0 from stored dirs, i.e. path1
test_input("popd +1").unwrap(); test_input("popd +1").unwrap();
assert_eq!(env::current_dir().unwrap(), path2); // no cd assert_eq!(env::current_dir().unwrap(), path2); // no cd
let stack = read_meta(|m| m.dirs().clone()); let stack = read_meta(|m| m.dirs().clone());
assert_eq!(stack.len(), 1); assert_eq!(stack.len(), 1);
assert_eq!(stack[0], original); assert_eq!(stack[0], original);
} }
#[test] #[test]
fn test_pushd_nonexistent_dir() { fn test_pushd_nonexistent_dir() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let result = test_input("pushd /nonexistent_dir_12345"); let result = test_input("pushd /nonexistent_dir_12345");
assert!(result.is_err()); assert!(result.is_err());
} }
} }

17
src/builtin/echo.rs
View File

@@ -31,7 +31,7 @@ bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct EchoFlags: u32 { pub struct EchoFlags: u32 {
const NO_NEWLINE = 0b000001; const NO_NEWLINE = 0b000001;
const NO_ESCAPE = 0b000010; const NO_ESCAPE = 0b000010;
const USE_ESCAPE = 0b000100; const USE_ESCAPE = 0b000100;
const USE_PROMPT = 0b001000; const USE_PROMPT = 0b001000;
} }
@@ -55,17 +55,16 @@ pub fn echo(node: Node) -> ShResult<()> {
} }
let output_channel = borrow_fd(STDOUT_FILENO); let output_channel = borrow_fd(STDOUT_FILENO);
let xpg_echo = read_shopts(|o| o.core.xpg_echo); // If true, echo expands escape sequences by default, and -E opts out let xpg_echo = read_shopts(|o| o.core.xpg_echo); // If true, echo expands escape sequences by default, and -E opts out
let use_escape = let use_escape = (xpg_echo && !flags.contains(EchoFlags::NO_ESCAPE)) || flags.contains(EchoFlags::USE_ESCAPE);
(xpg_echo && !flags.contains(EchoFlags::NO_ESCAPE)) || flags.contains(EchoFlags::USE_ESCAPE);
let mut echo_output = prepare_echo_args( let mut echo_output = prepare_echo_args(
argv argv
.into_iter() .into_iter()
.map(|a| a.0) // Extract the String from the tuple of (String,Span) .map(|a| a.0) // Extract the String from the tuple of (String,Span)
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
use_escape, use_escape,
flags.contains(EchoFlags::USE_PROMPT), flags.contains(EchoFlags::USE_PROMPT),
)? )?
.join(" "); .join(" ");
@@ -208,7 +207,7 @@ pub fn get_echo_flags(opts: Vec<Opt>) -> ShResult<EchoFlags> {
Opt::Short('n') => flags |= EchoFlags::NO_NEWLINE, Opt::Short('n') => flags |= EchoFlags::NO_NEWLINE,
Opt::Short('e') => flags |= EchoFlags::USE_ESCAPE, Opt::Short('e') => flags |= EchoFlags::USE_ESCAPE,
Opt::Short('p') => flags |= EchoFlags::USE_PROMPT, Opt::Short('p') => flags |= EchoFlags::USE_PROMPT,
Opt::Short('E') => flags |= EchoFlags::NO_ESCAPE, Opt::Short('E') => flags |= EchoFlags::NO_ESCAPE,
_ => { _ => {
return Err(ShErr::simple( return Err(ShErr::simple(
ShErrKind::ExecFail, ShErrKind::ExecFail,
@@ -309,7 +308,11 @@ mod tests {
#[test] #[test]
fn prepare_multiple_args() { fn prepare_multiple_args() {
let result = prepare_echo_args(vec!["hello".into(), "world".into()], false, false).unwrap(); let result = prepare_echo_args(
vec!["hello".into(), "world".into()],
false,
false,
).unwrap();
assert_eq!(result, vec!["hello", "world"]); assert_eq!(result, vec!["hello", "world"]);
} }

5
src/builtin/eval.rs
View File

@@ -37,7 +37,7 @@ pub fn eval(node: Node) -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::state::{self, VarFlags, VarKind, read_vars, write_vars}; use crate::state::{self, read_vars, write_vars, VarFlags, VarKind};
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
// ===================== Basic ===================== // ===================== Basic =====================
@@ -80,8 +80,7 @@ mod tests {
#[test] #[test]
fn eval_expands_variable() { fn eval_expands_variable() {
let guard = TestGuard::new(); let guard = TestGuard::new();
write_vars(|v| v.set_var("CMD", VarKind::Str("echo evaluated".into()), VarFlags::NONE)) write_vars(|v| v.set_var("CMD", VarKind::Str("echo evaluated".into()), VarFlags::NONE)).unwrap();
.unwrap();
test_input("eval $CMD").unwrap(); test_input("eval $CMD").unwrap();
let out = guard.read_output(); let out = guard.read_output();

6
src/builtin/exec.rs
View File

@@ -50,7 +50,7 @@ pub fn exec_builtin(node: Node) -> ShResult<()> {
mod tests { mod tests {
use crate::state; use crate::state;
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
// Testing exec is a bit tricky since it replaces the current process, so we just test that it correctly handles the case of no arguments and the case of a nonexistent command. We can't really test that it successfully executes a command since that would replace the test process itself. // Testing exec is a bit tricky since it replaces the current process, so we just test that it correctly handles the case of no arguments and the case of a nonexistent command. We can't really test that it successfully executes a command since that would replace the test process itself.
#[test] #[test]
fn exec_no_args_succeeds() { fn exec_no_args_succeeds() {
@@ -62,9 +62,7 @@ mod tests {
#[test] #[test]
fn exec_nonexistent_command_fails() { fn exec_nonexistent_command_fails() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let result = test_input( let result = test_input("exec _____________no_such_______command_xyz_____________hopefully______this_doesnt______exist_____somewhere_in___your______PATH__________________");
"exec _____________no_such_______command_xyz_____________hopefully______this_doesnt______exist_____somewhere_in___your______PATH__________________",
);
assert!(result.is_err()); assert!(result.is_err());
} }
} }

300
src/builtin/help.rs
View File

@@ -1,300 +0,0 @@
use std::{env, io::Write, path::Path};
use ariadne::Span as ASpan;
use nix::libc::STDIN_FILENO;
use crate::{
libsh::{
error::{ShErr, ShErrKind, ShResult},
guards::RawModeGuard,
},
parse::{
NdRule, Node, Redir, RedirType,
execute::{exec_input, prepare_argv},
lex::{QuoteState, Span},
},
procio::{IoFrame, IoMode},
readline::{complete::ScoredCandidate, markers},
state,
};
const TAG_SEQ: &str = "\x1b[1;33m"; // bold yellow — searchable tags
const REF_SEQ: &str = "\x1b[4;36m"; // underline cyan — cross-references
const RESET_SEQ: &str = "\x1b[0m";
const HEADER_SEQ: &str = "\x1b[1;35m"; // bold magenta — section headers
const CODE_SEQ: &str = "\x1b[32m"; // green — inline code
const KEYWORD_2_SEQ: &str = "\x1b[1;32m"; // bold green — {keyword}
const KEYWORD_3_SEQ: &str = "\x1b[3;37m"; // italic white — [optional]
pub fn help(node: Node) -> ShResult<()> {
let NdRule::Command {
assignments: _,
argv,
} = node.class
else {
unreachable!()
};
let mut argv = prepare_argv(argv)?.into_iter().peekable();
let help = argv.next().unwrap(); // drop 'help'
// Join all of the word-split arguments into a single string
// Preserve the span too
let (topic, span) = if argv.peek().is_none() {
("help.txt".to_string(), help.1)
} else {
argv.fold((String::new(), Span::default()), |mut acc, arg| {
if acc.1 == Span::default() {
acc.1 = arg.1.clone();
} else {
let new_end = arg.1.end();
let start = acc.1.start();
acc.1.set_range(start..new_end);
}
if acc.0.is_empty() {
acc.0 = arg.0;
} else {
acc.0 = acc.0 + &format!(" {}", arg.0);
}
acc
})
};
let hpath = env::var("SHED_HPATH").unwrap_or_default();
for path in hpath.split(':') {
let path = Path::new(&path).join(&topic);
if path.is_file() {
let Ok(contents) = std::fs::read_to_string(&path) else {
continue;
};
let filename = path.file_stem().unwrap().to_string_lossy().to_string();
let unescaped = unescape_help(&contents);
let expanded = expand_help(&unescaped);
open_help(&expanded, None, Some(filename))?;
state::set_status(0);
return Ok(());
}
}
// didn't find an exact filename match, its probably a tag search
for path in hpath.split(':') {
let path = Path::new(path);
if let Ok(entries) = path.read_dir() {
for entry in entries {
let Ok(entry) = entry else { continue };
let path = entry.path();
let filename = path.file_stem().unwrap().to_string_lossy().to_string();
if !path.is_file() {
continue;
}
let Ok(contents) = std::fs::read_to_string(&path) else {
continue;
};
let unescaped = unescape_help(&contents);
let expanded = expand_help(&unescaped);
let tags = read_tags(&expanded);
for (tag, line) in &tags {}
if let Some((matched_tag, line)) = get_best_match(&topic, &tags) {
open_help(&expanded, Some(line), Some(filename))?;
state::set_status(0);
return Ok(());
} else {
}
}
}
}
state::set_status(1);
Err(ShErr::at(
ShErrKind::NotFound,
span,
"No relevant help page found for this topic",
))
}
pub fn open_help(content: &str, line: Option<usize>, file_name: Option<String>) -> ShResult<()> {
let pager = env::var("SHED_HPAGER").unwrap_or(env::var("PAGER").unwrap_or("less -R".into()));
let line_arg = line.map(|ln| format!("+{ln}")).unwrap_or_default();
let prompt_arg = file_name
.map(|name| format!("-Ps'{name}'"))
.unwrap_or_default();
let mut tmp = tempfile::NamedTempFile::new()?;
let tmp_path = tmp.path().to_string_lossy().to_string();
tmp.write_all(content.as_bytes())?;
tmp.flush()?;
RawModeGuard::with_cooked_mode(|| {
exec_input(
format!("{pager} {line_arg} {prompt_arg} {tmp_path}"),
None,
true,
Some("help".into()),
)
})
}
pub fn get_best_match(topic: &str, tags: &[(String, usize)]) -> Option<(String, usize)> {
let mut candidates: Vec<_> = tags
.iter()
.map(|(tag, line)| (ScoredCandidate::new(tag.to_string()), *line))
.collect();
for (cand, _) in candidates.iter_mut() {
cand.fuzzy_score(topic);
}
candidates.retain(|(c, _)| c.score.unwrap_or(i32::MIN) > i32::MIN);
candidates.sort_by_key(|(c, _)| c.score.unwrap_or(i32::MIN));
candidates
.first()
.map(|(c, line)| (c.content.clone(), *line))
}
pub fn read_tags(raw: &str) -> Vec<(String, usize)> {
let mut tags = vec![];
for (line_num, line) in raw.lines().enumerate() {
let mut rest = line;
while let Some(pos) = rest.find(TAG_SEQ) {
let after_seq = &rest[pos + TAG_SEQ.len()..];
if let Some(end) = after_seq.find(RESET_SEQ) {
let tag = &after_seq[..end];
tags.push((tag.to_string(), line_num + 1));
rest = &after_seq[end + RESET_SEQ.len()..];
} else {
break;
}
}
}
tags
}
pub fn expand_help(raw: &str) -> String {
let mut result = String::new();
let mut chars = raw.chars();
while let Some(ch) = chars.next() {
match ch {
markers::RESET => result.push_str(RESET_SEQ),
markers::TAG => result.push_str(TAG_SEQ),
markers::REFERENCE => result.push_str(REF_SEQ),
markers::HEADER => result.push_str(HEADER_SEQ),
markers::CODE => result.push_str(CODE_SEQ),
markers::KEYWORD_2 => result.push_str(KEYWORD_2_SEQ),
markers::KEYWORD_3 => result.push_str(KEYWORD_3_SEQ),
_ => result.push(ch),
}
}
result
}
pub fn unescape_help(raw: &str) -> String {
let mut result = String::new();
let mut chars = raw.chars().peekable();
let mut qt_state = QuoteState::default();
while let Some(ch) = chars.next() {
match ch {
'\\' => {
if let Some(next_ch) = chars.next() {
result.push(next_ch);
}
}
'\n' => {
result.push(ch);
qt_state = QuoteState::default();
}
'"' => {
result.push(ch);
qt_state.toggle_double();
}
'\'' => {
result.push(ch);
qt_state.toggle_single();
}
_ if qt_state.in_quote() || chars.peek().is_none_or(|ch| ch.is_whitespace()) => {
result.push(ch);
}
'*' => {
result.push(markers::TAG);
while let Some(next_ch) = chars.next() {
if next_ch == '*' {
result.push(markers::RESET);
break;
} else {
result.push(next_ch);
}
}
}
'|' => {
result.push(markers::REFERENCE);
while let Some(next_ch) = chars.next() {
if next_ch == '|' {
result.push(markers::RESET);
break;
} else {
result.push(next_ch);
}
}
}
'#' => {
result.push(markers::HEADER);
while let Some(next_ch) = chars.next() {
if next_ch == '#' {
result.push(markers::RESET);
break;
} else {
result.push(next_ch);
}
}
}
'`' => {
result.push(markers::CODE);
while let Some(next_ch) = chars.next() {
if next_ch == '`' {
result.push(markers::RESET);
break;
} else {
result.push(next_ch);
}
}
}
'{' => {
result.push(markers::KEYWORD_2);
while let Some(next_ch) = chars.next() {
if next_ch == '}' {
result.push(markers::RESET);
break;
} else {
result.push(next_ch);
}
}
}
'[' => {
result.push(markers::KEYWORD_3);
while let Some(next_ch) = chars.next() {
if next_ch == ']' {
result.push(markers::RESET);
break;
} else {
result.push(next_ch);
}
}
}
_ => result.push(ch),
}
}
result
}

2
src/builtin/intro.rs
View File

@@ -185,7 +185,7 @@ mod tests {
let out = guard.read_output(); let out = guard.read_output();
assert!(out.contains("cat")); assert!(out.contains("cat"));
assert!(out.contains("is")); assert!(out.contains("is"));
assert!(out.contains("/")); // Should show a path assert!(out.contains("/")); // Should show a path
} }
// ===================== Not found ===================== // ===================== Not found =====================

33
src/builtin/keymap.rs
View File

@@ -81,10 +81,10 @@ impl KeyMapOpts {
opt: Opt::Short('o'), // operator-pending mode opt: Opt::Short('o'), // operator-pending mode
takes_arg: false, takes_arg: false,
}, },
OptSpec { OptSpec {
opt: Opt::Long("remove".into()), opt: Opt::Long("remove".into()),
takes_arg: true, takes_arg: true,
}, },
OptSpec { OptSpec {
opt: Opt::Short('r'), // replace mode opt: Opt::Short('r'), // replace mode
takes_arg: false, takes_arg: false,
@@ -180,8 +180,8 @@ pub fn keymap(node: Node) -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::expand::expand_keymap;
use crate::getopt::Opt; use crate::getopt::Opt;
use crate::expand::expand_keymap;
use crate::state::{self, read_logic}; use crate::state::{self, read_logic};
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
@@ -217,8 +217,7 @@ mod tests {
let opts = KeyMapOpts::from_opts(&[ let opts = KeyMapOpts::from_opts(&[
Opt::Short('n'), Opt::Short('n'),
Opt::LongWithArg("remove".into(), "jk".into()), Opt::LongWithArg("remove".into(), "jk".into()),
]) ]).unwrap();
.unwrap();
assert_eq!(opts.remove, Some("jk".into())); assert_eq!(opts.remove, Some("jk".into()));
} }
@@ -274,7 +273,10 @@ mod tests {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("keymap -n jk '<ESC>'").unwrap(); test_input("keymap -n jk '<ESC>'").unwrap();
let maps = read_logic(|l| l.keymaps_filtered(KeyMapFlags::NORMAL, &expand_keymap("jk"))); let maps = read_logic(|l| l.keymaps_filtered(
KeyMapFlags::NORMAL,
&expand_keymap("jk"),
));
assert!(!maps.is_empty()); assert!(!maps.is_empty());
} }
@@ -283,7 +285,10 @@ mod tests {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("keymap -i jk '<ESC>'").unwrap(); test_input("keymap -i jk '<ESC>'").unwrap();
let maps = read_logic(|l| l.keymaps_filtered(KeyMapFlags::INSERT, &expand_keymap("jk"))); let maps = read_logic(|l| l.keymaps_filtered(
KeyMapFlags::INSERT,
&expand_keymap("jk"),
));
assert!(!maps.is_empty()); assert!(!maps.is_empty());
} }
@@ -293,7 +298,10 @@ mod tests {
test_input("keymap -n jk '<ESC>'").unwrap(); test_input("keymap -n jk '<ESC>'").unwrap();
test_input("keymap -n jk 'dd'").unwrap(); test_input("keymap -n jk 'dd'").unwrap();
let maps = read_logic(|l| l.keymaps_filtered(KeyMapFlags::NORMAL, &expand_keymap("jk"))); let maps = read_logic(|l| l.keymaps_filtered(
KeyMapFlags::NORMAL,
&expand_keymap("jk"),
));
assert_eq!(maps.len(), 1); assert_eq!(maps.len(), 1);
assert_eq!(maps[0].action, "dd"); assert_eq!(maps[0].action, "dd");
} }
@@ -304,7 +312,10 @@ mod tests {
test_input("keymap -n jk '<ESC>'").unwrap(); test_input("keymap -n jk '<ESC>'").unwrap();
test_input("keymap -n --remove jk").unwrap(); test_input("keymap -n --remove jk").unwrap();
let maps = read_logic(|l| l.keymaps_filtered(KeyMapFlags::NORMAL, &expand_keymap("jk"))); let maps = read_logic(|l| l.keymaps_filtered(
KeyMapFlags::NORMAL,
&expand_keymap("jk"),
));
assert!(maps.is_empty()); assert!(maps.is_empty());
} }

7
src/builtin/map.rs
View File

@@ -389,7 +389,7 @@ pub fn get_map_opts(opts: Vec<Opt>) -> MapOpts {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{MapFlags, MapNode, get_map_opts}; use super::{MapNode, MapFlags, get_map_opts};
use crate::getopt::Opt; use crate::getopt::Opt;
use crate::state::{self, read_vars}; use crate::state::{self, read_vars};
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
@@ -433,7 +433,10 @@ mod tests {
#[test] #[test]
fn mapnode_remove_nested() { fn mapnode_remove_nested() {
let mut root = MapNode::default(); let mut root = MapNode::default();
root.set(&["a".into(), "b".into()], MapNode::StaticLeaf("val".into())); root.set(
&["a".into(), "b".into()],
MapNode::StaticLeaf("val".into()),
);
root.remove(&["a".into(), "b".into()]); root.remove(&["a".into(), "b".into()]);
assert!(root.get(&["a".into(), "b".into()]).is_none()); assert!(root.get(&["a".into(), "b".into()]).is_none());
// Parent branch should still exist // Parent branch should still exist

55
src/builtin/mod.rs
View File

@@ -11,28 +11,26 @@ pub mod eval;
pub mod exec; pub mod exec;
pub mod flowctl; pub mod flowctl;
pub mod getopts; pub mod getopts;
pub mod help;
pub mod intro; pub mod intro;
pub mod jobctl; pub mod jobctl;
pub mod keymap; pub mod keymap;
pub mod map; pub mod map;
pub mod pwd; pub mod pwd;
pub mod read; pub mod read;
pub mod resource;
pub mod seek;
pub mod shift; pub mod shift;
pub mod shopt; pub mod shopt;
pub mod source; pub mod source;
pub mod test; // [[ ]] thing pub mod test; // [[ ]] thing
pub mod trap; pub mod trap;
pub mod varcmds; pub mod varcmds;
pub mod resource;
pub const BUILTINS: [&str; 51] = [ pub const BUILTINS: [&str; 49] = [
"echo", "cd", "read", "export", "local", "pwd", "source", ".", "shift", "jobs", "fg", "bg", "echo", "cd", "read", "export", "local", "pwd", "source", ".", "shift", "jobs", "fg", "bg", "disown",
"disown", "alias", "unalias", "return", "break", "continue", "exit", "shopt", "builtin", "alias", "unalias", "return", "break", "continue", "exit", "shopt", "builtin",
"command", "trap", "pushd", "popd", "dirs", "exec", "eval", "true", "false", ":", "readonly", "command", "trap", "pushd", "popd", "dirs", "exec", "eval", "true", "false", ":", "readonly",
"unset", "complete", "compgen", "map", "pop", "fpop", "push", "fpush", "rotate", "wait", "type", "unset", "complete", "compgen", "map", "pop", "fpop", "push", "fpush", "rotate", "wait", "type",
"getopts", "keymap", "read_key", "autocmd", "ulimit", "umask", "seek", "help", "getopts", "keymap", "read_key", "autocmd", "ulimit", "umask"
]; ];
pub fn true_builtin() -> ShResult<()> { pub fn true_builtin() -> ShResult<()> {
@@ -52,34 +50,31 @@ pub fn noop_builtin() -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
pub mod tests { pub mod tests {
use crate::{ use crate::{state, testutil::{TestGuard, test_input}};
state,
testutil::{TestGuard, test_input},
};
// You can never be too sure!!!!!! // You can never be too sure!!!!!!
#[test] #[test]
fn test_true() { fn test_true() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("true").unwrap(); test_input("true").unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
#[test] #[test]
fn test_false() { fn test_false() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("false").unwrap(); test_input("false").unwrap();
assert_eq!(state::get_status(), 1); assert_eq!(state::get_status(), 1);
} }
#[test] #[test]
fn test_noop() { fn test_noop() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input(":").unwrap(); test_input(":").unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
} }

4
src/builtin/pwd.rs
View File

@@ -27,10 +27,10 @@ pub fn pwd(node: Node) -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::state;
use crate::testutil::{TestGuard, test_input};
use std::env; use std::env;
use tempfile::TempDir; use tempfile::TempDir;
use crate::state;
use crate::testutil::{TestGuard, test_input};
#[test] #[test]
fn pwd_prints_cwd() { fn pwd_prints_cwd() {

2
src/builtin/read.rs
View File

@@ -367,7 +367,7 @@ pub fn get_read_key_opts(opts: Vec<Opt>) -> ShResult<ReadKeyOpts> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::state::{self, VarFlags, VarKind, read_vars, write_vars}; use crate::state::{self, read_vars, write_vars, VarFlags, VarKind};
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
// ===================== Basic read into REPLY ===================== // ===================== Basic read into REPLY =====================

712
src/builtin/resource.rs
View File

@@ -1,115 +1,92 @@
use ariadne::Fmt; use ariadne::Fmt;
use nix::{ use nix::{libc::STDOUT_FILENO, sys::{resource::{Resource, getrlimit, setrlimit}, stat::{Mode, umask}}, unistd::write};
libc::STDOUT_FILENO,
sys::{
resource::{Resource, getrlimit, setrlimit},
stat::{Mode, umask},
},
unistd::write,
};
use crate::{ use crate::{
getopt::{Opt, OptSpec, get_opts_from_tokens_strict}, getopt::{Opt, OptSpec, get_opts_from_tokens_strict}, libsh::error::{ShErr, ShErrKind, ShResult, ShResultExt, next_color}, parse::{NdRule, Node}, procio::borrow_fd, state::{self}
libsh::error::{ShErr, ShErrKind, ShResult, ShResultExt, next_color},
parse::{NdRule, Node},
procio::borrow_fd,
state::{self},
}; };
fn ulimit_opt_spec() -> [OptSpec; 5] { fn ulimit_opt_spec() -> [OptSpec;5] {
[ [
OptSpec { OptSpec {
opt: Opt::Short('n'), // file descriptors opt: Opt::Short('n'), // file descriptors
takes_arg: true, takes_arg: true,
}, },
OptSpec { OptSpec {
opt: Opt::Short('u'), // max user processes opt: Opt::Short('u'), // max user processes
takes_arg: true, takes_arg: true,
}, },
OptSpec { OptSpec {
opt: Opt::Short('s'), // stack size opt: Opt::Short('s'), // stack size
takes_arg: true, takes_arg: true,
}, },
OptSpec { OptSpec {
opt: Opt::Short('c'), // core dump file size opt: Opt::Short('c'), // core dump file size
takes_arg: true, takes_arg: true,
}, },
OptSpec { OptSpec {
opt: Opt::Short('v'), // virtual memory opt: Opt::Short('v'), // virtual memory
takes_arg: true, takes_arg: true,
}, }
] ]
} }
struct UlimitOpts { struct UlimitOpts {
fds: Option<u64>, fds: Option<u64>,
procs: Option<u64>, procs: Option<u64>,
stack: Option<u64>, stack: Option<u64>,
core: Option<u64>, core: Option<u64>,
vmem: Option<u64>, vmem: Option<u64>,
} }
fn get_ulimit_opts(opt: &[Opt]) -> ShResult<UlimitOpts> { fn get_ulimit_opts(opt: &[Opt]) -> ShResult<UlimitOpts> {
let mut opts = UlimitOpts { let mut opts = UlimitOpts {
fds: None, fds: None,
procs: None, procs: None,
stack: None, stack: None,
core: None, core: None,
vmem: None, vmem: None,
}; };
for o in opt { for o in opt {
match o { match o {
Opt::ShortWithArg('n', arg) => { Opt::ShortWithArg('n', arg) => {
opts.fds = Some(arg.parse().map_err(|_| { opts.fds = Some(arg.parse().map_err(|_| ShErr::simple(
ShErr::simple( ShErrKind::ParseErr,
ShErrKind::ParseErr, format!("invalid argument for -n: {}", arg.fg(next_color())),
format!("invalid argument for -n: {}", arg.fg(next_color())), ))?);
) },
})?); Opt::ShortWithArg('u', arg) => {
} opts.procs = Some(arg.parse().map_err(|_| ShErr::simple(
Opt::ShortWithArg('u', arg) => { ShErrKind::ParseErr,
opts.procs = Some(arg.parse().map_err(|_| { format!("invalid argument for -u: {}", arg.fg(next_color())),
ShErr::simple( ))?);
ShErrKind::ParseErr, },
format!("invalid argument for -u: {}", arg.fg(next_color())), Opt::ShortWithArg('s', arg) => {
) opts.stack = Some(arg.parse().map_err(|_| ShErr::simple(
})?); ShErrKind::ParseErr,
} format!("invalid argument for -s: {}", arg.fg(next_color())),
Opt::ShortWithArg('s', arg) => { ))?);
opts.stack = Some(arg.parse().map_err(|_| { },
ShErr::simple( Opt::ShortWithArg('c', arg) => {
ShErrKind::ParseErr, opts.core = Some(arg.parse().map_err(|_| ShErr::simple(
format!("invalid argument for -s: {}", arg.fg(next_color())), ShErrKind::ParseErr,
) format!("invalid argument for -c: {}", arg.fg(next_color())),
})?); ))?);
} },
Opt::ShortWithArg('c', arg) => { Opt::ShortWithArg('v', arg) => {
opts.core = Some(arg.parse().map_err(|_| { opts.vmem = Some(arg.parse().map_err(|_| ShErr::simple(
ShErr::simple( ShErrKind::ParseErr,
ShErrKind::ParseErr, format!("invalid argument for -v: {}", arg.fg(next_color())),
format!("invalid argument for -c: {}", arg.fg(next_color())), ))?);
) },
})?); o => return Err(ShErr::simple(
} ShErrKind::ParseErr,
Opt::ShortWithArg('v', arg) => { format!("invalid option: {}", o.fg(next_color())),
opts.vmem = Some(arg.parse().map_err(|_| { )),
ShErr::simple( }
ShErrKind::ParseErr, }
format!("invalid argument for -v: {}", arg.fg(next_color())),
)
})?);
}
o => {
return Err(ShErr::simple(
ShErrKind::ParseErr,
format!("invalid option: {}", o.fg(next_color())),
));
}
}
}
Ok(opts) Ok(opts)
} }
pub fn ulimit(node: Node) -> ShResult<()> { pub fn ulimit(node: Node) -> ShResult<()> {
@@ -122,308 +99,282 @@ pub fn ulimit(node: Node) -> ShResult<()> {
unreachable!() unreachable!()
}; };
let (_, opts) = let (_, opts) = get_opts_from_tokens_strict(argv, &ulimit_opt_spec()).promote_err(span.clone())?;
get_opts_from_tokens_strict(argv, &ulimit_opt_spec()).promote_err(span.clone())?; let ulimit_opts = get_ulimit_opts(&opts).promote_err(span.clone())?;
let ulimit_opts = get_ulimit_opts(&opts).promote_err(span.clone())?;
if let Some(fds) = ulimit_opts.fds { if let Some(fds) = ulimit_opts.fds {
let (_, hard) = getrlimit(Resource::RLIMIT_NOFILE).map_err(|e| { let (_, hard) = getrlimit(Resource::RLIMIT_NOFILE).map_err(|e| ShErr::at(
ShErr::at( ShErrKind::ExecFail,
ShErrKind::ExecFail, span.clone(),
span.clone(), format!("failed to get file descriptor limit: {}", e),
format!("failed to get file descriptor limit: {}", e), ))?;
) setrlimit(Resource::RLIMIT_NOFILE, fds, hard).map_err(|e| ShErr::at(
})?; ShErrKind::ExecFail,
setrlimit(Resource::RLIMIT_NOFILE, fds, hard).map_err(|e| { span.clone(),
ShErr::at( format!("failed to set file descriptor limit: {}", e),
ShErrKind::ExecFail, ))?;
span.clone(), }
format!("failed to set file descriptor limit: {}", e), if let Some(procs) = ulimit_opts.procs {
) let (_, hard) = getrlimit(Resource::RLIMIT_NPROC).map_err(|e| ShErr::at(
})?; ShErrKind::ExecFail,
} span.clone(),
if let Some(procs) = ulimit_opts.procs { format!("failed to get process limit: {}", e),
let (_, hard) = getrlimit(Resource::RLIMIT_NPROC).map_err(|e| { ))?;
ShErr::at( setrlimit(Resource::RLIMIT_NPROC, procs, hard).map_err(|e| ShErr::at(
ShErrKind::ExecFail, ShErrKind::ExecFail,
span.clone(), span.clone(),
format!("failed to get process limit: {}", e), format!("failed to set process limit: {}", e),
) ))?;
})?; }
setrlimit(Resource::RLIMIT_NPROC, procs, hard).map_err(|e| { if let Some(stack) = ulimit_opts.stack {
ShErr::at( let (_, hard) = getrlimit(Resource::RLIMIT_STACK).map_err(|e| ShErr::at(
ShErrKind::ExecFail, ShErrKind::ExecFail,
span.clone(), span.clone(),
format!("failed to set process limit: {}", e), format!("failed to get stack size limit: {}", e),
) ))?;
})?; setrlimit(Resource::RLIMIT_STACK, stack, hard).map_err(|e| ShErr::at(
} ShErrKind::ExecFail,
if let Some(stack) = ulimit_opts.stack { span.clone(),
let (_, hard) = getrlimit(Resource::RLIMIT_STACK).map_err(|e| { format!("failed to set stack size limit: {}", e),
ShErr::at( ))?;
ShErrKind::ExecFail, }
span.clone(), if let Some(core) = ulimit_opts.core {
format!("failed to get stack size limit: {}", e), let (_, hard) = getrlimit(Resource::RLIMIT_CORE).map_err(|e| ShErr::at(
) ShErrKind::ExecFail,
})?; span.clone(),
setrlimit(Resource::RLIMIT_STACK, stack, hard).map_err(|e| { format!("failed to get core dump size limit: {}", e),
ShErr::at( ))?;
ShErrKind::ExecFail, setrlimit(Resource::RLIMIT_CORE, core, hard).map_err(|e| ShErr::at(
span.clone(), ShErrKind::ExecFail,
format!("failed to set stack size limit: {}", e), span.clone(),
) format!("failed to set core dump size limit: {}", e),
})?; ))?;
} }
if let Some(core) = ulimit_opts.core { if let Some(vmem) = ulimit_opts.vmem {
let (_, hard) = getrlimit(Resource::RLIMIT_CORE).map_err(|e| { let (_, hard) = getrlimit(Resource::RLIMIT_AS).map_err(|e| ShErr::at(
ShErr::at( ShErrKind::ExecFail,
ShErrKind::ExecFail, span.clone(),
span.clone(), format!("failed to get virtual memory limit: {}", e),
format!("failed to get core dump size limit: {}", e), ))?;
) setrlimit(Resource::RLIMIT_AS, vmem, hard).map_err(|e| ShErr::at(
})?; ShErrKind::ExecFail,
setrlimit(Resource::RLIMIT_CORE, core, hard).map_err(|e| { span.clone(),
ShErr::at( format!("failed to set virtual memory limit: {}", e),
ShErrKind::ExecFail, ))?;
span.clone(), }
format!("failed to set core dump size limit: {}", e),
)
})?;
}
if let Some(vmem) = ulimit_opts.vmem {
let (_, hard) = getrlimit(Resource::RLIMIT_AS).map_err(|e| {
ShErr::at(
ShErrKind::ExecFail,
span.clone(),
format!("failed to get virtual memory limit: {}", e),
)
})?;
setrlimit(Resource::RLIMIT_AS, vmem, hard).map_err(|e| {
ShErr::at(
ShErrKind::ExecFail,
span.clone(),
format!("failed to set virtual memory limit: {}", e),
)
})?;
}
state::set_status(0); state::set_status(0);
Ok(()) Ok(())
} }
pub fn umask_builtin(node: Node) -> ShResult<()> { pub fn umask_builtin(node: Node) -> ShResult<()> {
let span = node.get_span(); let span = node.get_span();
let NdRule::Command { let NdRule::Command {
assignments: _, assignments: _,
argv, argv,
} = node.class } = node.class else { unreachable!() };
else {
unreachable!()
};
let (argv, opts) = get_opts_from_tokens_strict( let (argv, opts) = get_opts_from_tokens_strict(
argv, argv,
&[OptSpec { &[OptSpec { opt: Opt::Short('S'), takes_arg: false }],
opt: Opt::Short('S'), )?;
takes_arg: false, let argv = &argv[1..]; // skip command name
}],
)?;
let argv = &argv[1..]; // skip command name
let old = umask(Mode::empty()); let old = umask(Mode::empty());
umask(old); umask(old);
let mut old_bits = old.bits(); let mut old_bits = old.bits();
if !argv.is_empty() { if !argv.is_empty() {
if argv.len() > 1 { if argv.len() > 1 {
return Err(ShErr::at( return Err(ShErr::at(
ShErrKind::ParseErr, ShErrKind::ParseErr,
span.clone(), span.clone(),
format!("umask takes at most one argument, got {}", argv.len()), format!("umask takes at most one argument, got {}", argv.len()),
)); ));
} }
let arg = argv[0].clone(); let arg = argv[0].clone();
let raw = arg.as_str(); let raw = arg.as_str();
if raw.chars().any(|c| c.is_ascii_digit()) { if raw.chars().any(|c| c.is_ascii_digit()) {
let mode_raw = u32::from_str_radix(raw, 8).map_err(|_| { let mode_raw = u32::from_str_radix(raw, 8).map_err(|_| ShErr::at(
ShErr::at( ShErrKind::ParseErr,
ShErrKind::ParseErr, span.clone(),
span.clone(), format!("invalid numeric umask: {}", raw.fg(next_color())),
format!("invalid numeric umask: {}", raw.fg(next_color())), ))?;
)
})?;
let mode = Mode::from_bits(mode_raw).ok_or_else(|| { let mode = Mode::from_bits(mode_raw).ok_or_else(|| ShErr::at(
ShErr::at( ShErrKind::ParseErr,
ShErrKind::ParseErr, span.clone(),
span.clone(), format!("invalid umask value: {}", raw.fg(next_color())),
format!("invalid umask value: {}", raw.fg(next_color())), ))?;
)
})?;
umask(mode); umask(mode);
} else { } else {
let parts = raw.split(','); let parts = raw.split(',');
for part in parts { for part in parts {
if let Some((who, bits)) = part.split_once('=') { if let Some((who,bits)) = part.split_once('=') {
let mut new_bits = 0; let mut new_bits = 0;
if bits.contains('r') { if bits.contains('r') {
new_bits |= 4; new_bits |= 4;
} }
if bits.contains('w') { if bits.contains('w') {
new_bits |= 2; new_bits |= 2;
} }
if bits.contains('x') { if bits.contains('x') {
new_bits |= 1; new_bits |= 1;
} }
for ch in who.chars() { for ch in who.chars() {
match ch { match ch {
'o' => { 'o' => {
old_bits &= !0o7; old_bits &= !0o7;
old_bits |= !new_bits & 0o7; old_bits |= !new_bits & 0o7;
} }
'g' => { 'g' => {
old_bits &= !(0o7 << 3); old_bits &= !(0o7 << 3);
old_bits |= (!new_bits & 0o7) << 3; old_bits |= (!new_bits & 0o7) << 3;
} }
'u' => { 'u' => {
old_bits &= !(0o7 << 6); old_bits &= !(0o7 << 6);
old_bits |= (!new_bits & 0o7) << 6; old_bits |= (!new_bits & 0o7) << 6;
} }
'a' => { 'a' => {
let denied = !new_bits & 0o7; let denied = !new_bits & 0o7;
old_bits = denied | (denied << 3) | (denied << 6); old_bits = denied | (denied << 3) | (denied << 6);
} }
_ => { _ => {
return Err(ShErr::at( return Err(ShErr::at(
ShErrKind::ParseErr, ShErrKind::ParseErr,
span.clone(), span.clone(),
format!("invalid umask 'who' character: {}", ch.fg(next_color())), format!("invalid umask 'who' character: {}", ch.fg(next_color())),
)); ));
} }
} }
} }
umask(Mode::from_bits_truncate(old_bits)); umask(Mode::from_bits_truncate(old_bits));
} else if let Some((who, bits)) = part.split_once('+') { } else if let Some((who,bits)) = part.split_once('+') {
let mut new_bits = 0; let mut new_bits = 0;
if bits.contains('r') { if bits.contains('r') {
new_bits |= 4; new_bits |= 4;
} }
if bits.contains('w') { if bits.contains('w') {
new_bits |= 2; new_bits |= 2;
} }
if bits.contains('x') { if bits.contains('x') {
new_bits |= 1; new_bits |= 1;
} }
for ch in who.chars() { for ch in who.chars() {
match ch { match ch {
'o' => { 'o' => {
old_bits &= !(new_bits & 0o7); old_bits &= !(new_bits & 0o7);
} }
'g' => { 'g' => {
old_bits &= !((new_bits & 0o7) << 3); old_bits &= !((new_bits & 0o7) << 3);
} }
'u' => { 'u' => {
old_bits &= !((new_bits & 0o7) << 6); old_bits &= !((new_bits & 0o7) << 6);
} }
'a' => { 'a' => {
let mask = new_bits & 0o7; let mask = new_bits & 0o7;
old_bits &= !(mask | (mask << 3) | (mask << 6)); old_bits &= !(mask | (mask << 3) | (mask << 6));
} }
_ => { _ => {
return Err(ShErr::at( return Err(ShErr::at(
ShErrKind::ParseErr, ShErrKind::ParseErr,
span.clone(), span.clone(),
format!("invalid umask 'who' character: {}", ch.fg(next_color())), format!("invalid umask 'who' character: {}", ch.fg(next_color())),
)); ));
} }
} }
} }
umask(Mode::from_bits_truncate(old_bits)); umask(Mode::from_bits_truncate(old_bits));
} else if let Some((who, bits)) = part.split_once('-') { } else if let Some((who,bits)) = part.split_once('-') {
let mut new_bits = 0; let mut new_bits = 0;
if bits.contains('r') { if bits.contains('r') {
new_bits |= 4; new_bits |= 4;
} }
if bits.contains('w') { if bits.contains('w') {
new_bits |= 2; new_bits |= 2;
} }
if bits.contains('x') { if bits.contains('x') {
new_bits |= 1; new_bits |= 1;
} }
for ch in who.chars() { for ch in who.chars() {
match ch { match ch {
'o' => { 'o' => {
old_bits |= new_bits & 0o7; old_bits |= new_bits & 0o7;
} }
'g' => { 'g' => {
old_bits |= (new_bits << 3) & (0o7 << 3); old_bits |= (new_bits << 3) & (0o7 << 3);
} }
'u' => { 'u' => {
old_bits |= (new_bits << 6) & (0o7 << 6); old_bits |= (new_bits << 6) & (0o7 << 6);
} }
'a' => { 'a' => {
old_bits |= (new_bits | (new_bits << 3) | (new_bits << 6)) & 0o777; old_bits |= (new_bits | (new_bits << 3) | (new_bits << 6)) & 0o777;
} }
_ => { _ => {
return Err(ShErr::at( return Err(ShErr::at(
ShErrKind::ParseErr, ShErrKind::ParseErr,
span.clone(), span.clone(),
format!("invalid umask 'who' character: {}", ch.fg(next_color())), format!("invalid umask 'who' character: {}", ch.fg(next_color())),
)); ));
} }
} }
} }
umask(Mode::from_bits_truncate(old_bits)); umask(Mode::from_bits_truncate(old_bits));
} else { } else {
return Err(ShErr::at( return Err(ShErr::at(
ShErrKind::ParseErr, ShErrKind::ParseErr,
span.clone(), span.clone(),
format!("invalid symbolic umask part: {}", part.fg(next_color())), format!("invalid symbolic umask part: {}", part.fg(next_color())),
)); ));
} }
} }
} }
} else if !opts.is_empty() {
let u = (old_bits >> 6) & 0o7;
let g = (old_bits >> 3) & 0o7;
let o = old_bits & 0o7;
let mut u_str = String::from("u=");
let mut g_str = String::from("g=");
let mut o_str = String::from("o=");
let stuff = [(u, &mut u_str), (g, &mut g_str), (o, &mut o_str)];
for (bits, out) in stuff.into_iter() {
if bits & 4 == 0 {
out.push('r');
}
if bits & 2 == 0 {
out.push('w');
}
if bits & 1 == 0 {
out.push('x');
}
}
let msg = [u_str, g_str, o_str].join(","); } else if !opts.is_empty() {
let stdout = borrow_fd(STDOUT_FILENO); let u = (old_bits >> 6) & 0o7;
write(stdout, msg.as_bytes())?; let g = (old_bits >> 3) & 0o7;
write(stdout, b"\n")?; let o = old_bits & 0o7;
} else { let mut u_str = String::from("u=");
let raw = format!("{:04o}\n", old_bits); let mut g_str = String::from("g=");
let mut o_str = String::from("o=");
let stuff = [
(u, &mut u_str),
(g, &mut g_str),
(o, &mut o_str),
];
for (bits, out) in stuff.into_iter() {
if bits & 4 == 0 {
out.push('r');
}
if bits & 2 == 0 {
out.push('w');
}
if bits & 1 == 0 {
out.push('x');
}
}
let stdout = borrow_fd(STDOUT_FILENO); let msg = [u_str,g_str,o_str].join(",");
write(stdout, raw.as_bytes())?; let stdout = borrow_fd(STDOUT_FILENO);
} write(stdout, msg.as_bytes())?;
write(stdout, b"\n")?;
} else {
let raw = format!("{:04o}\n", old_bits);
state::set_status(0); let stdout = borrow_fd(STDOUT_FILENO);
Ok(()) write(stdout, raw.as_bytes())?;
}
state::set_status(0);
Ok(())
} }
#[cfg(test)] #[cfg(test)]
@@ -472,8 +423,7 @@ mod tests {
let opts = get_ulimit_opts(&[ let opts = get_ulimit_opts(&[
Opt::ShortWithArg('n', "256".into()), Opt::ShortWithArg('n', "256".into()),
Opt::ShortWithArg('c', "0".into()), Opt::ShortWithArg('c', "0".into()),
]) ]).unwrap();
.unwrap();
assert_eq!(opts.fds, Some(256)); assert_eq!(opts.fds, Some(256));
assert_eq!(opts.core, Some(0)); assert_eq!(opts.core, Some(0));
assert!(opts.procs.is_none()); assert!(opts.procs.is_none());

263
src/builtin/seek.rs
View File

@@ -1,263 +0,0 @@
use nix::{
libc::STDOUT_FILENO,
unistd::{Whence, lseek, write},
};
use crate::{
getopt::{Opt, OptSpec, get_opts_from_tokens},
libsh::error::{ShErr, ShErrKind, ShResult},
parse::{NdRule, Node, execute::prepare_argv},
procio::borrow_fd,
state,
};
pub const LSEEK_OPTS: [OptSpec; 2] = [
OptSpec {
opt: Opt::Short('c'),
takes_arg: false,
},
OptSpec {
opt: Opt::Short('e'),
takes_arg: false,
},
];
pub struct LseekOpts {
cursor_rel: bool,
end_rel: bool,
}
pub fn seek(node: Node) -> ShResult<()> {
let NdRule::Command {
assignments: _,
argv,
} = node.class
else {
unreachable!()
};
let (argv, opts) = get_opts_from_tokens(argv, &LSEEK_OPTS)?;
let lseek_opts = get_lseek_opts(opts)?;
let mut argv = prepare_argv(argv)?.into_iter();
argv.next(); // drop 'seek'
let Some(fd) = argv.next() else {
return Err(ShErr::simple(
ShErrKind::ExecFail,
"lseek: Missing required argument 'fd'",
));
};
let Ok(fd) = fd.0.parse::<u32>() else {
return Err(
ShErr::at(ShErrKind::ExecFail, fd.1, "Invalid file descriptor")
.with_note("file descriptors are integers"),
);
};
let Some(offset) = argv.next() else {
return Err(ShErr::simple(
ShErrKind::ExecFail,
"lseek: Missing required argument 'offset'",
));
};
let Ok(offset) = offset.0.parse::<i64>() else {
return Err(
ShErr::at(ShErrKind::ExecFail, offset.1, "Invalid offset")
.with_note("offset can be a positive or negative integer"),
);
};
let whence = if lseek_opts.cursor_rel {
Whence::SeekCur
} else if lseek_opts.end_rel {
Whence::SeekEnd
} else {
Whence::SeekSet
};
match lseek(fd as i32, offset, whence) {
Ok(new_offset) => {
let stdout = borrow_fd(STDOUT_FILENO);
let buf = new_offset.to_string() + "\n";
write(stdout, buf.as_bytes())?;
}
Err(e) => {
state::set_status(1);
return Err(e.into());
}
}
state::set_status(0);
Ok(())
}
pub fn get_lseek_opts(opts: Vec<Opt>) -> ShResult<LseekOpts> {
let mut lseek_opts = LseekOpts {
cursor_rel: false,
end_rel: false,
};
for opt in opts {
match opt {
Opt::Short('c') => lseek_opts.cursor_rel = true,
Opt::Short('e') => lseek_opts.end_rel = true,
_ => {
return Err(ShErr::simple(
ShErrKind::ExecFail,
format!("lseek: Unexpected flag '{opt}'"),
));
}
}
}
Ok(lseek_opts)
}
#[cfg(test)]
mod tests {
use crate::testutil::{TestGuard, test_input};
use pretty_assertions::assert_eq;
#[test]
fn seek_set_beginning() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "hello world\n").unwrap();
let g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
test_input("seek 9 0").unwrap();
let out = g.read_output();
assert_eq!(out, "0\n");
}
#[test]
fn seek_set_offset() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "hello world\n").unwrap();
let g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
test_input("seek 9 6").unwrap();
let out = g.read_output();
assert_eq!(out, "6\n");
}
#[test]
fn seek_then_read() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "hello world\n").unwrap();
let g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
test_input("seek 9 6").unwrap();
// Clear the seek output
g.read_output();
test_input("read line <&9").unwrap();
let val = crate::state::read_vars(|v| v.get_var("line"));
assert_eq!(val, "world");
}
#[test]
fn seek_cur_relative() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "abcdefghij\n").unwrap();
let g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
test_input("seek 9 3").unwrap();
test_input("seek -c 9 4").unwrap();
let out = g.read_output();
assert_eq!(out, "3\n7\n");
}
#[test]
fn seek_end() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "hello\n").unwrap(); // 6 bytes
let g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
test_input("seek -e 9 0").unwrap();
let out = g.read_output();
assert_eq!(out, "6\n");
}
#[test]
fn seek_end_negative() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "hello\n").unwrap(); // 6 bytes
let g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
test_input("seek -e 9 -2").unwrap();
let out = g.read_output();
assert_eq!(out, "4\n");
}
#[test]
fn seek_write_overwrite() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "hello world\n").unwrap();
let _g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
test_input("seek 9 6").unwrap();
test_input("echo -n 'WORLD' >&9").unwrap();
let contents = std::fs::read_to_string(&path).unwrap();
assert_eq!(contents, "hello WORLD\n");
}
#[test]
fn seek_rewind_full_read() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("seek.txt");
std::fs::write(&path, "abc\n").unwrap();
let g = TestGuard::new();
test_input(format!("exec 9<> {}", path.display())).unwrap();
// Read moves cursor to EOF
test_input("read line <&9").unwrap();
// Rewind
test_input("seek 9 0").unwrap();
// Clear output from seek
g.read_output();
// Read again from beginning
test_input("read line <&9").unwrap();
let val = crate::state::read_vars(|v| v.get_var("line"));
assert_eq!(val, "abc");
}
#[test]
fn seek_bad_fd() {
let _g = TestGuard::new();
let result = test_input("seek 99 0");
assert!(result.is_err());
}
#[test]
fn seek_missing_args() {
let _g = TestGuard::new();
let result = test_input("seek");
assert!(result.is_err());
let result = test_input("seek 9");
assert!(result.is_err());
}
}

13
src/builtin/shopt.rs
View File

@@ -32,7 +32,7 @@ pub fn shopt(node: Node) -> ShResult<()> {
} }
for (arg, span) in argv { for (arg, span) in argv {
let Some(mut output) = write_shopts(|s| s.query(&arg)).promote_err(span)? else { let Some(mut output) = write_shopts(|s| s.query(&arg)).blame(span)? else {
continue; continue;
}; };
@@ -61,7 +61,7 @@ mod tests {
assert!(out.contains("dotglob")); assert!(out.contains("dotglob"));
assert!(out.contains("autocd")); assert!(out.contains("autocd"));
assert!(out.contains("max_hist")); assert!(out.contains("max_hist"));
assert!(out.contains("comp_limit")); assert!(out.contains("edit_mode"));
} }
#[test] #[test]
@@ -72,7 +72,7 @@ mod tests {
assert!(out.contains("dotglob")); assert!(out.contains("dotglob"));
assert!(out.contains("autocd")); assert!(out.contains("autocd"));
// Should not contain prompt opts // Should not contain prompt opts
assert!(!out.contains("comp_limit")); assert!(!out.contains("edit_mode"));
} }
#[test] #[test]
@@ -107,10 +107,11 @@ mod tests {
} }
#[test] #[test]
fn shopt_set_completion_ignore_case() { fn shopt_set_edit_mode() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("shopt prompt.completion_ignore_case=true").unwrap(); test_input("shopt prompt.edit_mode=emacs").unwrap();
assert!(read_shopts(|o| o.prompt.completion_ignore_case)); let mode = read_shopts(|o| format!("{}", o.prompt.edit_mode));
assert_eq!(mode, "emacs");
} }
// ===================== Error cases ===================== // ===================== Error cases =====================

204
src/builtin/source.rs
View File

@@ -44,128 +44,128 @@ pub fn source(node: Node) -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
pub mod tests { pub mod tests {
use std::io::Write; use std::io::Write;
use crate::state::{self, read_logic, read_vars}; use tempfile::{NamedTempFile, TempDir};
use crate::testutil::{TestGuard, test_input}; use crate::state::{self, read_logic, read_vars};
use tempfile::{NamedTempFile, TempDir}; use crate::testutil::{TestGuard, test_input};
#[test] #[test]
fn source_simple() { fn source_simple() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let mut file = NamedTempFile::new().unwrap(); let mut file = NamedTempFile::new().unwrap();
let path = file.path().display().to_string(); let path = file.path().display().to_string();
file.write_all(b"some_var=some_val").unwrap(); file.write_all(b"some_var=some_val").unwrap();
test_input(format!("source {path}")).unwrap(); test_input(format!("source {path}")).unwrap();
let var = read_vars(|v| v.get_var("some_var")); let var = read_vars(|v| v.get_var("some_var"));
assert_eq!(var, "some_val".to_string()); assert_eq!(var, "some_val".to_string());
} }
#[test] #[test]
fn source_multiple_commands() { fn source_multiple_commands() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let mut file = NamedTempFile::new().unwrap(); let mut file = NamedTempFile::new().unwrap();
let path = file.path().display().to_string(); let path = file.path().display().to_string();
file.write_all(b"x=1\ny=2\nz=3").unwrap(); file.write_all(b"x=1\ny=2\nz=3").unwrap();
test_input(format!("source {path}")).unwrap(); test_input(format!("source {path}")).unwrap();
assert_eq!(read_vars(|v| v.get_var("x")), "1"); assert_eq!(read_vars(|v| v.get_var("x")), "1");
assert_eq!(read_vars(|v| v.get_var("y")), "2"); assert_eq!(read_vars(|v| v.get_var("y")), "2");
assert_eq!(read_vars(|v| v.get_var("z")), "3"); assert_eq!(read_vars(|v| v.get_var("z")), "3");
} }
#[test] #[test]
fn source_defines_function() { fn source_defines_function() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let mut file = NamedTempFile::new().unwrap(); let mut file = NamedTempFile::new().unwrap();
let path = file.path().display().to_string(); let path = file.path().display().to_string();
file.write_all(b"greet() { echo hi; }").unwrap(); file.write_all(b"greet() { echo hi; }").unwrap();
test_input(format!("source {path}")).unwrap(); test_input(format!("source {path}")).unwrap();
let func = read_logic(|l| l.get_func("greet")); let func = read_logic(|l| l.get_func("greet"));
assert!(func.is_some()); assert!(func.is_some());
} }
#[test] #[test]
fn source_defines_alias() { fn source_defines_alias() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let mut file = NamedTempFile::new().unwrap(); let mut file = NamedTempFile::new().unwrap();
let path = file.path().display().to_string(); let path = file.path().display().to_string();
file.write_all(b"alias ll='ls -la'").unwrap(); file.write_all(b"alias ll='ls -la'").unwrap();
test_input(format!("source {path}")).unwrap(); test_input(format!("source {path}")).unwrap();
let alias = read_logic(|l| l.get_alias("ll")); let alias = read_logic(|l| l.get_alias("ll"));
assert!(alias.is_some()); assert!(alias.is_some());
} }
#[test] #[test]
fn source_output_captured() { fn source_output_captured() {
let guard = TestGuard::new(); let guard = TestGuard::new();
let mut file = NamedTempFile::new().unwrap(); let mut file = NamedTempFile::new().unwrap();
let path = file.path().display().to_string(); let path = file.path().display().to_string();
file.write_all(b"echo sourced").unwrap(); file.write_all(b"echo sourced").unwrap();
test_input(format!("source {path}")).unwrap(); test_input(format!("source {path}")).unwrap();
let out = guard.read_output(); let out = guard.read_output();
assert!(out.contains("sourced")); assert!(out.contains("sourced"));
} }
#[test] #[test]
fn source_multiple_files() { fn source_multiple_files() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let mut file1 = NamedTempFile::new().unwrap(); let mut file1 = NamedTempFile::new().unwrap();
let mut file2 = NamedTempFile::new().unwrap(); let mut file2 = NamedTempFile::new().unwrap();
let path1 = file1.path().display().to_string(); let path1 = file1.path().display().to_string();
let path2 = file2.path().display().to_string(); let path2 = file2.path().display().to_string();
file1.write_all(b"a=from_file1").unwrap(); file1.write_all(b"a=from_file1").unwrap();
file2.write_all(b"b=from_file2").unwrap(); file2.write_all(b"b=from_file2").unwrap();
test_input(format!("source {path1} {path2}")).unwrap(); test_input(format!("source {path1} {path2}")).unwrap();
assert_eq!(read_vars(|v| v.get_var("a")), "from_file1"); assert_eq!(read_vars(|v| v.get_var("a")), "from_file1");
assert_eq!(read_vars(|v| v.get_var("b")), "from_file2"); assert_eq!(read_vars(|v| v.get_var("b")), "from_file2");
} }
// ===================== Dot syntax ===================== // ===================== Dot syntax =====================
#[test] #[test]
fn source_dot_syntax() { fn source_dot_syntax() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let mut file = NamedTempFile::new().unwrap(); let mut file = NamedTempFile::new().unwrap();
let path = file.path().display().to_string(); let path = file.path().display().to_string();
file.write_all(b"dot_var=dot_val").unwrap(); file.write_all(b"dot_var=dot_val").unwrap();
test_input(format!(". {path}")).unwrap(); test_input(format!(". {path}")).unwrap();
assert_eq!(read_vars(|v| v.get_var("dot_var")), "dot_val"); assert_eq!(read_vars(|v| v.get_var("dot_var")), "dot_val");
} }
// ===================== Error cases ===================== // ===================== Error cases =====================
#[test] #[test]
fn source_nonexistent_file() { fn source_nonexistent_file() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let result = test_input("source /tmp/__no_such_file_xyz__"); let result = test_input("source /tmp/__no_such_file_xyz__");
assert!(result.is_err()); assert!(result.is_err());
} }
#[test] #[test]
fn source_directory_fails() { fn source_directory_fails() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let dir = TempDir::new().unwrap(); let dir = TempDir::new().unwrap();
let result = test_input(format!("source {}", dir.path().display())); let result = test_input(format!("source {}", dir.path().display()));
assert!(result.is_err()); assert!(result.is_err());
} }
// ===================== Status ===================== // ===================== Status =====================
#[test] #[test]
fn source_status_zero() { fn source_status_zero() {
let _g = TestGuard::new(); let _g = TestGuard::new();
let mut file = NamedTempFile::new().unwrap(); let mut file = NamedTempFile::new().unwrap();
let path = file.path().display().to_string(); let path = file.path().display().to_string();
file.write_all(b"true").unwrap(); file.write_all(b"true").unwrap();
test_input(format!("source {path}")).unwrap(); test_input(format!("source {path}")).unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
} }

18
src/builtin/test.rs
View File

@@ -94,10 +94,7 @@ impl FromStr for TestOp {
"-ge" => Ok(Self::IntGe), "-ge" => Ok(Self::IntGe),
"-le" => Ok(Self::IntLe), "-le" => Ok(Self::IntLe),
_ if TEST_UNARY_OPS.contains(&s) => Ok(Self::Unary(s.parse::<UnaryOp>()?)), _ if TEST_UNARY_OPS.contains(&s) => Ok(Self::Unary(s.parse::<UnaryOp>()?)),
_ => Err(ShErr::simple( _ => Err(ShErr::simple(ShErrKind::SyntaxErr, format!("Invalid test operator '{}'", s))),
ShErrKind::SyntaxErr,
format!("Invalid test operator '{}'", s),
)),
} }
} }
} }
@@ -124,7 +121,7 @@ pub fn double_bracket_test(node: Node) -> ShResult<bool> {
}; };
let mut last_result = false; let mut last_result = false;
let mut conjunct_op: Option<ConjunctOp>; let mut conjunct_op: Option<ConjunctOp>;
log::trace!("test cases: {:#?}", cases); log::trace!("test cases: {:#?}", cases);
for case in cases { for case in cases {
let result = match case { let result = match case {
@@ -308,10 +305,10 @@ pub fn double_bracket_test(node: Node) -> ShResult<bool> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::fs;
use tempfile::{TempDir, NamedTempFile};
use crate::state; use crate::state;
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
use std::fs;
use tempfile::{NamedTempFile, TempDir};
// ===================== Unary: file tests ===================== // ===================== Unary: file tests =====================
@@ -593,10 +590,9 @@ mod tests {
fn parse_unary_ops() { fn parse_unary_ops() {
use super::UnaryOp; use super::UnaryOp;
use std::str::FromStr; use std::str::FromStr;
for op in [ for op in ["-e", "-d", "-f", "-h", "-L", "-r", "-w", "-x", "-s",
"-e", "-d", "-f", "-h", "-L", "-r", "-w", "-x", "-s", "-p", "-S", "-b", "-c", "-k", "-O", "-p", "-S", "-b", "-c", "-k", "-O", "-G", "-N", "-u",
"-G", "-N", "-u", "-g", "-t", "-n", "-z", "-g", "-t", "-n", "-z"] {
] {
assert!(UnaryOp::from_str(op).is_ok(), "failed to parse {op}"); assert!(UnaryOp::from_str(op).is_ok(), "failed to parse {op}");
} }
} }

8
src/builtin/trap.rs
View File

@@ -171,10 +171,10 @@ pub fn trap(node: Node) -> ShResult<()> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::TrapTarget; use super::TrapTarget;
use std::str::FromStr;
use nix::sys::signal::Signal;
use crate::state::{self, read_logic}; use crate::state::{self, read_logic};
use crate::testutil::{TestGuard, test_input}; use crate::testutil::{TestGuard, test_input};
use nix::sys::signal::Signal;
use std::str::FromStr;
// ===================== Pure: TrapTarget parsing ===================== // ===================== Pure: TrapTarget parsing =====================
@@ -231,9 +231,7 @@ mod tests {
#[test] #[test]
fn display_signal_roundtrip() { fn display_signal_roundtrip() {
for name in &[ for name in &["INT", "QUIT", "TERM", "USR1", "USR2", "ALRM", "CHLD", "WINCH"] {
"INT", "QUIT", "TERM", "USR1", "USR2", "ALRM", "CHLD", "WINCH",
] {
let target = TrapTarget::from_str(name).unwrap(); let target = TrapTarget::from_str(name).unwrap();
assert_eq!(target.to_string(), *name); assert_eq!(target.to_string(), *name);
} }

18
src/builtin/varcmds.rs
View File

@@ -245,16 +245,8 @@ mod tests {
test_input("readonly a=1 b=2").unwrap(); test_input("readonly a=1 b=2").unwrap();
assert_eq!(read_vars(|v| v.get_var("a")), "1"); assert_eq!(read_vars(|v| v.get_var("a")), "1");
assert_eq!(read_vars(|v| v.get_var("b")), "2"); assert_eq!(read_vars(|v| v.get_var("b")), "2");
assert!( assert!(read_vars(|v| v.get_var_flags("a")).unwrap().contains(VarFlags::READONLY));
read_vars(|v| v.get_var_flags("a")) assert!(read_vars(|v| v.get_var_flags("b")).unwrap().contains(VarFlags::READONLY));
.unwrap()
.contains(VarFlags::READONLY)
);
assert!(
read_vars(|v| v.get_var_flags("b"))
.unwrap()
.contains(VarFlags::READONLY)
);
} }
#[test] #[test]
@@ -393,11 +385,7 @@ mod tests {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("local mylocal").unwrap(); test_input("local mylocal").unwrap();
assert_eq!(read_vars(|v| v.get_var("mylocal")), ""); assert_eq!(read_vars(|v| v.get_var("mylocal")), "");
assert!( assert!(read_vars(|v| v.get_var_flags("mylocal")).unwrap().contains(VarFlags::LOCAL));
read_vars(|v| v.get_var_flags("mylocal"))
.unwrap()
.contains(VarFlags::LOCAL)
);
} }
#[test] #[test]

620
src/expand.rs
View File

@@ -4,7 +4,6 @@ use std::str::{Chars, FromStr};
use ariadne::Fmt; use ariadne::Fmt;
use glob::Pattern; use glob::Pattern;
use nix::unistd::{Uid, User};
use regex::Regex; use regex::Regex;
use crate::libsh::error::{ShErr, ShErrKind, ShResult, ShResultExt, next_color}; use crate::libsh::error::{ShErr, ShErrKind, ShResult, ShResultExt, next_color};
@@ -41,26 +40,18 @@ impl Tk {
} }
pub struct Expander { pub struct Expander {
flags: TkFlags,
raw: String, raw: String,
} }
impl Expander { impl Expander {
pub fn new(raw: Tk) -> ShResult<Self> { pub fn new(raw: Tk) -> ShResult<Self> {
let tk_raw = raw.span.as_str(); let raw = raw.span.as_str();
Self::from_raw(tk_raw, raw.flags) Self::from_raw(raw)
} }
pub fn from_raw(raw: &str, flags: TkFlags) -> ShResult<Self> { pub fn from_raw(raw: &str) -> ShResult<Self> {
let raw = expand_braces_full(raw)?.join(" "); let raw = expand_braces_full(raw)?.join(" ");
let unescaped = if flags.contains(TkFlags::IS_HEREDOC) { let unescaped = unescape_str(&raw);
unescape_heredoc(&raw) Ok(Self { raw: unescaped })
} else {
unescape_str(&raw)
};
Ok(Self {
raw: unescaped,
flags,
})
} }
pub fn expand(&mut self) -> ShResult<Vec<String>> { pub fn expand(&mut self) -> ShResult<Vec<String>> {
let mut chars = self.raw.chars().peekable(); let mut chars = self.raw.chars().peekable();
@@ -84,11 +75,7 @@ impl Expander {
self.raw.insert_str(0, "./"); self.raw.insert_str(0, "./");
} }
if self.flags.contains(TkFlags::IS_HEREDOC) { Ok(self.split_words())
Ok(vec![self.raw.clone()])
} else {
Ok(self.split_words())
}
} }
pub fn split_words(&mut self) -> Vec<String> { pub fn split_words(&mut self) -> Vec<String> {
let mut words = vec![]; let mut words = vec![];
@@ -99,11 +86,6 @@ impl Expander {
'outer: while let Some(ch) = chars.next() { 'outer: while let Some(ch) = chars.next() {
match ch { match ch {
markers::ESCAPE => {
if let Some(next_ch) = chars.next() {
cur_word.push(next_ch);
}
}
markers::DUB_QUOTE | markers::SNG_QUOTE | markers::SUBSH => { markers::DUB_QUOTE | markers::SNG_QUOTE | markers::SUBSH => {
while let Some(q_ch) = chars.next() { while let Some(q_ch) = chars.next() {
match q_ch { match q_ch {
@@ -474,32 +456,7 @@ pub fn expand_raw(chars: &mut Peekable<Chars<'_>>) -> ShResult<String> {
while let Some(ch) = chars.next() { while let Some(ch) = chars.next() {
match ch { match ch {
markers::TILDE_SUB => { markers::TILDE_SUB => {
let mut username = String::new(); let home = env::var("HOME").unwrap_or_default();
while chars.peek().is_some_and(|ch| *ch != '/') {
let ch = chars.next().unwrap();
username.push(ch);
}
let home = if username.is_empty() {
// standard '~' expansion
env::var("HOME").unwrap_or_default()
} else if let Ok(result) = User::from_name(&username)
&& let Some(user) = result
{
// username expansion like '~user'
user.dir.to_string_lossy().to_string()
} else if let Ok(id) = username.parse::<u32>()
&& let Ok(result) = User::from_uid(Uid::from_raw(id))
&& let Some(user) = result
{
// uid expansion like '~1000'
// shed only feature btw B)
user.dir.to_string_lossy().to_string()
} else {
// no match, use literal
format!("~{username}")
};
result.push_str(&home); result.push_str(&home);
} }
markers::PROC_SUB_OUT => { markers::PROC_SUB_OUT => {
@@ -677,12 +634,8 @@ pub fn expand_glob(raw: &str) -> ShResult<String> {
{ {
let entry = let entry =
entry.map_err(|_| ShErr::simple(ShErrKind::SyntaxErr, "Invalid filename found in glob"))?; entry.map_err(|_| ShErr::simple(ShErrKind::SyntaxErr, "Invalid filename found in glob"))?;
let entry_raw = entry
.to_str()
.ok_or_else(|| ShErr::simple(ShErrKind::SyntaxErr, "Non-UTF8 filename found in glob"))?;
let escaped = escape_str(entry_raw, true);
words.push(escaped) words.push(entry.to_str().unwrap().to_string())
} }
Ok(words.join(" ")) Ok(words.join(" "))
} }
@@ -1020,11 +973,6 @@ pub fn expand_cmd_sub(raw: &str) -> ShResult<String> {
} }
} }
/// Strip ESCAPE markers from a string, leaving the characters they protect intact.
fn strip_escape_markers(s: &str) -> String {
s.replace(markers::ESCAPE, "")
}
/// Processes strings into intermediate representations that are more readable /// Processes strings into intermediate representations that are more readable
/// by the program /// by the program
/// ///
@@ -1041,7 +989,6 @@ pub fn unescape_str(raw: &str) -> String {
'~' if first_char => result.push(markers::TILDE_SUB), '~' if first_char => result.push(markers::TILDE_SUB),
'\\' => { '\\' => {
if let Some(next_ch) = chars.next() { if let Some(next_ch) = chars.next() {
result.push(markers::ESCAPE);
result.push(next_ch) result.push(next_ch)
} }
} }
@@ -1192,25 +1139,6 @@ pub fn unescape_str(raw: &str) -> String {
} }
} }
} }
'`' => {
result.push(markers::VAR_SUB);
result.push(markers::SUBSH);
while let Some(bt_ch) = chars.next() {
match bt_ch {
'\\' => {
result.push(bt_ch);
if let Some(next_ch) = chars.next() {
result.push(next_ch);
}
}
'`' => {
result.push(markers::SUBSH);
break;
}
_ => result.push(bt_ch),
}
}
}
'"' => { '"' => {
result.push(markers::DUB_QUOTE); result.push(markers::DUB_QUOTE);
break; break;
@@ -1223,16 +1151,14 @@ pub fn unescape_str(raw: &str) -> String {
result.push(markers::SNG_QUOTE); result.push(markers::SNG_QUOTE);
while let Some(q_ch) = chars.next() { while let Some(q_ch) = chars.next() {
match q_ch { match q_ch {
'\\' => { '\\' => {
match chars.peek() { if chars.peek() == Some(&'\'') {
Some(&'\\') | result.push('\'');
Some(&'\'') => { chars.next();
let ch = chars.next().unwrap(); } else {
result.push(ch); result.push('\\');
} }
_ => result.push(q_ch), }
}
}
'\'' => { '\'' => {
result.push(markers::SNG_QUOTE); result.push(markers::SNG_QUOTE);
break; break;
@@ -1377,25 +1303,6 @@ pub fn unescape_str(raw: &str) -> String {
result.push('$'); result.push('$');
} }
} }
'`' => {
result.push(markers::VAR_SUB);
result.push(markers::SUBSH);
while let Some(bt_ch) = chars.next() {
match bt_ch {
'\\' => {
result.push(bt_ch);
if let Some(next_ch) = chars.next() {
result.push(next_ch);
}
}
'`' => {
result.push(markers::SUBSH);
break;
}
_ => result.push(bt_ch),
}
}
}
_ => result.push(ch), _ => result.push(ch),
} }
first_char = false; first_char = false;
@@ -1404,134 +1311,6 @@ pub fn unescape_str(raw: &str) -> String {
result result
} }
/// Like unescape_str but for heredoc bodies. Only processes:
/// - $var / ${var} / $(cmd) substitution markers
/// - Backslash escapes (only before $, `, \, and newline)
///
/// Everything else (quotes, tildes, globs, process subs, etc.) is literal.
pub fn unescape_heredoc(raw: &str) -> String {
let mut chars = raw.chars().peekable();
let mut result = String::new();
while let Some(ch) = chars.next() {
match ch {
'\\' => {
match chars.peek() {
Some('$') | Some('`') | Some('\\') | Some('\n') => {
let next_ch = chars.next().unwrap();
if next_ch == '\n' {
// line continuation — discard both backslash and newline
continue;
}
result.push(markers::ESCAPE);
result.push(next_ch);
}
_ => {
// backslash is literal
result.push('\\');
}
}
}
'$' if chars.peek() == Some(&'(') => {
result.push(markers::VAR_SUB);
chars.next(); // consume '('
result.push(markers::SUBSH);
let mut paren_count = 1;
while let Some(subsh_ch) = chars.next() {
match subsh_ch {
'\\' => {
result.push(subsh_ch);
if let Some(next_ch) = chars.next() {
result.push(next_ch);
}
}
'(' => {
paren_count += 1;
result.push(subsh_ch);
}
')' => {
paren_count -= 1;
if paren_count == 0 {
result.push(markers::SUBSH);
break;
} else {
result.push(subsh_ch);
}
}
_ => result.push(subsh_ch),
}
}
}
'$' => {
result.push(markers::VAR_SUB);
if chars.peek() == Some(&'$') {
chars.next();
result.push('$');
}
}
'`' => {
result.push(markers::VAR_SUB);
result.push(markers::SUBSH);
while let Some(bt_ch) = chars.next() {
match bt_ch {
'\\' => {
result.push(bt_ch);
if let Some(next_ch) = chars.next() {
result.push(next_ch);
}
}
'`' => {
result.push(markers::SUBSH);
break;
}
_ => result.push(bt_ch),
}
}
}
_ => result.push(ch),
}
}
result
}
/// Opposite of unescape_str - escapes a string to be executed as literal text
/// Used for completion results, and glob filename matches.
pub fn escape_str(raw: &str, use_marker: bool) -> String {
let mut result = String::new();
let mut chars = raw.chars();
while let Some(ch) = chars.next() {
match ch {
'\'' | '"' | '\\' | '|' | '&' | ';' | '(' | ')' | '<' | '>' | '$' | '*' | '!' | '`' | '{'
| '?' | '[' | '#' | ' ' | '\t' | '\n' => {
if use_marker {
result.push(markers::ESCAPE);
} else {
result.push('\\');
}
result.push(ch);
continue;
}
'~' if result.is_empty() => {
if use_marker {
result.push(markers::ESCAPE);
} else {
result.push('\\');
}
result.push(ch);
continue;
}
_ => {
result.push(ch);
continue;
}
}
}
result
}
pub fn unescape_math(raw: &str) -> String { pub fn unescape_math(raw: &str) -> String {
let mut chars = raw.chars().peekable(); let mut chars = raw.chars().peekable();
let mut result = String::new(); let mut result = String::new();
@@ -1585,10 +1364,6 @@ pub fn unescape_math(raw: &str) -> String {
#[derive(Debug)] #[derive(Debug)]
pub enum ParamExp { pub enum ParamExp {
Len, // #var_name Len, // #var_name
ToUpperFirst, // ^var_name
ToUpperAll, // ^^var_name
ToLowerFirst, // ,var_name
ToLowerAll, // ,,var_name
DefaultUnsetOrNull(String), // :- DefaultUnsetOrNull(String), // :-
DefaultUnset(String), // - DefaultUnset(String), // -
SetDefaultUnsetOrNull(String), // := SetDefaultUnsetOrNull(String), // :=
@@ -1624,19 +1399,6 @@ impl FromStr for ParamExp {
)) ))
}; };
if s == "^^" {
return Ok(ToUpperAll);
}
if s == "^" {
return Ok(ToUpperFirst);
}
if s == ",," {
return Ok(ToLowerAll);
}
if s == "," {
return Ok(ToLowerFirst);
}
// Handle indirect var expansion: ${!var} // Handle indirect var expansion: ${!var}
if let Some(var) = s.strip_prefix('!') { if let Some(var) = s.strip_prefix('!') {
if var.ends_with('*') || var.ends_with('@') { if var.ends_with('*') || var.ends_with('@') {
@@ -1742,7 +1504,7 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
while let Some(ch) = chars.next() { while let Some(ch) = chars.next() {
match ch { match ch {
'!' | '#' | '%' | ':' | '-' | '+' | '^' | ',' | '=' | '/' | '?' => { '!' | '#' | '%' | ':' | '-' | '+' | '=' | '/' | '?' => {
rest.push(ch); rest.push(ch);
rest.push_str(&chars.collect::<String>()); rest.push_str(&chars.collect::<String>());
break; break;
@@ -1754,32 +1516,6 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
if let Ok(expansion) = rest.parse::<ParamExp>() { if let Ok(expansion) = rest.parse::<ParamExp>() {
match expansion { match expansion {
ParamExp::Len => unreachable!(), ParamExp::Len => unreachable!(),
ParamExp::ToUpperAll => {
let value = vars.get_var(&var_name);
Ok(value.to_uppercase())
}
ParamExp::ToUpperFirst => {
let value = vars.get_var(&var_name);
let mut chars = value.chars();
let first = chars
.next()
.map(|c| c.to_uppercase().to_string())
.unwrap_or_default();
Ok(first + chars.as_str())
}
ParamExp::ToLowerAll => {
let value = vars.get_var(&var_name);
Ok(value.to_lowercase())
}
ParamExp::ToLowerFirst => {
let value = vars.get_var(&var_name);
let mut chars = value.chars();
let first = chars
.next()
.map(|c| c.to_lowercase().to_string())
.unwrap_or_default();
Ok(first + chars.as_str())
}
ParamExp::DefaultUnsetOrNull(default) => { ParamExp::DefaultUnsetOrNull(default) => {
match vars.try_get_var(&var_name).filter(|v| !v.is_empty()) { match vars.try_get_var(&var_name).filter(|v| !v.is_empty()) {
Some(val) => Ok(val), Some(val) => Ok(val),
@@ -1852,8 +1588,7 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
ParamExp::RemShortestPrefix(prefix) => { ParamExp::RemShortestPrefix(prefix) => {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let unescaped = unescape_str(&prefix); let unescaped = unescape_str(&prefix);
let expanded = let expanded = expand_raw(&mut unescaped.chars().peekable()).unwrap_or(prefix);
strip_escape_markers(&expand_raw(&mut unescaped.chars().peekable()).unwrap_or(prefix));
let pattern = Pattern::new(&expanded).unwrap(); let pattern = Pattern::new(&expanded).unwrap();
for i in 0..=value.len() { for i in 0..=value.len() {
let sliced = &value[..i]; let sliced = &value[..i];
@@ -1866,8 +1601,7 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
ParamExp::RemLongestPrefix(prefix) => { ParamExp::RemLongestPrefix(prefix) => {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let unescaped = unescape_str(&prefix); let unescaped = unescape_str(&prefix);
let expanded = let expanded = expand_raw(&mut unescaped.chars().peekable()).unwrap_or(prefix);
strip_escape_markers(&expand_raw(&mut unescaped.chars().peekable()).unwrap_or(prefix));
let pattern = Pattern::new(&expanded).unwrap(); let pattern = Pattern::new(&expanded).unwrap();
for i in (0..=value.len()).rev() { for i in (0..=value.len()).rev() {
let sliced = &value[..i]; let sliced = &value[..i];
@@ -1880,8 +1614,7 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
ParamExp::RemShortestSuffix(suffix) => { ParamExp::RemShortestSuffix(suffix) => {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let unescaped = unescape_str(&suffix); let unescaped = unescape_str(&suffix);
let expanded = let expanded = expand_raw(&mut unescaped.chars().peekable()).unwrap_or(suffix);
strip_escape_markers(&expand_raw(&mut unescaped.chars().peekable()).unwrap_or(suffix));
let pattern = Pattern::new(&expanded).unwrap(); let pattern = Pattern::new(&expanded).unwrap();
for i in (0..=value.len()).rev() { for i in (0..=value.len()).rev() {
let sliced = &value[i..]; let sliced = &value[i..];
@@ -1894,9 +1627,8 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
ParamExp::RemLongestSuffix(suffix) => { ParamExp::RemLongestSuffix(suffix) => {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let unescaped = unescape_str(&suffix); let unescaped = unescape_str(&suffix);
let expanded_suffix = strip_escape_markers( let expanded_suffix =
&expand_raw(&mut unescaped.chars().peekable()).unwrap_or(suffix.clone()), expand_raw(&mut unescaped.chars().peekable()).unwrap_or(suffix.clone());
);
let pattern = Pattern::new(&expanded_suffix).unwrap(); let pattern = Pattern::new(&expanded_suffix).unwrap();
for i in 0..=value.len() { for i in 0..=value.len() {
let sliced = &value[i..]; let sliced = &value[i..];
@@ -1910,10 +1642,8 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let search = unescape_str(&search); let search = unescape_str(&search);
let replace = unescape_str(&replace); let replace = unescape_str(&replace);
let expanded_search = let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
strip_escape_markers(&expand_raw(&mut search.chars().peekable()).unwrap_or(search)); let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
let expanded_replace =
strip_escape_markers(&expand_raw(&mut replace.chars().peekable()).unwrap_or(replace));
let regex = glob_to_regex(&expanded_search, false); // unanchored pattern let regex = glob_to_regex(&expanded_search, false); // unanchored pattern
if let Some(mat) = regex.find(&value) { if let Some(mat) = regex.find(&value) {
@@ -1929,10 +1659,8 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let search = unescape_str(&search); let search = unescape_str(&search);
let replace = unescape_str(&replace); let replace = unescape_str(&replace);
let expanded_search = let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
strip_escape_markers(&expand_raw(&mut search.chars().peekable()).unwrap_or(search)); let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
let expanded_replace =
strip_escape_markers(&expand_raw(&mut replace.chars().peekable()).unwrap_or(replace));
let regex = glob_to_regex(&expanded_search, false); let regex = glob_to_regex(&expanded_search, false);
let mut result = String::new(); let mut result = String::new();
let mut last_match_end = 0; let mut last_match_end = 0;
@@ -1951,10 +1679,8 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let search = unescape_str(&search); let search = unescape_str(&search);
let replace = unescape_str(&replace); let replace = unescape_str(&replace);
let expanded_search = let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
strip_escape_markers(&expand_raw(&mut search.chars().peekable()).unwrap_or(search)); let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
let expanded_replace =
strip_escape_markers(&expand_raw(&mut replace.chars().peekable()).unwrap_or(replace));
let pattern = Pattern::new(&expanded_search).unwrap(); let pattern = Pattern::new(&expanded_search).unwrap();
for i in (0..=value.len()).rev() { for i in (0..=value.len()).rev() {
let sliced = &value[..i]; let sliced = &value[..i];
@@ -1968,10 +1694,8 @@ pub fn perform_param_expansion(raw: &str) -> ShResult<String> {
let value = vars.get_var(&var_name); let value = vars.get_var(&var_name);
let search = unescape_str(&search); let search = unescape_str(&search);
let replace = unescape_str(&replace); let replace = unescape_str(&replace);
let expanded_search = let expanded_search = expand_raw(&mut search.chars().peekable()).unwrap_or(search);
strip_escape_markers(&expand_raw(&mut search.chars().peekable()).unwrap_or(search)); let expanded_replace = expand_raw(&mut replace.chars().peekable()).unwrap_or(replace);
let expanded_replace =
strip_escape_markers(&expand_raw(&mut replace.chars().peekable()).unwrap_or(replace));
let pattern = Pattern::new(&expanded_search).unwrap(); let pattern = Pattern::new(&expanded_search).unwrap();
for i in (0..=value.len()).rev() { for i in (0..=value.len()).rev() {
let sliced = &value[i..]; let sliced = &value[i..];
@@ -2016,11 +1740,6 @@ pub fn expand_case_pattern(raw: &str) -> ShResult<String> {
markers::DUB_QUOTE | markers::SNG_QUOTE => { markers::DUB_QUOTE | markers::SNG_QUOTE => {
in_quote = !in_quote; in_quote = !in_quote;
} }
markers::ESCAPE => {
if let Some(next_ch) = chars.next() {
result.push(next_ch);
}
}
'*' | '?' | '[' | ']' if in_quote => { '*' | '?' | '[' | ']' if in_quote => {
result.push('\\'); result.push('\\');
result.push(ch); result.push(ch);
@@ -2662,11 +2381,11 @@ pub fn parse_key_alias(alias: &str) -> Option<KeyEvent> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::parse::lex::Span;
use crate::readline::keys::{KeyCode, KeyEvent, ModKeys};
use crate::state::{ArrIndex, VarFlags, VarKind, read_vars, write_vars};
use crate::testutil::{TestGuard, test_input};
use std::time::Duration; use std::time::Duration;
use crate::readline::keys::{KeyCode, KeyEvent, ModKeys};
use crate::state::{write_vars, read_vars, ArrIndex, VarKind, VarFlags};
use crate::parse::lex::Span;
use crate::testutil::{TestGuard, test_input};
// ===================== has_braces ===================== // ===================== has_braces =====================
@@ -2806,7 +2525,10 @@ mod tests {
#[test] #[test]
fn braces_simple_list() { fn braces_simple_list() {
assert_eq!(expand_braces_full("{a,b,c}").unwrap(), vec!["a", "b", "c"]); assert_eq!(
expand_braces_full("{a,b,c}").unwrap(),
vec!["a", "b", "c"]
);
} }
#[test] #[test]
@@ -2892,23 +2614,11 @@ mod tests {
assert_eq!(result, vec!["prepost", "preapost"]); assert_eq!(result, vec!["prepost", "preapost"]);
} }
#[test] #[test]
fn braces_cursed() { fn braces_cursed() {
let result = expand_braces_full("foo{a,{1,2,3,{1..4},5},c}{5..1}bar").unwrap(); let result = expand_braces_full("foo{a,{1,2,3,{1..4},5},c}{5..1}bar").unwrap();
assert_eq!( assert_eq!(result, vec![ "fooa5bar", "fooa4bar", "fooa3bar", "fooa2bar", "fooa1bar", "foo15bar", "foo14bar", "foo13bar", "foo12bar", "foo11bar", "foo25bar", "foo24bar", "foo23bar", "foo22bar", "foo21bar", "foo35bar", "foo34bar", "foo33bar", "foo32bar", "foo31bar", "foo15bar", "foo14bar", "foo13bar", "foo12bar", "foo11bar", "foo25bar", "foo24bar", "foo23bar", "foo22bar", "foo21bar", "foo35bar", "foo34bar", "foo33bar", "foo32bar", "foo31bar", "foo45bar", "foo44bar", "foo43bar", "foo42bar", "foo41bar", "foo55bar", "foo54bar", "foo53bar", "foo52bar", "foo51bar", "fooc5bar", "fooc4bar", "fooc3bar", "fooc2bar", "fooc1bar", ])
result, }
vec![
"fooa5bar", "fooa4bar", "fooa3bar", "fooa2bar", "fooa1bar", "foo15bar", "foo14bar",
"foo13bar", "foo12bar", "foo11bar", "foo25bar", "foo24bar", "foo23bar", "foo22bar",
"foo21bar", "foo35bar", "foo34bar", "foo33bar", "foo32bar", "foo31bar", "foo15bar",
"foo14bar", "foo13bar", "foo12bar", "foo11bar", "foo25bar", "foo24bar", "foo23bar",
"foo22bar", "foo21bar", "foo35bar", "foo34bar", "foo33bar", "foo32bar", "foo31bar",
"foo45bar", "foo44bar", "foo43bar", "foo42bar", "foo41bar", "foo55bar", "foo54bar",
"foo53bar", "foo52bar", "foo51bar", "fooc5bar", "fooc4bar", "fooc3bar", "fooc2bar",
"fooc1bar",
]
)
}
// ===================== Arithmetic ===================== // ===================== Arithmetic =====================
@@ -3148,8 +2858,7 @@ mod tests {
#[test] #[test]
fn unescape_backslash() { fn unescape_backslash() {
let result = unescape_str("hello\\nworld"); let result = unescape_str("hello\\nworld");
let expected = format!("hello{}nworld", markers::ESCAPE); assert_eq!(result, "hellonworld");
assert_eq!(result, expected);
} }
#[test] #[test]
@@ -3380,22 +3089,10 @@ mod tests {
#[test] #[test]
fn key_alias_arrows() { fn key_alias_arrows() {
assert_eq!( assert_eq!(parse_key_alias("UP").unwrap(), KeyEvent(KeyCode::Up, ModKeys::NONE));
parse_key_alias("UP").unwrap(), assert_eq!(parse_key_alias("DOWN").unwrap(), KeyEvent(KeyCode::Down, ModKeys::NONE));
KeyEvent(KeyCode::Up, ModKeys::NONE) assert_eq!(parse_key_alias("LEFT").unwrap(), KeyEvent(KeyCode::Left, ModKeys::NONE));
); assert_eq!(parse_key_alias("RIGHT").unwrap(), KeyEvent(KeyCode::Right, ModKeys::NONE));
assert_eq!(
parse_key_alias("DOWN").unwrap(),
KeyEvent(KeyCode::Down, ModKeys::NONE)
);
assert_eq!(
parse_key_alias("LEFT").unwrap(),
KeyEvent(KeyCode::Left, ModKeys::NONE)
);
assert_eq!(
parse_key_alias("RIGHT").unwrap(),
KeyEvent(KeyCode::Right, ModKeys::NONE)
);
} }
#[test] #[test]
@@ -3407,13 +3104,7 @@ mod tests {
#[test] #[test]
fn key_alias_ctrl_shift_alt_modifier() { fn key_alias_ctrl_shift_alt_modifier() {
let key = parse_key_alias("C-S-A-b").unwrap(); let key = parse_key_alias("C-S-A-b").unwrap();
assert_eq!( assert_eq!(key, KeyEvent(KeyCode::Char('B'), ModKeys::CTRL | ModKeys::SHIFT | ModKeys::ALT));
key,
KeyEvent(
KeyCode::Char('B'),
ModKeys::CTRL | ModKeys::SHIFT | ModKeys::ALT
)
);
} }
#[test] #[test]
@@ -3605,14 +3296,7 @@ mod tests {
#[test] #[test]
fn param_remove_shortest_prefix() { fn param_remove_shortest_prefix() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
write_vars(|v| { write_vars(|v| v.set_var("PATH", VarKind::Str("/usr/local/bin".into()), VarFlags::NONE)).unwrap();
v.set_var(
"PATH",
VarKind::Str("/usr/local/bin".into()),
VarFlags::NONE,
)
})
.unwrap();
let result = perform_param_expansion("PATH#*/").unwrap(); let result = perform_param_expansion("PATH#*/").unwrap();
assert_eq!(result, "usr/local/bin"); assert_eq!(result, "usr/local/bin");
@@ -3621,14 +3305,7 @@ mod tests {
#[test] #[test]
fn param_remove_longest_prefix() { fn param_remove_longest_prefix() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
write_vars(|v| { write_vars(|v| v.set_var("PATH", VarKind::Str("/usr/local/bin".into()), VarFlags::NONE)).unwrap();
v.set_var(
"PATH",
VarKind::Str("/usr/local/bin".into()),
VarFlags::NONE,
)
})
.unwrap();
let result = perform_param_expansion("PATH##*/").unwrap(); let result = perform_param_expansion("PATH##*/").unwrap();
assert_eq!(result, "bin"); assert_eq!(result, "bin");
@@ -3742,10 +3419,7 @@ mod tests {
fn word_split_default_ifs() { fn word_split_default_ifs() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
let mut exp = Expander { let mut exp = Expander { raw: "hello world\tfoo".to_string() };
raw: "hello world\tfoo".to_string(),
flags: TkFlags::empty(),
};
let words = exp.split_words(); let words = exp.split_words();
assert_eq!(words, vec!["hello", "world", "foo"]); assert_eq!(words, vec!["hello", "world", "foo"]);
} }
@@ -3753,14 +3427,9 @@ mod tests {
#[test] #[test]
fn word_split_custom_ifs() { fn word_split_custom_ifs() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
unsafe { unsafe { std::env::set_var("IFS", ":"); }
std::env::set_var("IFS", ":");
}
let mut exp = Expander { let mut exp = Expander { raw: "a:b:c".to_string() };
raw: "a:b:c".to_string(),
flags: TkFlags::empty(),
};
let words = exp.split_words(); let words = exp.split_words();
assert_eq!(words, vec!["a", "b", "c"]); assert_eq!(words, vec!["a", "b", "c"]);
} }
@@ -3768,14 +3437,9 @@ mod tests {
#[test] #[test]
fn word_split_empty_ifs() { fn word_split_empty_ifs() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
unsafe { unsafe { std::env::set_var("IFS", ""); }
std::env::set_var("IFS", "");
}
let mut exp = Expander { let mut exp = Expander { raw: "hello world".to_string() };
raw: "hello world".to_string(),
flags: TkFlags::empty(),
};
let words = exp.split_words(); let words = exp.split_words();
assert_eq!(words, vec!["hello world"]); assert_eq!(words, vec!["hello world"]);
} }
@@ -3785,82 +3449,11 @@ mod tests {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
let raw = format!("{}hello world{}", markers::DUB_QUOTE, markers::DUB_QUOTE); let raw = format!("{}hello world{}", markers::DUB_QUOTE, markers::DUB_QUOTE);
let mut exp = Expander { let mut exp = Expander { raw };
raw,
flags: TkFlags::empty(),
};
let words = exp.split_words(); let words = exp.split_words();
assert_eq!(words, vec!["hello world"]); assert_eq!(words, vec!["hello world"]);
} }
// ===================== Escaped Word Splitting =====================
#[test]
fn word_split_escaped_space() {
let _guard = TestGuard::new();
let raw = format!("hello{}world", unescape_str("\\ "));
let mut exp = Expander {
raw,
flags: TkFlags::empty(),
};
let words = exp.split_words();
assert_eq!(words, vec!["hello world"]);
}
#[test]
fn word_split_escaped_tab() {
let _guard = TestGuard::new();
let raw = format!("hello{}world", unescape_str("\\\t"));
let mut exp = Expander {
raw,
flags: TkFlags::empty(),
};
let words = exp.split_words();
assert_eq!(words, vec!["hello\tworld"]);
}
#[test]
fn word_split_escaped_custom_ifs() {
let _guard = TestGuard::new();
unsafe {
std::env::set_var("IFS", ":");
}
let raw = format!("a{}b:c", unescape_str("\\:"));
let mut exp = Expander {
raw,
flags: TkFlags::empty(),
};
let words = exp.split_words();
assert_eq!(words, vec!["a:b", "c"]);
}
// ===================== Parameter Expansion with Escapes (TestGuard) =====================
#[test]
fn param_exp_prefix_removal_escaped() {
let guard = TestGuard::new();
write_vars(|v| v.set_var("branch", VarKind::Str("## main".into()), VarFlags::NONE)).unwrap();
test_input("echo \"${branch#\\#\\# }\"").unwrap();
let out = guard.read_output();
assert_eq!(out, "main\n");
}
#[test]
fn param_exp_suffix_removal_escaped() {
let guard = TestGuard::new();
write_vars(|v| v.set_var("val", VarKind::Str("hello world!!".into()), VarFlags::NONE)).unwrap();
test_input("echo \"${val%\\!\\!}\"").unwrap();
let out = guard.read_output();
assert_eq!(out, "hello world\n");
}
// ===================== Arithmetic with Variables (TestGuard) ===================== // ===================== Arithmetic with Variables (TestGuard) =====================
#[test] #[test]
@@ -3885,13 +3478,8 @@ mod tests {
fn array_index_first() { fn array_index_first() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
write_vars(|v| { write_vars(|v| {
v.set_var( v.set_var("arr", VarKind::arr_from_vec(vec!["a".into(), "b".into(), "c".into()]), VarFlags::NONE)
"arr", }).unwrap();
VarKind::arr_from_vec(vec!["a".into(), "b".into(), "c".into()]),
VarFlags::NONE,
)
})
.unwrap();
let val = read_vars(|v| v.index_var("arr", ArrIndex::Literal(0))).unwrap(); let val = read_vars(|v| v.index_var("arr", ArrIndex::Literal(0))).unwrap();
assert_eq!(val, "a"); assert_eq!(val, "a");
@@ -3901,13 +3489,8 @@ mod tests {
fn array_index_second() { fn array_index_second() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
write_vars(|v| { write_vars(|v| {
v.set_var( v.set_var("arr", VarKind::arr_from_vec(vec!["x".into(), "y".into(), "z".into()]), VarFlags::NONE)
"arr", }).unwrap();
VarKind::arr_from_vec(vec!["x".into(), "y".into(), "z".into()]),
VarFlags::NONE,
)
})
.unwrap();
let val = read_vars(|v| v.index_var("arr", ArrIndex::Literal(1))).unwrap(); let val = read_vars(|v| v.index_var("arr", ArrIndex::Literal(1))).unwrap();
assert_eq!(val, "y"); assert_eq!(val, "y");
@@ -3917,13 +3500,8 @@ mod tests {
fn array_all_elems() { fn array_all_elems() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
write_vars(|v| { write_vars(|v| {
v.set_var( v.set_var("arr", VarKind::arr_from_vec(vec!["a".into(), "b".into(), "c".into()]), VarFlags::NONE)
"arr", }).unwrap();
VarKind::arr_from_vec(vec!["a".into(), "b".into(), "c".into()]),
VarFlags::NONE,
)
})
.unwrap();
let elems = read_vars(|v| v.get_arr_elems("arr")).unwrap(); let elems = read_vars(|v| v.get_arr_elems("arr")).unwrap();
assert_eq!(elems, vec!["a", "b", "c"]); assert_eq!(elems, vec!["a", "b", "c"]);
@@ -3933,13 +3511,8 @@ mod tests {
fn array_elem_count() { fn array_elem_count() {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
write_vars(|v| { write_vars(|v| {
v.set_var( v.set_var("arr", VarKind::arr_from_vec(vec!["a".into(), "b".into(), "c".into()]), VarFlags::NONE)
"arr", }).unwrap();
VarKind::arr_from_vec(vec!["a".into(), "b".into(), "c".into()]),
VarFlags::NONE,
)
})
.unwrap();
let elems = read_vars(|v| v.get_arr_elems("arr")).unwrap(); let elems = read_vars(|v| v.get_arr_elems("arr")).unwrap();
assert_eq!(elems.len(), 3); assert_eq!(elems.len(), 3);
@@ -3952,9 +3525,7 @@ mod tests {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
let dummy_span = Span::default(); let dummy_span = Span::default();
crate::state::SHED.with(|s| { crate::state::SHED.with(|s| {
s.logic s.logic.borrow_mut().insert_alias("ll", "ls -la", dummy_span.clone());
.borrow_mut()
.insert_alias("ll", "ls -la", dummy_span.clone());
}); });
let log_tab = crate::state::SHED.with(|s| s.logic.borrow().clone()); let log_tab = crate::state::SHED.with(|s| s.logic.borrow().clone());
@@ -3967,9 +3538,7 @@ mod tests {
let _guard = TestGuard::new(); let _guard = TestGuard::new();
let dummy_span = Span::default(); let dummy_span = Span::default();
crate::state::SHED.with(|s| { crate::state::SHED.with(|s| {
s.logic s.logic.borrow_mut().insert_alias("foo", "foo --verbose", dummy_span.clone());
.borrow_mut()
.insert_alias("foo", "foo --verbose", dummy_span.clone());
}); });
let log_tab = crate::state::SHED.with(|s| s.logic.borrow().clone()); let log_tab = crate::state::SHED.with(|s| s.logic.borrow().clone());
@@ -3981,47 +3550,26 @@ mod tests {
// ===================== Direct Input Tests (TestGuard) ===================== // ===================== Direct Input Tests (TestGuard) =====================
#[test] #[test]
fn index_simple() { fn index_simple() {
let guard = TestGuard::new(); let guard = TestGuard::new();
write_vars(|v| { write_vars(|v| v.set_var("arr", VarKind::Arr(VecDeque::from(["foo".into(), "bar".into(), "biz".into()])), VarFlags::NONE)).unwrap();
v.set_var(
"arr",
VarKind::Arr(VecDeque::from(["foo".into(), "bar".into(), "biz".into()])),
VarFlags::NONE,
)
})
.unwrap();
test_input("echo $arr").unwrap(); test_input("echo $arr").unwrap();
let out = guard.read_output(); let out = guard.read_output();
assert_eq!(out, "foo bar biz\n"); assert_eq!(out, "foo bar biz\n");
} }
#[test] #[test]
fn index_cursed() { fn index_cursed() {
let guard = TestGuard::new(); let guard = TestGuard::new();
write_vars(|v| { write_vars(|v| v.set_var("arr", VarKind::Arr(VecDeque::from(["foo".into(), "bar".into(), "biz".into()])), VarFlags::NONE)).unwrap();
v.set_var( write_vars(|v| v.set_var("i", VarKind::Arr(VecDeque::from(["0".into(), "1".into(), "2".into()])), VarFlags::NONE)).unwrap();
"arr",
VarKind::Arr(VecDeque::from(["foo".into(), "bar".into(), "biz".into()])),
VarFlags::NONE,
)
})
.unwrap();
write_vars(|v| {
v.set_var(
"i",
VarKind::Arr(VecDeque::from(["0".into(), "1".into(), "2".into()])),
VarFlags::NONE,
)
})
.unwrap();
test_input("echo $echo ${var:-${arr[$(($(echo ${i[0]}) + 1))]}}").unwrap(); test_input("echo $echo ${var:-${arr[$(($(echo ${i[0]}) + 1))]}}").unwrap();
let out = guard.read_output(); let out = guard.read_output();
assert_eq!(out, "bar\n"); assert_eq!(out, "bar\n");
} }
} }

293
src/getopt.rs
View File

@@ -3,11 +3,7 @@ use std::sync::Arc;
use ariadne::Fmt; use ariadne::Fmt;
use fmt::Display; use fmt::Display;
use crate::{ use crate::{libsh::error::{ShErr, ShErrKind, ShResult, next_color}, parse::lex::Tk, prelude::*};
libsh::error::{ShErr, ShErrKind, ShResult, next_color},
parse::lex::Tk,
prelude::*,
};
pub type OptSet = Arc<[Opt]>; pub type OptSet = Arc<[Opt]>;
@@ -73,36 +69,30 @@ pub fn get_opts(words: Vec<String>) -> (Vec<String>, Vec<Opt>) {
} }
pub fn get_opts_from_tokens_strict( pub fn get_opts_from_tokens_strict(
tokens: Vec<Tk>, tokens: Vec<Tk>,
opt_specs: &[OptSpec], opt_specs: &[OptSpec],
) -> ShResult<(Vec<Tk>, Vec<Opt>)> { ) -> ShResult<(Vec<Tk>, Vec<Opt>)> {
sort_tks(tokens, opt_specs, true) sort_tks(tokens, opt_specs, true)
} }
pub fn get_opts_from_tokens( pub fn get_opts_from_tokens(
tokens: Vec<Tk>, tokens: Vec<Tk>,
opt_specs: &[OptSpec], opt_specs: &[OptSpec],
) -> ShResult<(Vec<Tk>, Vec<Opt>)> { ) -> ShResult<(Vec<Tk>, Vec<Opt>)> {
sort_tks(tokens, opt_specs, false) sort_tks(tokens, opt_specs, false)
} }
pub fn sort_tks( pub fn sort_tks(tokens: Vec<Tk>, opt_specs: &[OptSpec], strict: bool) -> ShResult<(Vec<Tk>, Vec<Opt>)> {
tokens: Vec<Tk>,
opt_specs: &[OptSpec],
strict: bool,
) -> ShResult<(Vec<Tk>, Vec<Opt>)> {
let mut tokens_iter = tokens let mut tokens_iter = tokens
.into_iter() .into_iter()
.map(|t| t.expand()) .map(|t| t.expand())
.collect::<ShResult<Vec<_>>>()? .collect::<ShResult<Vec<_>>>()?
.into_iter() .into_iter();
.peekable();
let mut opts = vec![]; let mut opts = vec![];
let mut non_opts = vec![]; let mut non_opts = vec![];
while let Some(token) = tokens_iter.next() { while let Some(token) = tokens_iter.next() {
if &token.to_string() == "--" { if &token.to_string() == "--" {
non_opts.push(token);
non_opts.extend(tokens_iter); non_opts.extend(tokens_iter);
break; break;
} }
@@ -135,14 +125,14 @@ pub fn sort_tks(
} }
} }
if !pushed { if !pushed {
if strict { if strict {
return Err(ShErr::simple( return Err(ShErr::simple(
ShErrKind::ParseErr, ShErrKind::ParseErr,
format!("Unknown option: {}", opt.to_string().fg(next_color())), format!("Unknown option: {}", opt.to_string().fg(next_color())),
)); ));
} else { } else {
non_opts.push(token.clone()); non_opts.push(token.clone());
} }
} }
} }
} }
@@ -150,11 +140,12 @@ pub fn sort_tks(
Ok((non_opts, opts)) Ok((non_opts, opts))
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::parse::lex::{LexFlags, LexStream}; use crate::parse::lex::{LexFlags, LexStream};
use super::*; use super::*;
#[test] #[test]
fn parse_short_single() { fn parse_short_single() {
@@ -165,10 +156,7 @@ mod tests {
#[test] #[test]
fn parse_short_combined() { fn parse_short_combined() {
let opts = Opt::parse("-abc"); let opts = Opt::parse("-abc");
assert_eq!( assert_eq!(opts, vec![Opt::Short('a'), Opt::Short('b'), Opt::Short('c')]);
opts,
vec![Opt::Short('a'), Opt::Short('b'), Opt::Short('c')]
);
} }
#[test] #[test]
@@ -185,12 +173,7 @@ mod tests {
#[test] #[test]
fn get_opts_basic() { fn get_opts_basic() {
let words = vec![ let words = vec!["file.txt".into(), "-v".into(), "--help".into(), "arg".into()];
"file.txt".into(),
"-v".into(),
"--help".into(),
"arg".into(),
];
let (non_opts, opts) = get_opts(words); let (non_opts, opts) = get_opts(words);
assert_eq!(non_opts, vec!["file.txt", "arg"]); assert_eq!(non_opts, vec!["file.txt", "arg"]);
assert_eq!(opts, vec![Opt::Short('v'), Opt::Long("help".into())]); assert_eq!(opts, vec![Opt::Short('v'), Opt::Long("help".into())]);
@@ -208,10 +191,7 @@ mod tests {
fn get_opts_combined_short() { fn get_opts_combined_short() {
let words = vec!["-abc".into(), "file".into()]; let words = vec!["-abc".into(), "file".into()];
let (non_opts, opts) = get_opts(words); let (non_opts, opts) = get_opts(words);
assert_eq!( assert_eq!(opts, vec![Opt::Short('a'), Opt::Short('b'), Opt::Short('c')]);
opts,
vec![Opt::Short('a'), Opt::Short('b'), Opt::Short('c')]
);
assert_eq!(non_opts, vec!["file"]); assert_eq!(non_opts, vec!["file"]);
} }
@@ -235,175 +215,128 @@ mod tests {
assert_eq!(Opt::Short('v').to_string(), "-v"); assert_eq!(Opt::Short('v').to_string(), "-v");
assert_eq!(Opt::Long("help".into()).to_string(), "--help"); assert_eq!(Opt::Long("help".into()).to_string(), "--help");
assert_eq!(Opt::ShortWithArg('o', "file".into()).to_string(), "-o file"); assert_eq!(Opt::ShortWithArg('o', "file".into()).to_string(), "-o file");
assert_eq!( assert_eq!(Opt::LongWithArg("output".into(), "file".into()).to_string(), "--output file");
Opt::LongWithArg("output".into(), "file".into()).to_string(),
"--output file"
);
} }
fn lex(input: &str) -> Vec<Tk> { fn lex(input: &str) -> Vec<Tk> {
LexStream::new(Arc::new(input.to_string()), LexFlags::empty()) LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
.collect::<ShResult<Vec<Tk>>>() .collect::<ShResult<Vec<Tk>>>()
.unwrap() .unwrap()
} }
#[test] #[test]
fn get_opts_from_tks() { fn get_opts_from_tks() {
let tokens = lex("file.txt --help -v arg"); let tokens = lex("file.txt --help -v arg");
let opt_spec = vec![ let opt_spec = vec![
OptSpec { OptSpec { opt: Opt::Short('v'), takes_arg: false },
opt: Opt::Short('v'), OptSpec { opt: Opt::Long("help".into()), takes_arg: false },
takes_arg: false, ];
},
OptSpec {
opt: Opt::Long("help".into()),
takes_arg: false,
},
];
let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap(); let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap();
let mut opts = opts.into_iter(); let mut opts = opts.into_iter();
assert!(opts.any(|o| o == Opt::Short('v') || o == Opt::Long("help".into()))); assert!(opts.any(|o| o == Opt::Short('v') || o == Opt::Long("help".into())));
assert!(opts.any(|o| o == Opt::Short('v') || o == Opt::Long("help".into()))); assert!(opts.any(|o| o == Opt::Short('v') || o == Opt::Long("help".into())));
let mut non_opts = non_opts.into_iter().map(|s| s.to_string()); let mut non_opts = non_opts.into_iter().map(|s| s.to_string());
assert!(non_opts.any(|s| s == "file.txt" || s == "arg")); assert!(non_opts.any(|s| s == "file.txt" || s == "arg"));
assert!(non_opts.any(|s| s == "file.txt" || s == "arg")); assert!(non_opts.any(|s| s == "file.txt" || s == "arg"));
} }
#[test] #[test]
fn tks_short_with_arg() { fn tks_short_with_arg() {
let tokens = lex("-o output.txt file.txt"); let tokens = lex("-o output.txt file.txt");
let opt_spec = vec![OptSpec { let opt_spec = vec![
opt: Opt::Short('o'), OptSpec { opt: Opt::Short('o'), takes_arg: true },
takes_arg: true, ];
}];
let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap(); let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap();
assert_eq!(opts, vec![Opt::ShortWithArg('o', "output.txt".into())]); assert_eq!(opts, vec![Opt::ShortWithArg('o', "output.txt".into())]);
let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect(); let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect();
assert!(non_opts.contains(&"file.txt".to_string())); assert!(non_opts.contains(&"file.txt".to_string()));
} }
#[test] #[test]
fn tks_long_with_arg() { fn tks_long_with_arg() {
let tokens = lex("--output result.txt input.txt"); let tokens = lex("--output result.txt input.txt");
let opt_spec = vec![OptSpec { let opt_spec = vec![
opt: Opt::Long("output".into()), OptSpec { opt: Opt::Long("output".into()), takes_arg: true },
takes_arg: true, ];
}];
let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap(); let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap();
assert_eq!( assert_eq!(opts, vec![Opt::LongWithArg("output".into(), "result.txt".into())]);
opts, let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect();
vec![Opt::LongWithArg("output".into(), "result.txt".into())] assert!(non_opts.contains(&"input.txt".to_string()));
); }
let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect();
assert!(non_opts.contains(&"input.txt".to_string()));
}
#[test] #[test]
fn tks_double_dash_stops() { fn tks_double_dash_stops() {
let tokens = lex("-v -- -a --foo"); let tokens = lex("-v -- -a --foo");
let opt_spec = vec![ let opt_spec = vec![
OptSpec { OptSpec { opt: Opt::Short('v'), takes_arg: false },
opt: Opt::Short('v'), OptSpec { opt: Opt::Short('a'), takes_arg: false },
takes_arg: false, ];
},
OptSpec {
opt: Opt::Short('a'),
takes_arg: false,
},
];
let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap(); let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap();
assert_eq!(opts, vec![Opt::Short('v')]); assert_eq!(opts, vec![Opt::Short('v')]);
let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect(); let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect();
assert!(non_opts.contains(&"-a".to_string())); assert!(non_opts.contains(&"-a".to_string()));
assert!(non_opts.contains(&"--foo".to_string())); assert!(non_opts.contains(&"--foo".to_string()));
} }
#[test] #[test]
fn tks_combined_short_with_spec() { fn tks_combined_short_with_spec() {
let tokens = lex("-abc"); let tokens = lex("-abc");
let opt_spec = vec![ let opt_spec = vec![
OptSpec { OptSpec { opt: Opt::Short('a'), takes_arg: false },
opt: Opt::Short('a'), OptSpec { opt: Opt::Short('b'), takes_arg: false },
takes_arg: false, OptSpec { opt: Opt::Short('c'), takes_arg: false },
}, ];
OptSpec {
opt: Opt::Short('b'),
takes_arg: false,
},
OptSpec {
opt: Opt::Short('c'),
takes_arg: false,
},
];
let (_non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap(); let (_non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap();
assert_eq!( assert_eq!(opts, vec![Opt::Short('a'), Opt::Short('b'), Opt::Short('c')]);
opts, }
vec![Opt::Short('a'), Opt::Short('b'), Opt::Short('c')]
);
}
#[test] #[test]
fn tks_unknown_opt_becomes_non_opt() { fn tks_unknown_opt_becomes_non_opt() {
let tokens = lex("-v -x file"); let tokens = lex("-v -x file");
let opt_spec = vec![OptSpec { let opt_spec = vec![
opt: Opt::Short('v'), OptSpec { opt: Opt::Short('v'), takes_arg: false },
takes_arg: false, ];
}];
let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap(); let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap();
assert_eq!(opts, vec![Opt::Short('v')]); assert_eq!(opts, vec![Opt::Short('v')]);
// -x is not in spec, so its token goes to non_opts // -x is not in spec, so its token goes to non_opts
assert!( assert!(non_opts.into_iter().map(|s| s.to_string()).any(|s| s == "-x" || s == "file"));
non_opts }
.into_iter()
.map(|s| s.to_string())
.any(|s| s == "-x" || s == "file")
);
}
#[test] #[test]
fn tks_mixed_short_and_long_with_args() { fn tks_mixed_short_and_long_with_args() {
let tokens = lex("-n 5 --output file.txt input"); let tokens = lex("-n 5 --output file.txt input");
let opt_spec = vec![ let opt_spec = vec![
OptSpec { OptSpec { opt: Opt::Short('n'), takes_arg: true },
opt: Opt::Short('n'), OptSpec { opt: Opt::Long("output".into()), takes_arg: true },
takes_arg: true, ];
},
OptSpec {
opt: Opt::Long("output".into()),
takes_arg: true,
},
];
let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap(); let (non_opts, opts) = get_opts_from_tokens(tokens, &opt_spec).unwrap();
assert_eq!( assert_eq!(opts, vec![
opts, Opt::ShortWithArg('n', "5".into()),
vec![ Opt::LongWithArg("output".into(), "file.txt".into()),
Opt::ShortWithArg('n', "5".into()), ]);
Opt::LongWithArg("output".into(), "file.txt".into()), let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect();
] assert!(non_opts.contains(&"input".to_string()));
); }
let non_opts: Vec<String> = non_opts.into_iter().map(|s| s.to_string()).collect();
assert!(non_opts.contains(&"input".to_string()));
}
} }

51
src/jobs.rs
View File

@@ -1,7 +1,4 @@
use std::collections::VecDeque;
use ariadne::Fmt; use ariadne::Fmt;
use nix::unistd::getpid;
use scopeguard::defer; use scopeguard::defer;
use yansi::Color; use yansi::Color;
@@ -13,7 +10,7 @@ use crate::{
prelude::*, prelude::*,
procio::{IoMode, borrow_fd}, procio::{IoMode, borrow_fd},
signal::{disable_reaping, enable_reaping}, signal::{disable_reaping, enable_reaping},
state::{self, ShellParam, Var, VarFlags, VarKind, set_status, write_jobs, write_vars}, state::{self, ShellParam, set_status, write_jobs, write_vars},
}; };
pub const SIG_EXIT_OFFSET: i32 = 128; pub const SIG_EXIT_OFFSET: i32 = 128;
@@ -599,29 +596,6 @@ impl Job {
.map(|chld| chld.stat()) .map(|chld| chld.stat())
.collect::<Vec<WtStat>>() .collect::<Vec<WtStat>>()
} }
pub fn pipe_status(stats: &[WtStat]) -> Option<Vec<i32>> {
if stats.iter().any(|stat| {
matches!(
stat,
WtStat::StillAlive | WtStat::Continued(_) | WtStat::PtraceSyscall(_)
)
}) || stats.len() <= 1
{
return None;
}
Some(
stats
.iter()
.map(|stat| match stat {
WtStat::Exited(_, code) => *code,
WtStat::Signaled(_, signal, _) => SIG_EXIT_OFFSET + *signal as i32,
WtStat::Stopped(_, signal) => SIG_EXIT_OFFSET + *signal as i32,
WtStat::PtraceEvent(_, signal, _) => SIG_EXIT_OFFSET + *signal as i32,
WtStat::PtraceSyscall(_) | WtStat::Continued(_) | WtStat::StillAlive => unreachable!(),
})
.collect(),
)
}
pub fn get_pids(&self) -> Vec<Pid> { pub fn get_pids(&self) -> Vec<Pid> {
self self
.children .children
@@ -865,35 +839,22 @@ pub fn wait_fg(job: Job, interactive: bool) -> ShResult<()> {
enable_reaping(); enable_reaping();
} }
let statuses = write_jobs(|j| j.new_fg(job))?; let statuses = write_jobs(|j| j.new_fg(job))?;
for status in &statuses { for status in statuses {
code = code_from_status(status).unwrap_or(0); code = code_from_status(&status).unwrap_or(0);
match status { match status {
WtStat::Stopped(_, _) => { WtStat::Stopped(_, _) => {
was_stopped = true; was_stopped = true;
write_jobs(|j| j.fg_to_bg(*status))?; write_jobs(|j| j.fg_to_bg(status))?;
} }
WtStat::Signaled(_, sig, _) => { WtStat::Signaled(_, sig, _) => {
if *sig == Signal::SIGINT { if sig == Signal::SIGTSTP {
// interrupt propagates to the shell
// necessary for interrupting stuff like
// while/for loops
kill(getpid(), Signal::SIGINT)?;
} else if *sig == Signal::SIGTSTP {
was_stopped = true; was_stopped = true;
write_jobs(|j| j.fg_to_bg(*status))?; write_jobs(|j| j.fg_to_bg(status))?;
} }
} }
_ => { /* Do nothing */ } _ => { /* Do nothing */ }
} }
} }
if let Some(pipe_status) = Job::pipe_status(&statuses) {
let pipe_status = pipe_status
.into_iter()
.map(|s| s.to_string())
.collect::<VecDeque<String>>();
write_vars(|v| v.set_var("PIPESTATUS", VarKind::Arr(pipe_status), VarFlags::NONE))?;
}
// If job wasn't stopped (moved to bg), clear the fg slot // If job wasn't stopped (moved to bg), clear the fg slot
if !was_stopped { if !was_stopped {
write_jobs(|j| { write_jobs(|j| {

13
src/libsh/error.rs
View File

@@ -1,10 +1,10 @@
use ariadne::{Color, Fmt}; use ariadne::{Color, Fmt};
use ariadne::{Report, ReportKind}; use ariadne::{Report, ReportKind};
use rand::TryRng; use rand::TryRng;
use yansi::Paint;
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::{HashMap, VecDeque}; use std::collections::{HashMap, VecDeque};
use std::fmt::Display; use std::fmt::Display;
use yansi::Paint;
use crate::procio::RedirGuard; use crate::procio::RedirGuard;
use crate::{ use crate::{
@@ -150,7 +150,7 @@ impl Display for Note {
writeln!(f, "{note}: {main}")?; writeln!(f, "{note}: {main}")?;
} else { } else {
let bar_break = Fmt::fg("-", Color::Cyan); let bar_break = Fmt::fg("-", Color::Cyan);
let bar_break = bar_break.bold(); let bar_break = bar_break.bold();
let indent = " ".repeat(self.depth); let indent = " ".repeat(self.depth);
writeln!(f, " {indent}{bar_break} {main}")?; writeln!(f, " {indent}{bar_break} {main}")?;
} }
@@ -201,7 +201,6 @@ impl ShErr {
pub fn is_flow_control(&self) -> bool { pub fn is_flow_control(&self) -> bool {
self.kind.is_flow_control() self.kind.is_flow_control()
} }
/// Promotes a shell error from a simple error to an error that blames a span
pub fn promote(mut self, span: Span) -> Self { pub fn promote(mut self, span: Span) -> Self {
if self.notes.is_empty() { if self.notes.is_empty() {
return self; return self;
@@ -209,8 +208,6 @@ impl ShErr {
let first = self.notes[0].clone(); let first = self.notes[0].clone();
if self.notes.len() > 1 { if self.notes.len() > 1 {
self.notes = self.notes[1..].to_vec(); self.notes = self.notes[1..].to_vec();
} else {
self.notes = vec![];
} }
self.labeled(span, first) self.labeled(span, first)
@@ -459,7 +456,7 @@ pub enum ShErrKind {
FuncReturn(i32), FuncReturn(i32),
LoopContinue(i32), LoopContinue(i32),
LoopBreak(i32), LoopBreak(i32),
Interrupt, ClearReadline,
Null, Null,
} }
@@ -471,7 +468,7 @@ impl ShErrKind {
| Self::FuncReturn(_) | Self::FuncReturn(_)
| Self::LoopContinue(_) | Self::LoopContinue(_)
| Self::LoopBreak(_) | Self::LoopBreak(_)
| Self::Interrupt | Self::ClearReadline
) )
} }
} }
@@ -496,7 +493,7 @@ impl Display for ShErrKind {
Self::LoopBreak(_) => "Syntax Error", Self::LoopBreak(_) => "Syntax Error",
Self::ReadlineErr => "Readline Error", Self::ReadlineErr => "Readline Error",
Self::ExCommand => "Ex Command Error", Self::ExCommand => "Ex Command Error",
Self::Interrupt => "", Self::ClearReadline => "",
Self::Null => "", Self::Null => "",
}; };
write!(f, "{output}") write!(f, "{output}")

14
src/libsh/guards.rs
View File

@@ -3,7 +3,7 @@ use std::collections::HashSet;
use std::os::fd::{BorrowedFd, RawFd}; use std::os::fd::{BorrowedFd, RawFd};
use nix::sys::termios::{self, LocalFlags, Termios, tcgetattr, tcsetattr}; use nix::sys::termios::{self, LocalFlags, Termios, tcgetattr, tcsetattr};
use nix::unistd::{isatty, write}; use nix::unistd::isatty;
use scopeguard::guard; use scopeguard::guard;
thread_local! { thread_local! {
@@ -147,10 +147,11 @@ impl RawModeGuard {
let orig = ORIG_TERMIOS let orig = ORIG_TERMIOS
.with(|cell| cell.borrow().clone()) .with(|cell| cell.borrow().clone())
.expect("with_cooked_mode called before raw_mode()"); .expect("with_cooked_mode called before raw_mode()");
tcsetattr(borrow_fd(*TTY_FILENO), termios::SetArg::TCSANOW, &orig).ok(); tcsetattr(borrow_fd(*TTY_FILENO), termios::SetArg::TCSANOW, &orig)
.expect("Failed to restore cooked mode");
let res = f(); let res = f();
tcsetattr(borrow_fd(*TTY_FILENO), termios::SetArg::TCSANOW, &current).ok(); tcsetattr(borrow_fd(*TTY_FILENO), termios::SetArg::TCSANOW, &current)
unsafe { write(BorrowedFd::borrow_raw(*TTY_FILENO), b"\x1b[?1l\x1b>").ok() }; .expect("Failed to restore raw mode");
res res
} }
} }
@@ -158,12 +159,11 @@ impl RawModeGuard {
impl Drop for RawModeGuard { impl Drop for RawModeGuard {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
termios::tcsetattr( let _ = termios::tcsetattr(
BorrowedFd::borrow_raw(self.fd), BorrowedFd::borrow_raw(self.fd),
termios::SetArg::TCSANOW, termios::SetArg::TCSANOW,
&self.orig, &self.orig,
) );
.ok();
} }
} }
} }

11
src/libsh/sys.rs
View File

@@ -2,15 +2,6 @@ use std::sync::LazyLock;
use crate::prelude::*; use crate::prelude::*;
/// Minimum fd number for shell-internal file descriptors.
const MIN_INTERNAL_FD: RawFd = 10;
pub static TTY_FILENO: LazyLock<RawFd> = LazyLock::new(|| { pub static TTY_FILENO: LazyLock<RawFd> = LazyLock::new(|| {
let fd = open("/dev/tty", OFlag::O_RDWR, Mode::empty()).expect("Failed to open /dev/tty"); open("/dev/tty", OFlag::O_RDWR, Mode::empty()).expect("Failed to open /dev/tty")
// Move the tty fd above the user-accessible range so that
// `exec 3>&-` and friends don't collide with shell internals.
let high =
fcntl(fd, FcntlArg::F_DUPFD_CLOEXEC(MIN_INTERNAL_FD)).expect("Failed to dup /dev/tty high");
close(fd).ok();
high
}); });

142
src/main.rs
View File

@@ -38,18 +38,15 @@ use crate::prelude::*;
use crate::procio::borrow_fd; use crate::procio::borrow_fd;
use crate::readline::term::{LineWriter, RawModeGuard, raw_mode}; use crate::readline::term::{LineWriter, RawModeGuard, raw_mode};
use crate::readline::{Prompt, ReadlineEvent, ShedVi}; use crate::readline::{Prompt, ReadlineEvent, ShedVi};
use crate::signal::{ use crate::signal::{GOT_SIGWINCH, JOB_DONE, QUIT_CODE, check_signals, sig_setup, signals_pending};
GOT_SIGUSR1, GOT_SIGWINCH, JOB_DONE, QUIT_CODE, check_signals, sig_setup, signals_pending, use crate::state::{AutoCmdKind, read_logic, read_shopts, source_rc, write_jobs, write_meta};
};
use crate::state::{
AutoCmdKind, read_logic, read_shopts, source_env, source_login, source_rc, write_jobs,
write_meta, write_shopts,
};
use clap::Parser; use clap::Parser;
use state::write_vars; use state::{read_vars, write_vars};
#[derive(Parser, Debug)] #[derive(Parser, Debug)]
struct ShedArgs { struct ShedArgs {
script: Option<String>,
#[arg(short)] #[arg(short)]
command: Option<String>, command: Option<String>,
@@ -62,13 +59,24 @@ struct ShedArgs {
#[arg(short)] #[arg(short)]
interactive: bool, interactive: bool,
#[arg(short)]
stdin: bool,
#[arg(long, short)] #[arg(long, short)]
login_shell: bool, login_shell: bool,
} }
/// Force evaluation of lazily-initialized values early in shell startup.
///
/// In particular, this ensures that the variable table is initialized, which
/// populates environment variables from the system. If this initialization is
/// deferred too long, features like prompt expansion may fail due to missing
/// environment variables.
///
/// This function triggers initialization by calling `read_vars` with a no-op
/// closure, which forces access to the variable table and causes its `LazyLock`
/// constructor to run.
fn kickstart_lazy_evals() {
read_vars(|_| {});
}
/// We need to make sure that even if we panic, our child processes get sighup /// We need to make sure that even if we panic, our child processes get sighup
fn setup_panic_handler() { fn setup_panic_handler() {
let default_panic_hook = std::panic::take_hook(); let default_panic_hook = std::panic::take_hook();
@@ -103,6 +111,7 @@ fn setup_panic_handler() {
fn main() -> ExitCode { fn main() -> ExitCode {
yansi::enable(); yansi::enable();
env_logger::init(); env_logger::init();
kickstart_lazy_evals();
setup_panic_handler(); setup_panic_handler();
let mut args = ShedArgs::parse(); let mut args = ShedArgs::parse();
@@ -121,31 +130,14 @@ fn main() -> ExitCode {
return ExitCode::SUCCESS; return ExitCode::SUCCESS;
} }
// Increment SHLVL, or set to 1 if not present or invalid. if let Err(e) = if let Some(path) = args.script {
// This var represents how many nested shell instances we're in
if let Ok(var) = env::var("SHLVL")
&& let Ok(lvl) = var.parse::<u32>()
{
unsafe { env::set_var("SHLVL", (lvl + 1).to_string()) };
} else {
unsafe { env::set_var("SHLVL", "1") };
}
if let Err(e) = source_env() {
e.print_error();
}
if let Err(e) = if let Some(cmd) = args.command {
exec_dash_c(cmd)
} else if args.stdin || !isatty(STDIN_FILENO).unwrap_or(false) {
read_commands(args.script_args)
} else if !args.script_args.is_empty() {
let path = args.script_args.remove(0);
run_script(path, args.script_args) run_script(path, args.script_args)
} else if let Some(cmd) = args.command {
exec_dash_c(cmd)
} else { } else {
let res = shed_interactive(args); let res = shed_interactive(args);
write(borrow_fd(*TTY_FILENO), b"\x1b[?2004l").ok(); // disable bracketed paste mode on exit write(borrow_fd(*TTY_FILENO), b"\x1b[?2004l").ok(); // disable bracketed paste mode on exit
res res
} { } {
e.print_error(); e.print_error();
}; };
@@ -163,32 +155,6 @@ fn main() -> ExitCode {
ExitCode::from(QUIT_CODE.load(Ordering::SeqCst) as u8) ExitCode::from(QUIT_CODE.load(Ordering::SeqCst) as u8)
} }
fn read_commands(args: Vec<String>) -> ShResult<()> {
let mut input = vec![];
let mut read_buf = [0u8; 4096];
loop {
match read(STDIN_FILENO, &mut read_buf) {
Ok(0) => break,
Ok(n) => input.extend_from_slice(&read_buf[..n]),
Err(Errno::EINTR) => continue,
Err(e) => {
QUIT_CODE.store(1, Ordering::SeqCst);
return Err(ShErr::simple(
ShErrKind::CleanExit(1),
format!("error reading from stdin: {e}"),
));
}
}
}
let commands = String::from_utf8_lossy(&input).to_string();
for arg in args {
write_vars(|v| v.cur_scope_mut().bpush_arg(arg))
}
exec_input(commands, None, false, None)
}
fn run_script<P: AsRef<Path>>(path: P, args: Vec<String>) -> ShResult<()> { fn run_script<P: AsRef<Path>>(path: P, args: Vec<String>) -> ShResult<()> {
let path = path.as_ref(); let path = path.as_ref();
let path_raw = path.to_string_lossy().to_string(); let path_raw = path.to_string_lossy().to_string();
@@ -224,12 +190,6 @@ fn shed_interactive(args: ShedArgs) -> ShResult<()> {
let _raw_mode = raw_mode(); // sets raw mode, restores termios on drop let _raw_mode = raw_mode(); // sets raw mode, restores termios on drop
sig_setup(args.login_shell); sig_setup(args.login_shell);
if args.login_shell
&& let Err(e) = source_login()
{
e.print_error();
}
if let Err(e) = source_rc() { if let Err(e) = source_rc() {
e.print_error(); e.print_error();
} }
@@ -247,7 +207,7 @@ fn shed_interactive(args: ShedArgs) -> ShResult<()> {
} }
}; };
readline.writer.flush_write("\x1b[?2004h")?; // enable bracketed paste mode readline.writer.flush_write("\x1b[?2004h")?; // enable bracketed paste mode
// Main poll loop // Main poll loop
loop { loop {
@@ -261,14 +221,14 @@ fn shed_interactive(args: ShedArgs) -> ShResult<()> {
while signals_pending() { while signals_pending() {
if let Err(e) = check_signals() { if let Err(e) = check_signals() {
match e.kind() { match e.kind() {
ShErrKind::Interrupt => { ShErrKind::ClearReadline => {
// We got Ctrl+C - clear current input and redraw // We got Ctrl+C - clear current input and redraw
readline.reset_active_widget(false)?; readline.reset_active_widget(false)?;
} }
ShErrKind::CleanExit(code) => { ShErrKind::CleanExit(code) => {
QUIT_CODE.store(*code, Ordering::SeqCst); QUIT_CODE.store(*code, Ordering::SeqCst);
return Ok(()); return Ok(());
} }
_ => e.print_error(), _ => e.print_error(),
} }
} }
@@ -287,53 +247,22 @@ fn shed_interactive(args: ShedArgs) -> ShResult<()> {
readline.prompt_mut().refresh(); readline.prompt_mut().refresh();
} }
if GOT_SIGUSR1.swap(false, Ordering::SeqCst) {
log::info!("SIGUSR1 received: refreshing readline state");
readline.mark_dirty();
readline.prompt_mut().refresh();
}
readline.print_line(false)?; readline.print_line(false)?;
// Poll for // Poll for stdin input
// stdin input
let mut fds = [PollFd::new( let mut fds = [PollFd::new(
unsafe { BorrowedFd::borrow_raw(*TTY_FILENO) }, unsafe { BorrowedFd::borrow_raw(*TTY_FILENO) },
PollFlags::POLLIN, PollFlags::POLLIN,
)]; )];
let mut exec_if_timeout = None;
let timeout = if readline.pending_keymap.is_empty() { let timeout = if readline.pending_keymap.is_empty() {
let screensaver_cmd = read_shopts(|o| o.prompt.screensaver_cmd.clone()); PollTimeout::MAX
let screensaver_idle_time = read_shopts(|o| o.prompt.screensaver_idle_time);
if screensaver_idle_time > 0 && !screensaver_cmd.is_empty() {
exec_if_timeout = Some(screensaver_cmd);
PollTimeout::from((screensaver_idle_time * 1000) as u16)
} else {
PollTimeout::MAX
}
} else { } else {
PollTimeout::from(1000u16) PollTimeout::from(1000u16)
}; };
match poll(&mut fds, timeout) { match poll(&mut fds, timeout) {
Ok(0) => { Ok(_) => {}
// We timed out.
if let Some(cmd) = exec_if_timeout {
let prepared = ReadlineEvent::Line(cmd);
let saved_hist_opt = read_shopts(|o| o.core.auto_hist);
let _guard = scopeguard::guard(saved_hist_opt, |opt| {
write_shopts(|o| o.core.auto_hist = opt);
});
write_shopts(|o| o.core.auto_hist = false); // don't save screensaver command to history
match handle_readline_event(&mut readline, Ok(prepared))? {
true => return Ok(()),
false => continue,
}
}
}
Err(Errno::EINTR) => { Err(Errno::EINTR) => {
// Interrupted by signal, loop back to handle it // Interrupted by signal, loop back to handle it
continue; continue;
@@ -342,7 +271,6 @@ fn shed_interactive(args: ShedArgs) -> ShResult<()> {
eprintln!("poll error: {e}"); eprintln!("poll error: {e}");
break; break;
} }
Ok(_) => {}
} }
// Timeout — resolve pending keymap ambiguity // Timeout — resolve pending keymap ambiguity
@@ -444,10 +372,6 @@ fn handle_readline_event(readline: &mut ShedVi, event: ShResult<ReadlineEvent>)
}) { }) {
// CleanExit signals an intentional shell exit; any other error is printed. // CleanExit signals an intentional shell exit; any other error is printed.
match e.kind() { match e.kind() {
ShErrKind::Interrupt => {
// We got Ctrl+C during command execution
// Just fall through here
}
ShErrKind::CleanExit(code) => { ShErrKind::CleanExit(code) => {
QUIT_CODE.store(*code, Ordering::SeqCst); QUIT_CODE.store(*code, Ordering::SeqCst);
return Ok(true); return Ok(true);

288
src/parse/execute.rs
View File

@@ -8,30 +8,7 @@ use ariadne::Fmt;
use crate::{ use crate::{
builtin::{ builtin::{
alias::{alias, unalias}, alias::{alias, unalias}, arrops::{arr_fpop, arr_fpush, arr_pop, arr_push, arr_rotate}, autocmd::autocmd, cd::cd, complete::{compgen_builtin, complete_builtin}, dirstack::{dirs, popd, pushd}, echo::echo, eval, exec, flowctl::flowctl, getopts::getopts, intro, jobctl::{self, JobBehavior, continue_job, disown, jobs}, keymap, map, pwd::pwd, read::{self, read_builtin}, resource::{ulimit, umask_builtin}, shift::shift, shopt::shopt, source::source, test::double_bracket_test, trap::{TrapTarget, trap}, varcmds::{export, local, readonly, unset}
arrops::{arr_fpop, arr_fpush, arr_pop, arr_push, arr_rotate},
autocmd::autocmd,
cd::cd,
complete::{compgen_builtin, complete_builtin},
dirstack::{dirs, popd, pushd},
echo::echo,
eval, exec,
flowctl::flowctl,
getopts::getopts,
help::help,
intro,
jobctl::{self, JobBehavior, continue_job, disown, jobs},
keymap, map,
pwd::pwd,
read::{self, read_builtin},
resource::{ulimit, umask_builtin},
seek::seek,
shift::shift,
shopt::shopt,
source::source,
test::double_bracket_test,
trap::{TrapTarget, trap},
varcmds::{export, local, readonly, unset},
}, },
expand::{expand_aliases, expand_case_pattern, glob_to_regex}, expand::{expand_aliases, expand_case_pattern, glob_to_regex},
jobs::{ChildProc, JobStack, attach_tty, dispatch_job}, jobs::{ChildProc, JobStack, attach_tty, dispatch_job},
@@ -42,7 +19,6 @@ use crate::{
}, },
prelude::*, prelude::*,
procio::{IoMode, IoStack, PipeGenerator}, procio::{IoMode, IoStack, PipeGenerator},
signal::{check_signals, signals_pending},
state::{ state::{
self, ShFunc, VarFlags, VarKind, read_logic, read_shopts, write_jobs, write_logic, write_vars, self, ShFunc, VarFlags, VarKind, read_logic, read_shopts, write_jobs, write_logic, write_vars,
}, },
@@ -160,18 +136,13 @@ pub fn exec_dash_c(input: String) -> ShResult<()> {
if nodes.len() == 1 { if nodes.len() == 1 {
let is_single_cmd = match &nodes[0].class { let is_single_cmd = match &nodes[0].class {
NdRule::Command { .. } => true, NdRule::Command { .. } => true,
NdRule::Pipeline { cmds } => { NdRule::Pipeline { cmds } => cmds.len() == 1 && matches!(cmds[0].class, NdRule::Command { .. }),
cmds.len() == 1 && matches!(cmds[0].class, NdRule::Command { .. })
}
NdRule::Conjunction { elements } => { NdRule::Conjunction { elements } => {
elements.len() == 1 elements.len() == 1 && match &elements[0].cmd.class {
&& match &elements[0].cmd.class { NdRule::Pipeline { cmds } => cmds.len() == 1 && matches!(cmds[0].class, NdRule::Command { .. }),
NdRule::Pipeline { cmds } => { NdRule::Command { .. } => true,
cmds.len() == 1 && matches!(cmds[0].class, NdRule::Command { .. }) _ => false,
} }
NdRule::Command { .. } => true,
_ => false,
}
} }
_ => false, _ => false,
}; };
@@ -180,12 +151,8 @@ pub fn exec_dash_c(input: String) -> ShResult<()> {
let mut node = nodes.remove(0); let mut node = nodes.remove(0);
loop { loop {
match node.class { match node.class {
NdRule::Conjunction { mut elements } => { NdRule::Conjunction { mut elements } => { node = *elements.remove(0).cmd; }
node = *elements.remove(0).cmd; NdRule::Pipeline { mut cmds } => { node = cmds.remove(0); }
}
NdRule::Pipeline { mut cmds } => {
node = cmds.remove(0);
}
NdRule::Command { .. } => break, NdRule::Command { .. } => break,
_ => break, _ => break,
} }
@@ -274,13 +241,6 @@ impl Dispatcher {
Ok(()) Ok(())
} }
pub fn dispatch_node(&mut self, node: Node) -> ShResult<()> { pub fn dispatch_node(&mut self, node: Node) -> ShResult<()> {
while signals_pending() {
// If we have received SIGINT,
// this will stop the execution here
// and propagate back to the functions in main.rs
check_signals()?;
}
match node.class { match node.class {
NdRule::Conjunction { .. } => self.exec_conjunction(node)?, NdRule::Conjunction { .. } => self.exec_conjunction(node)?,
NdRule::Pipeline { .. } => self.exec_pipeline(node)?, NdRule::Pipeline { .. } => self.exec_pipeline(node)?,
@@ -290,7 +250,7 @@ impl Dispatcher {
NdRule::CaseNode { .. } => self.exec_case(node)?, NdRule::CaseNode { .. } => self.exec_case(node)?,
NdRule::BraceGrp { .. } => self.exec_brc_grp(node)?, NdRule::BraceGrp { .. } => self.exec_brc_grp(node)?,
NdRule::FuncDef { .. } => self.exec_func_def(node)?, NdRule::FuncDef { .. } => self.exec_func_def(node)?,
NdRule::Negate { .. } => self.exec_negated(node)?, NdRule::Negate { .. } => self.exec_negated(node)?,
NdRule::Command { .. } => self.dispatch_cmd(node)?, NdRule::Command { .. } => self.dispatch_cmd(node)?,
NdRule::Test { .. } => self.exec_test(node)?, NdRule::Test { .. } => self.exec_test(node)?,
_ => unreachable!(), _ => unreachable!(),
@@ -298,15 +258,6 @@ impl Dispatcher {
Ok(()) Ok(())
} }
pub fn dispatch_cmd(&mut self, node: Node) -> ShResult<()> { pub fn dispatch_cmd(&mut self, node: Node) -> ShResult<()> {
let (line, _) = node.get_span().clone().line_and_col();
write_vars(|v| {
v.set_var(
"LINENO",
VarKind::Str((line + 1).to_string()),
VarFlags::NONE,
)
})?;
let Some(cmd) = node.get_command() else { let Some(cmd) = node.get_command() else {
return self.exec_cmd(node); // Argv is empty, probably an assignment return self.exec_cmd(node); // Argv is empty, probably an assignment
}; };
@@ -334,35 +285,40 @@ impl Dispatcher {
self.exec_cmd(node) self.exec_cmd(node)
} }
} }
pub fn exec_negated(&mut self, node: Node) -> ShResult<()> { pub fn exec_negated(&mut self, node: Node) -> ShResult<()> {
let NdRule::Negate { cmd } = node.class else { let NdRule::Negate { cmd } = node.class else {
unreachable!() unreachable!()
}; };
self.dispatch_node(*cmd)?; self.dispatch_node(*cmd)?;
let status = state::get_status(); let status = state::get_status();
state::set_status(if status == 0 { 1 } else { 0 }); state::set_status(if status == 0 { 1 } else { 0 });
Ok(()) Ok(())
} }
pub fn exec_conjunction(&mut self, conjunction: Node) -> ShResult<()> { pub fn exec_conjunction(&mut self, conjunction: Node) -> ShResult<()> {
let NdRule::Conjunction { elements } = conjunction.class else { let NdRule::Conjunction { elements } = conjunction.class else {
unreachable!() unreachable!()
}; };
let mut elem_iter = elements.into_iter(); let mut elem_iter = elements.into_iter();
let mut skip = false;
while let Some(element) = elem_iter.next() { while let Some(element) = elem_iter.next() {
let ConjunctNode { cmd, operator } = element; let ConjunctNode { cmd, operator } = element;
if !skip { self.dispatch_node(*cmd)?;
self.dispatch_node(*cmd)?;
}
let status = state::get_status(); let status = state::get_status();
skip = match operator { match operator {
ConjunctOp::And => status != 0, ConjunctOp::And => {
ConjunctOp::Or => status == 0, if status != 0 {
break;
}
}
ConjunctOp::Or => {
if status == 0 {
break;
}
}
ConjunctOp::Null => break, ConjunctOp::Null => break,
}; }
} }
Ok(()) Ok(())
} }
@@ -382,11 +338,7 @@ impl Dispatcher {
}; };
let body_span = body.get_span(); let body_span = body.get_span();
let body = body_span.as_str().to_string(); let body = body_span.as_str().to_string();
let name = name let name = name.span.as_str().strip_suffix("()").unwrap();
.span
.as_str()
.strip_suffix("()")
.unwrap_or(name.span.as_str());
if KEYWORDS.contains(&name) { if KEYWORDS.contains(&name) {
return Err(ShErr::at( return Err(ShErr::at(
@@ -409,7 +361,7 @@ impl Dispatcher {
Ok(()) Ok(())
} }
fn exec_subsh(&mut self, subsh: Node) -> ShResult<()> { fn exec_subsh(&mut self, subsh: Node) -> ShResult<()> {
let _blame = subsh.get_span().clone(); let _blame = subsh.get_span().clone();
let NdRule::Command { assignments, argv } = subsh.class else { let NdRule::Command { assignments, argv } = subsh.class else {
unreachable!() unreachable!()
}; };
@@ -813,18 +765,7 @@ impl Dispatcher {
if cmds.len() == 1 { if cmds.len() == 1 {
self.fg_job = !is_bg && self.interactive; self.fg_job = !is_bg && self.interactive;
let cmd = cmds.into_iter().next().unwrap(); let cmd = cmds.into_iter().next().unwrap();
if is_bg && !matches!(cmd.class, NdRule::Command { .. }) { self.dispatch_node(cmd)?;
self.run_fork(
&cmd.get_command().map(|t| t.to_string()).unwrap_or_default(),
|s| {
if let Err(e) = s.dispatch_node(cmd) {
e.print_error();
}
},
)?;
} else {
self.dispatch_node(cmd)?;
}
// Give the pipeline terminal control as soon as the first child // Give the pipeline terminal control as soon as the first child
// establishes the PGID, so later children (e.g. nvim) don't get // establishes the PGID, so later children (e.g. nvim) don't get
@@ -897,10 +838,7 @@ impl Dispatcher {
if fork_builtins { if fork_builtins {
log::trace!("Forking builtin: {}", cmd_raw); log::trace!("Forking builtin: {}", cmd_raw);
let guard = self.io_stack.pop_frame().redirect()?; let _guard = self.io_stack.pop_frame().redirect()?;
if cmd_raw.as_str() == "exec" {
guard.persist();
}
self.run_fork(&cmd_raw, |s| { self.run_fork(&cmd_raw, |s| {
if let Err(e) = s.dispatch_builtin(cmd) { if let Err(e) = s.dispatch_builtin(cmd) {
e.print_error(); e.print_error();
@@ -1023,10 +961,8 @@ impl Dispatcher {
"keymap" => keymap::keymap(cmd), "keymap" => keymap::keymap(cmd),
"read_key" => read::read_key(cmd), "read_key" => read::read_key(cmd),
"autocmd" => autocmd(cmd), "autocmd" => autocmd(cmd),
"ulimit" => ulimit(cmd), "ulimit" => ulimit(cmd),
"umask" => umask_builtin(cmd), "umask" => umask_builtin(cmd),
"seek" => seek(cmd),
"help" => help(cmd),
"true" | ":" => { "true" | ":" => {
state::set_status(0); state::set_status(0);
Ok(()) Ok(())
@@ -1164,7 +1100,6 @@ impl Dispatcher {
match unsafe { fork()? } { match unsafe { fork()? } {
ForkResult::Child => { ForkResult::Child => {
let _ = setpgid(Pid::from_raw(0), existing_pgid.unwrap_or(Pid::from_raw(0))); let _ = setpgid(Pid::from_raw(0), existing_pgid.unwrap_or(Pid::from_raw(0)));
self.interactive = false;
f(self); f(self);
exit(state::get_status()) exit(state::get_status())
} }
@@ -1384,94 +1319,83 @@ mod tests {
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
// ===================== other stuff ===================== // ===================== other stuff =====================
#[test] #[test]
fn for_loop_var_zip() { fn for_loop_var_zip() {
let g = TestGuard::new(); let g = TestGuard::new();
test_input("for a b in 1 2 3 4 5 6; do echo $a $b; done").unwrap(); test_input("for a b in 1 2 3 4 5 6; do echo $a $b; done").unwrap();
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, "1 2\n3 4\n5 6\n"); assert_eq!(out, "1 2\n3 4\n5 6\n");
} }
#[test] #[test]
fn for_loop_unsets_zipped() { fn for_loop_unsets_zipped() {
let g = TestGuard::new(); let g = TestGuard::new();
test_input("for a b c d in 1 2 3 4 5 6; do echo $a $b $c $d; done").unwrap(); test_input("for a b c d in 1 2 3 4 5 6; do echo $a $b $c $d; done").unwrap();
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, "1 2 3 4\n5 6\n"); assert_eq!(out, "1 2 3 4\n5 6\n");
} }
// ===================== negation (!) status ===================== // ===================== negation (!) status =====================
#[test] #[test]
fn negate_true() { fn negate_true() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("! true").unwrap(); test_input("! true").unwrap();
assert_eq!(state::get_status(), 1); assert_eq!(state::get_status(), 1);
} }
#[test] #[test]
fn negate_false() { fn negate_false() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("! false").unwrap(); test_input("! false").unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
#[test] #[test]
fn double_negate_true() { fn double_negate_true() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("! ! true").unwrap(); test_input("! ! true").unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
#[test] #[test]
fn double_negate_false() { fn double_negate_false() {
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input("! ! false").unwrap(); test_input("! ! false").unwrap();
assert_eq!(state::get_status(), 1); assert_eq!(state::get_status(), 1);
} }
#[test] #[test]
fn negate_pipeline_last_cmd() { fn negate_pipeline_last_cmd() {
let _g = TestGuard::new(); let _g = TestGuard::new();
// pipeline status = last cmd (false) = 1, negated → 0 // pipeline status = last cmd (false) = 1, negated → 0
test_input("! true | false").unwrap(); test_input("! true | false").unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
#[test] #[test]
fn negate_pipeline_last_cmd_true() { fn negate_pipeline_last_cmd_true() {
let _g = TestGuard::new(); let _g = TestGuard::new();
// pipeline status = last cmd (true) = 0, negated → 1 // pipeline status = last cmd (true) = 0, negated → 1
test_input("! false | true").unwrap(); test_input("! false | true").unwrap();
assert_eq!(state::get_status(), 1); assert_eq!(state::get_status(), 1);
} }
#[test] #[test]
fn negate_in_conjunction() { fn negate_in_conjunction() {
let _g = TestGuard::new(); let _g = TestGuard::new();
// ! binds to pipeline, not conjunction: (! (true && false)) && true // ! binds to pipeline, not conjunction: (! (true && false)) && true
test_input("! (true && false) && true").unwrap(); test_input("! (true && false) && true").unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
} }
#[test] #[test]
fn negate_in_if_condition() { fn negate_in_if_condition() {
let g = TestGuard::new(); let g = TestGuard::new();
test_input("if ! false; then echo yes; fi").unwrap(); test_input("if ! false; then echo yes; fi").unwrap();
assert_eq!(state::get_status(), 0); assert_eq!(state::get_status(), 0);
assert_eq!(g.read_output(), "yes\n"); assert_eq!(g.read_output(), "yes\n");
} }
#[test]
fn empty_var_in_test() {
let _g = TestGuard::new();
// POSIX specifies that a quoted unset variable expands to an empty string, so the shell actually sees `[ -n "" ]`, which returns false
test_input("[ -n \"$EMPTYVAR_PROBABLY_NOT_SET_TO_ANYTHING\" ]").unwrap();
assert_eq!(state::get_status(), 1);
// Without quotes, word splitting causes an empty var to be removed entirely, so the shell actually sees `[ -n ]`, testing the value of ']', which returns true
test_input("[ -n $EMPTYVAR_PROBABLY_NOT_SET_TO_ANYTHING ]").unwrap();
assert_eq!(state::get_status(), 0);
}
} }

348
src/parse/lex.rs
View File

@@ -19,7 +19,7 @@ use crate::{
pub const KEYWORDS: [&str; 17] = [ pub const KEYWORDS: [&str; 17] = [
"if", "then", "elif", "else", "fi", "while", "until", "select", "for", "in", "do", "done", "if", "then", "elif", "else", "fi", "while", "until", "select", "for", "in", "do", "done",
"case", "esac", "[[", "]]", "!", "case", "esac", "[[", "]]", "!"
]; ];
pub const OPENERS: [&str; 6] = ["if", "while", "until", "for", "select", "case"]; pub const OPENERS: [&str; 6] = ["if", "while", "until", "for", "select", "case"];
@@ -166,7 +166,7 @@ pub enum TkRule {
ErrPipe, ErrPipe,
And, And,
Or, Or,
Bang, Bang,
Bg, Bg,
Sep, Sep,
Redir, Redir,
@@ -217,31 +217,6 @@ impl Tk {
}; };
self.span.as_str().trim() == ";;" self.span.as_str().trim() == ";;"
} }
pub fn is_opener(&self) -> bool {
OPENERS.contains(&self.as_str())
|| matches!(self.class, TkRule::BraceGrpStart)
|| matches!(self.class, TkRule::CasePattern)
}
pub fn is_closer(&self) -> bool {
matches!(self.as_str(), "fi" | "done" | "esac")
|| self.has_double_semi()
|| matches!(self.class, TkRule::BraceGrpEnd)
}
pub fn is_closer_for(&self, other: &Tk) -> bool {
if (matches!(other.class, TkRule::BraceGrpStart) && matches!(self.class, TkRule::BraceGrpEnd))
|| (matches!(other.class, TkRule::CasePattern) && self.has_double_semi())
{
return true;
}
match other.as_str() {
"for" | "while" | "until" => matches!(self.as_str(), "done"),
"if" => matches!(self.as_str(), "fi"),
"case" => matches!(self.as_str(), "esac"),
_ => false,
}
}
} }
impl Display for Tk { impl Display for Tk {
@@ -266,12 +241,20 @@ bitflags! {
const ASSIGN = 0b0000000001000000; const ASSIGN = 0b0000000001000000;
const BUILTIN = 0b0000000010000000; const BUILTIN = 0b0000000010000000;
const IS_PROCSUB = 0b0000000100000000; const IS_PROCSUB = 0b0000000100000000;
const IS_HEREDOC = 0b0000001000000000;
const LIT_HEREDOC = 0b0000010000000000;
const TAB_HEREDOC = 0b0000100000000000;
} }
} }
pub struct LexStream {
source: Arc<String>,
pub cursor: usize,
pub name: String,
quote_state: QuoteState,
brc_grp_depth: usize,
brc_grp_start: Option<usize>,
case_depth: usize,
flags: LexFlags,
}
bitflags! { bitflags! {
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
pub struct LexFlags: u32 { pub struct LexFlags: u32 {
@@ -313,18 +296,6 @@ pub fn clean_input(input: &str) -> String {
output output
} }
pub struct LexStream {
source: Arc<String>,
pub cursor: usize,
pub name: String,
quote_state: QuoteState,
brc_grp_depth: usize,
brc_grp_start: Option<usize>,
case_depth: usize,
heredoc_skip: Option<usize>,
flags: LexFlags,
}
impl LexStream { impl LexStream {
pub fn new(source: Arc<String>, flags: LexFlags) -> Self { pub fn new(source: Arc<String>, flags: LexFlags) -> Self {
let flags = flags | LexFlags::FRESH | LexFlags::NEXT_IS_CMD; let flags = flags | LexFlags::FRESH | LexFlags::NEXT_IS_CMD;
@@ -336,7 +307,6 @@ impl LexStream {
quote_state: QuoteState::default(), quote_state: QuoteState::default(),
brc_grp_depth: 0, brc_grp_depth: 0,
brc_grp_start: None, brc_grp_start: None,
heredoc_skip: None,
case_depth: 0, case_depth: 0,
} }
} }
@@ -397,7 +367,7 @@ impl LexStream {
} }
pub fn read_redir(&mut self) -> Option<ShResult<Tk>> { pub fn read_redir(&mut self) -> Option<ShResult<Tk>> {
assert!(self.cursor <= self.source.len()); assert!(self.cursor <= self.source.len());
let slice = self.slice(self.cursor..)?.to_string(); let slice = self.slice(self.cursor..)?;
let mut pos = self.cursor; let mut pos = self.cursor;
let mut chars = slice.chars().peekable(); let mut chars = slice.chars().peekable();
let mut tk = Tk::default(); let mut tk = Tk::default();
@@ -409,47 +379,33 @@ impl LexStream {
return None; // It's a process sub return None; // It's a process sub
} }
pos += 1; pos += 1;
if let Some('|') = chars.peek() {
// noclobber force '>|'
chars.next();
pos += 1;
tk = self.get_token(self.cursor..pos, TkRule::Redir);
break;
}
if let Some('>') = chars.peek() { if let Some('>') = chars.peek() {
chars.next(); chars.next();
pos += 1; pos += 1;
} }
let Some('&') = chars.peek() else { if let Some('&') = chars.peek() {
tk = self.get_token(self.cursor..pos, TkRule::Redir);
break;
};
chars.next();
pos += 1;
let mut found_fd = false;
if chars.peek().is_some_and(|ch| *ch == '-') {
chars.next(); chars.next();
found_fd = true;
pos += 1; pos += 1;
} else {
let mut found_fd = false;
while chars.peek().is_some_and(|ch| ch.is_ascii_digit()) { while chars.peek().is_some_and(|ch| ch.is_ascii_digit()) {
chars.next(); chars.next();
found_fd = true; found_fd = true;
pos += 1; pos += 1;
} }
}
if !found_fd && !self.flags.contains(LexFlags::LEX_UNFINISHED) { if !found_fd && !self.flags.contains(LexFlags::LEX_UNFINISHED) {
let span_start = self.cursor; let span_start = self.cursor;
self.cursor = pos; self.cursor = pos;
return Some(Err(ShErr::at( return Some(Err(ShErr::at(
ShErrKind::ParseErr, ShErrKind::ParseErr,
Span::new(span_start..pos, self.source.clone()), Span::new(span_start..pos, self.source.clone()),
"Invalid redirection", "Invalid redirection",
))); )));
} else {
tk = self.get_token(self.cursor..pos, TkRule::Redir);
break;
}
} else { } else {
tk = self.get_token(self.cursor..pos, TkRule::Redir); tk = self.get_token(self.cursor..pos, TkRule::Redir);
break; break;
@@ -461,94 +417,14 @@ impl LexStream {
} }
pos += 1; pos += 1;
match chars.peek() { for _ in 0..2 {
Some('<') => { if let Some('<') = chars.peek() {
chars.next(); chars.next();
pos += 1; pos += 1;
} else {
match chars.peek() {
Some('<') => {
chars.next();
pos += 1;
}
Some(ch) => {
let mut ch = *ch;
while is_field_sep(ch) {
let Some(next_ch) = chars.next() else {
// Incomplete input — fall through to emit << as Redir
break;
};
pos += next_ch.len_utf8();
ch = next_ch;
}
if is_field_sep(ch) {
// Ran out of input while skipping whitespace — fall through
} else {
let saved_cursor = self.cursor;
match self.read_heredoc(pos) {
Ok(Some(heredoc_tk)) => {
// cursor is set to after the delimiter word;
// heredoc_skip is set to after the body
pos = self.cursor;
self.cursor = saved_cursor;
tk = heredoc_tk;
break;
}
Ok(None) => {
// Incomplete heredoc — restore cursor and fall through
self.cursor = saved_cursor;
}
Err(e) => return Some(Err(e)),
}
}
}
_ => {
// No delimiter yet — input is incomplete
// Fall through to emit the << as a Redir token
}
}
}
Some('>') => {
chars.next();
pos += 1;
tk = self.get_token(self.cursor..pos, TkRule::Redir);
break; break;
} }
Some('&') => {
chars.next();
pos += 1;
let mut found_fd = false;
if chars.peek().is_some_and(|ch| *ch == '-') {
chars.next();
found_fd = true;
pos += 1;
} else {
while chars.peek().is_some_and(|ch| ch.is_ascii_digit()) {
chars.next();
found_fd = true;
pos += 1;
}
}
if !found_fd && !self.flags.contains(LexFlags::LEX_UNFINISHED) {
let span_start = self.cursor;
self.cursor = pos;
return Some(Err(ShErr::at(
ShErrKind::ParseErr,
Span::new(span_start..pos, self.source.clone()),
"Invalid redirection",
)));
} else {
tk = self.get_token(self.cursor..pos, TkRule::Redir);
break;
}
}
_ => {}
} }
tk = self.get_token(self.cursor..pos, TkRule::Redir); tk = self.get_token(self.cursor..pos, TkRule::Redir);
break; break;
} }
@@ -572,133 +448,6 @@ impl LexStream {
self.cursor = pos; self.cursor = pos;
Some(Ok(tk)) Some(Ok(tk))
} }
pub fn read_heredoc(&mut self, mut pos: usize) -> ShResult<Option<Tk>> {
let slice = self.slice(pos..).unwrap_or_default().to_string();
let mut chars = slice.chars();
let mut delim = String::new();
let mut flags = TkFlags::empty();
let mut first_char = true;
// Parse the delimiter word, stripping quotes
while let Some(ch) = chars.next() {
match ch {
'-' if first_char => {
pos += 1;
flags |= TkFlags::TAB_HEREDOC;
}
'\"' => {
pos += 1;
self.quote_state.toggle_double();
flags |= TkFlags::LIT_HEREDOC;
}
'\'' => {
pos += 1;
self.quote_state.toggle_single();
flags |= TkFlags::LIT_HEREDOC;
}
_ if self.quote_state.in_quote() => {
pos += ch.len_utf8();
delim.push(ch);
}
ch if is_hard_sep(ch) => {
break;
}
ch => {
pos += ch.len_utf8();
delim.push(ch);
}
}
first_char = false;
}
// pos is now right after the delimiter word — this is where
// the cursor should return so the rest of the line gets lexed
let cursor_after_delim = pos;
// Re-slice from cursor_after_delim so iterator and pos are in sync
// (the old chars iterator consumed the hard_sep without advancing pos)
let rest = self
.slice(cursor_after_delim..)
.unwrap_or_default()
.to_string();
let mut chars = rest.chars();
// Scan forward to the newline (or use heredoc_skip from a previous heredoc)
let body_start = if let Some(skip) = self.heredoc_skip {
// A previous heredoc on this line already read its body;
// our body starts where that one ended
let skip_offset = skip - cursor_after_delim;
for _ in 0..skip_offset {
chars.next();
}
skip
} else {
// Skip the rest of the current line to find where the body begins
let mut scan = pos;
let mut found_newline = false;
while let Some(ch) = chars.next() {
scan += ch.len_utf8();
if ch == '\n' {
found_newline = true;
break;
}
}
if !found_newline {
if self.flags.contains(LexFlags::LEX_UNFINISHED) {
return Ok(None);
} else {
return Err(ShErr::at(
ShErrKind::ParseErr,
Span::new(pos..pos, self.source.clone()),
"Heredoc delimiter not found",
));
}
}
scan
};
pos = body_start;
let start = pos;
// Read lines until we find one that matches the delimiter exactly
let mut line = String::new();
let mut line_start = pos;
while let Some(ch) = chars.next() {
pos += ch.len_utf8();
if ch == '\n' {
let trimmed = line.trim_end_matches('\r');
if trimmed == delim {
let mut tk = self.get_token(start..line_start, TkRule::Redir);
tk.flags |= TkFlags::IS_HEREDOC | flags;
self.heredoc_skip = Some(pos);
self.cursor = cursor_after_delim;
return Ok(Some(tk));
}
line.clear();
line_start = pos;
} else {
line.push(ch);
}
}
// Check the last line (no trailing newline)
let trimmed = line.trim_end_matches('\r');
if trimmed == delim {
let mut tk = self.get_token(start..line_start, TkRule::Redir);
tk.flags |= TkFlags::IS_HEREDOC | flags;
self.heredoc_skip = Some(pos);
self.cursor = cursor_after_delim;
return Ok(Some(tk));
}
if !self.flags.contains(LexFlags::LEX_UNFINISHED) {
Err(ShErr::at(
ShErrKind::ParseErr,
Span::new(start..pos, self.source.clone()),
format!("Heredoc delimiter '{}' not found", delim),
))
} else {
Ok(None)
}
}
pub fn read_string(&mut self) -> ShResult<Tk> { pub fn read_string(&mut self) -> ShResult<Tk> {
assert!(self.cursor <= self.source.len()); assert!(self.cursor <= self.source.len());
let slice = self.slice_from_cursor().unwrap().to_string(); let slice = self.slice_from_cursor().unwrap().to_string();
@@ -876,16 +625,6 @@ impl LexStream {
)); ));
} }
} }
'(' if can_be_subshell && chars.peek() == Some(&')') => {
// standalone "()" — function definition marker
pos += 2;
chars.next();
let mut tk = self.get_token(self.cursor..pos, TkRule::Str);
tk.mark(TkFlags::KEYWORD);
self.cursor = pos;
self.set_next_is_cmd(true);
return Ok(tk);
}
'(' if self.next_is_cmd() && can_be_subshell => { '(' if self.next_is_cmd() && can_be_subshell => {
pos += 1; pos += 1;
let mut paren_count = 1; let mut paren_count = 1;
@@ -1106,19 +845,10 @@ impl Iterator for LexStream {
let token = match get_char(&self.source, self.cursor).unwrap() { let token = match get_char(&self.source, self.cursor).unwrap() {
'\r' | '\n' | ';' => { '\r' | '\n' | ';' => {
let ch = get_char(&self.source, self.cursor).unwrap();
let ch_idx = self.cursor; let ch_idx = self.cursor;
self.cursor += 1; self.cursor += 1;
self.set_next_is_cmd(true); self.set_next_is_cmd(true);
// If a heredoc was parsed on this line, skip past the body
// Only on newline — ';' is a command separator within the same line
if (ch == '\n' || ch == '\r')
&& let Some(skip) = self.heredoc_skip.take()
{
self.cursor = skip;
}
while let Some(ch) = get_char(&self.source, self.cursor) { while let Some(ch) = get_char(&self.source, self.cursor) {
match ch { match ch {
'\\' if get_char(&self.source, self.cursor + 1) == Some('\n') => { '\\' if get_char(&self.source, self.cursor + 1) == Some('\n') => {
@@ -1153,14 +883,14 @@ impl Iterator for LexStream {
return self.next(); return self.next();
} }
} }
'!' if self.next_is_cmd() => { '!' if self.next_is_cmd() => {
self.cursor += 1; self.cursor += 1;
let tk_type = TkRule::Bang; let tk_type = TkRule::Bang;
let mut tk = self.get_token((self.cursor - 1)..self.cursor, tk_type); let mut tk = self.get_token((self.cursor - 1)..self.cursor, tk_type);
tk.flags |= TkFlags::KEYWORD; tk.flags |= TkFlags::KEYWORD;
tk tk
} }
'|' => { '|' => {
let ch_idx = self.cursor; let ch_idx = self.cursor;
self.cursor += 1; self.cursor += 1;

1727
src/parse/mod.rs
View File

File diff suppressed because one or more lines are too long

3
src/prelude.rs
View File

@@ -19,7 +19,7 @@ pub use std::os::unix::io::{AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd,
pub use bitflags::bitflags; pub use bitflags::bitflags;
pub use nix::{ pub use nix::{
errno::Errno, errno::Errno,
fcntl::{FcntlArg, OFlag, fcntl, open}, fcntl::{OFlag, open},
libc::{self, STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO}, libc::{self, STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO},
sys::{ sys::{
signal::{self, SigHandler, SigSet, SigmaskHow, Signal, kill, killpg, pthread_sigmask, signal}, signal::{self, SigHandler, SigSet, SigmaskHow, Signal, kill, killpg, pthread_sigmask, signal},
@@ -33,4 +33,5 @@ pub use nix::{
}, },
}; };
// Additional utilities, if needed, can be added here // Additional utilities, if needed, can be added here

382
src/procio.rs
View File

@@ -8,27 +8,15 @@ use crate::{
expand::Expander, expand::Expander,
libsh::{ libsh::{
error::{ShErr, ShErrKind, ShResult}, error::{ShErr, ShErrKind, ShResult},
sys::TTY_FILENO,
utils::RedirVecUtils, utils::RedirVecUtils,
}, },
parse::{Redir, RedirType, get_redir_file, lex::TkFlags}, parse::{Redir, RedirType, get_redir_file},
prelude::*, prelude::*,
state,
}; };
// Credit to fish-shell for many of the implementation ideas present in this // Credit to fish-shell for many of the implementation ideas present in this
// module https://fishshell.com/ // module https://fishshell.com/
/// Minimum fd number for shell-internal file descriptors.
/// User-visible fds (0-9) are kept clear so `exec 3>&-` etc. work as expected.
const MIN_INTERNAL_FD: RawFd = 10;
/// Like `dup()`, but places the new fd at `MIN_INTERNAL_FD` or above so it
/// doesn't collide with user-managed fds.
fn dup_high(fd: RawFd) -> nix::Result<RawFd> {
fcntl(fd, FcntlArg::F_DUPFD_CLOEXEC(MIN_INTERNAL_FD))
}
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum IoMode { pub enum IoMode {
Fd { Fd {
@@ -49,9 +37,8 @@ pub enum IoMode {
pipe: Arc<OwnedFd>, pipe: Arc<OwnedFd>,
}, },
Buffer { Buffer {
tgt_fd: RawFd,
buf: String, buf: String,
flags: TkFlags, // so we can see if its a heredoc or not pipe: Arc<OwnedFd>,
}, },
Close { Close {
tgt_fd: RawFd, tgt_fd: RawFd,
@@ -92,37 +79,19 @@ impl IoMode {
if let IoMode::File { tgt_fd, path, mode } = self { if let IoMode::File { tgt_fd, path, mode } = self {
let path_raw = path.as_os_str().to_str().unwrap_or_default().to_string(); let path_raw = path.as_os_str().to_str().unwrap_or_default().to_string();
let expanded_path = Expander::from_raw(&path_raw, TkFlags::empty())? let expanded_path = Expander::from_raw(&path_raw)?.expand()?.join(" "); // should just be one string, will have to find some way to handle a return of
.expand()? // multiple
.join(" "); // should just be one string, will have to find some way to handle a return of multiple paths
let expanded_pathbuf = PathBuf::from(expanded_path); let expanded_pathbuf = PathBuf::from(expanded_path);
let file = get_redir_file(mode, expanded_pathbuf)?; let file = get_redir_file(mode, expanded_pathbuf)?;
// Move the opened fd above the user-accessible range so it never
// collides with the target fd (e.g. `3>/tmp/foo` where open() returns 3,
// causing dup2(3,3) to be a no-op and then OwnedFd drop closes it).
let raw = file.as_raw_fd();
let high = fcntl(raw, FcntlArg::F_DUPFD_CLOEXEC(MIN_INTERNAL_FD)).map_err(ShErr::from)?;
drop(file); // closes the original low fd
self = IoMode::OpenedFile { self = IoMode::OpenedFile {
tgt_fd, tgt_fd,
file: Arc::new(unsafe { OwnedFd::from_raw_fd(high) }), file: Arc::new(OwnedFd::from(file)),
} }
} }
Ok(self) Ok(self)
} }
pub fn buffer(tgt_fd: RawFd, buf: String, flags: TkFlags) -> ShResult<Self> {
Ok(Self::Buffer { tgt_fd, buf, flags })
}
pub fn loaded_pipe(tgt_fd: RawFd, buf: &[u8]) -> ShResult<Self> {
let (rpipe, wpipe) = nix::unistd::pipe()?;
write(wpipe, buf)?;
Ok(Self::Pipe {
tgt_fd,
pipe: rpipe.into(),
})
}
pub fn get_pipes() -> (Self, Self) { pub fn get_pipes() -> (Self, Self) {
let (rpipe, wpipe) = nix::unistd::pipe2(OFlag::O_CLOEXEC).unwrap(); let (rpipe, wpipe) = nix::unistd::pipe2(OFlag::O_CLOEXEC).unwrap();
( (
@@ -237,106 +206,23 @@ impl<'e> IoFrame {
) )
} }
pub fn save(&'e mut self) { pub fn save(&'e mut self) {
let saved_in = dup_high(STDIN_FILENO).unwrap(); let saved_in = dup(STDIN_FILENO).unwrap();
let saved_out = dup_high(STDOUT_FILENO).unwrap(); let saved_out = dup(STDOUT_FILENO).unwrap();
let saved_err = dup_high(STDERR_FILENO).unwrap(); let saved_err = dup(STDERR_FILENO).unwrap();
self.saved_io = Some(IoGroup(saved_in, saved_out, saved_err)); self.saved_io = Some(IoGroup(saved_in, saved_out, saved_err));
} }
pub fn redirect(mut self) -> ShResult<RedirGuard> { pub fn redirect(mut self) -> ShResult<RedirGuard> {
self.save(); self.save();
if let Err(e) = self.apply_redirs() {
// Restore saved fds before propagating the error so they don't leak.
self.restore().ok();
return Err(e);
}
Ok(RedirGuard::new(self))
}
fn apply_redirs(&mut self) -> ShResult<()> {
for redir in &mut self.redirs { for redir in &mut self.redirs {
let io_mode = &mut redir.io_mode; let io_mode = &mut redir.io_mode;
match io_mode { if let IoMode::File { .. } = io_mode {
IoMode::Close { tgt_fd } => { *io_mode = io_mode.clone().open_file()?;
if *tgt_fd == *TTY_FILENO { };
// Don't let user close the shell's tty fd.
continue;
}
close(*tgt_fd).ok();
continue;
}
IoMode::File { .. } => match io_mode.clone().open_file() {
Ok(file) => *io_mode = file,
Err(e) => {
if let Some(span) = redir.span.as_ref() {
return Err(e.promote(span.clone()));
}
return Err(e);
}
},
IoMode::Buffer { tgt_fd, buf, flags } => {
let (rpipe, wpipe) = nix::unistd::pipe()?;
let mut text = if flags.contains(TkFlags::LIT_HEREDOC) {
buf.clone()
} else {
let words = Expander::from_raw(buf, *flags)?.expand()?;
if flags.contains(TkFlags::IS_HEREDOC) {
words.into_iter().next().unwrap_or_default()
} else {
let ifs = state::get_separator();
words.join(&ifs).trim().to_string() + "\n"
}
};
if flags.contains(TkFlags::TAB_HEREDOC) {
let lines = text.lines();
let mut min_tabs = usize::MAX;
for line in lines {
if line.is_empty() {
continue;
}
let line_len = line.len();
let after_strip = line.trim_start_matches('\t').len();
let delta = line_len - after_strip;
min_tabs = min_tabs.min(delta);
}
if min_tabs == usize::MAX {
// let's avoid possibly allocating a string with 18 quintillion tabs
min_tabs = 0;
}
if min_tabs > 0 {
let stripped = text
.lines()
.fold(vec![], |mut acc, ln| {
if ln.is_empty() {
acc.push("");
return acc;
}
let stripped_ln = ln.strip_prefix(&"\t".repeat(min_tabs)).unwrap();
acc.push(stripped_ln);
acc
})
.join("\n");
text = stripped + "\n";
}
}
write(wpipe, text.as_bytes())?;
*io_mode = IoMode::Pipe {
tgt_fd: *tgt_fd,
pipe: rpipe.into(),
};
}
_ => {}
}
let tgt_fd = io_mode.tgt_fd(); let tgt_fd = io_mode.tgt_fd();
let src_fd = io_mode.src_fd(); let src_fd = io_mode.src_fd();
if let Err(e) = dup2(src_fd, tgt_fd) { dup2(src_fd, tgt_fd)?;
if let Some(span) = redir.span.as_ref() {
return Err(ShErr::from(e).promote(span.clone()));
} else {
return Err(e.into());
}
}
} }
Ok(()) Ok(RedirGuard::new(self))
} }
pub fn restore(&mut self) -> ShResult<()> { pub fn restore(&mut self) -> ShResult<()> {
if let Some(saved) = self.saved_io.take() { if let Some(saved) = self.saved_io.take() {
@@ -448,8 +334,6 @@ pub fn borrow_fd<'f>(fd: i32) -> BorrowedFd<'f> {
} }
type PipeFrames = Map<PipeGenerator, fn((Option<Redir>, Option<Redir>)) -> IoFrame>; type PipeFrames = Map<PipeGenerator, fn((Option<Redir>, Option<Redir>)) -> IoFrame>;
/// An iterator that lazily creates a specific number of pipes.
pub struct PipeGenerator { pub struct PipeGenerator {
num_cmds: usize, num_cmds: usize,
cursor: usize, cursor: usize,
@@ -505,166 +389,154 @@ impl Iterator for PipeGenerator {
#[cfg(test)] #[cfg(test)]
pub mod tests { pub mod tests {
use crate::testutil::{TestGuard, has_cmd, has_cmds, test_input}; use crate::testutil::{TestGuard, has_cmd, has_cmds, test_input};
use pretty_assertions::assert_eq; use pretty_assertions::assert_eq;
#[test] #[test]
fn pipeline_simple() { fn pipeline_simple() {
if !has_cmd("sed") { if !has_cmd("sed") { return };
return; let g = TestGuard::new();
};
let g = TestGuard::new();
test_input("echo foo | sed 's/foo/bar/'").unwrap(); test_input("echo foo | sed 's/foo/bar/'").unwrap();
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, "bar\n"); assert_eq!(out, "bar\n");
} }
#[test] #[test]
fn pipeline_multi() { fn pipeline_multi() {
if !has_cmds(&["cut", "sed"]) { if !has_cmds(&[
return; "cut",
} "sed"
let g = TestGuard::new(); ]) { return; }
let g = TestGuard::new();
test_input("echo foo bar baz | cut -d ' ' -f 2 | sed 's/a/A/'").unwrap(); test_input("echo foo bar baz | cut -d ' ' -f 2 | sed 's/a/A/'").unwrap();
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, "bAr\n"); assert_eq!(out, "bAr\n");
} }
#[test] #[test]
fn rube_goldberg_pipeline() { fn rube_goldberg_pipeline() {
if !has_cmds(&["sed", "cat"]) { if !has_cmds(&[
return; "sed",
} "cat",
let g = TestGuard::new(); ]) { return }
let g = TestGuard::new();
test_input("{ echo foo; echo bar } | if cat; then :; else echo failed; fi | (read line && echo $line | sed 's/foo/baz/'; sed 's/bar/buzz/')").unwrap(); test_input("{ echo foo; echo bar } | if cat; then :; else echo failed; fi | (read line && echo $line | sed 's/foo/baz/'; sed 's/bar/buzz/')").unwrap();
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, "baz\nbuzz\n"); assert_eq!(out, "baz\nbuzz\n");
} }
#[test] #[test]
fn simple_file_redir() { fn simple_file_redir() {
let mut g = TestGuard::new(); let mut g = TestGuard::new();
test_input("echo this is in a file > /tmp/simple_file_redir.txt").unwrap(); test_input("echo this is in a file > /tmp/simple_file_redir.txt").unwrap();
g.add_cleanup(|| { g.add_cleanup(|| { std::fs::remove_file("/tmp/simple_file_redir.txt").ok(); });
std::fs::remove_file("/tmp/simple_file_redir.txt").ok(); let contents = std::fs::read_to_string("/tmp/simple_file_redir.txt").unwrap();
});
let contents = std::fs::read_to_string("/tmp/simple_file_redir.txt").unwrap();
assert_eq!(contents, "this is in a file\n"); assert_eq!(contents, "this is in a file\n");
} }
#[test] #[test]
fn append_file_redir() { fn append_file_redir() {
let dir = tempfile::TempDir::new().unwrap(); let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("append.txt"); let path = dir.path().join("append.txt");
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input(format!("echo first > {}", path.display())).unwrap(); test_input(format!("echo first > {}", path.display())).unwrap();
test_input(format!("echo second >> {}", path.display())).unwrap(); test_input(format!("echo second >> {}", path.display())).unwrap();
let contents = std::fs::read_to_string(&path).unwrap(); let contents = std::fs::read_to_string(&path).unwrap();
assert_eq!(contents, "first\nsecond\n"); assert_eq!(contents, "first\nsecond\n");
} }
#[test] #[test]
fn input_redir() { fn input_redir() {
if !has_cmd("cat") { if !has_cmd("cat") { return; }
return; let dir = tempfile::TempDir::new().unwrap();
} let path = dir.path().join("input.txt");
let dir = tempfile::TempDir::new().unwrap(); std::fs::write(&path, "hello from file\n").unwrap();
let path = dir.path().join("input.txt"); let g = TestGuard::new();
std::fs::write(&path, "hello from file\n").unwrap();
let g = TestGuard::new();
test_input(format!("cat < {}", path.display())).unwrap(); test_input(format!("cat < {}", path.display())).unwrap();
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, "hello from file\n"); assert_eq!(out, "hello from file\n");
} }
#[test] #[test]
fn stderr_redir_to_file() { fn stderr_redir_to_file() {
let dir = tempfile::TempDir::new().unwrap(); let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("err.txt"); let path = dir.path().join("err.txt");
let g = TestGuard::new(); let g = TestGuard::new();
test_input(format!("echo error msg 2> {} >&2", path.display())).unwrap(); test_input(format!("echo error msg 2> {} >&2", path.display())).unwrap();
let contents = std::fs::read_to_string(&path).unwrap(); let contents = std::fs::read_to_string(&path).unwrap();
assert_eq!(contents, "error msg\n"); assert_eq!(contents, "error msg\n");
// stdout should be empty since we redirected to stderr // stdout should be empty since we redirected to stderr
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, ""); assert_eq!(out, "");
} }
#[test] #[test]
fn pipe_and_stderr() { fn pipe_and_stderr() {
if !has_cmd("cat") { if !has_cmd("cat") { return; }
return; let g = TestGuard::new();
}
let g = TestGuard::new();
test_input("echo on stderr >&2 |& cat").unwrap(); test_input("echo on stderr >&2 |& cat").unwrap();
let out = g.read_output(); let out = g.read_output();
assert_eq!(out, "on stderr\n"); assert_eq!(out, "on stderr\n");
} }
#[test] #[test]
fn output_redir_clobber() { fn output_redir_clobber() {
let dir = tempfile::TempDir::new().unwrap(); let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("clobber.txt"); let path = dir.path().join("clobber.txt");
let _g = TestGuard::new(); let _g = TestGuard::new();
test_input(format!("echo first > {}", path.display())).unwrap(); test_input(format!("echo first > {}", path.display())).unwrap();
test_input(format!("echo second > {}", path.display())).unwrap(); test_input(format!("echo second > {}", path.display())).unwrap();
let contents = std::fs::read_to_string(&path).unwrap(); let contents = std::fs::read_to_string(&path).unwrap();
assert_eq!(contents, "second\n"); assert_eq!(contents, "second\n");
} }
#[test] #[test]
fn pipeline_preserves_exit_status() { fn pipeline_preserves_exit_status() {
if !has_cmd("cat") { if !has_cmd("cat") { return; }
return; let _g = TestGuard::new();
}
let _g = TestGuard::new();
test_input("false | cat").unwrap(); test_input("false | cat").unwrap();
// Pipeline exit status is the last command // Pipeline exit status is the last command
let status = crate::state::get_status(); let status = crate::state::get_status();
assert_eq!(status, 0); assert_eq!(status, 0);
test_input("cat < /dev/null | false").unwrap(); test_input("cat < /dev/null | false").unwrap();
let status = crate::state::get_status(); let status = crate::state::get_status();
assert_ne!(status, 0); assert_ne!(status, 0);
} }
#[test] #[test]
fn fd_duplication() { fn fd_duplication() {
let dir = tempfile::TempDir::new().unwrap(); let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("dup.txt"); let path = dir.path().join("dup.txt");
let _g = TestGuard::new(); let _g = TestGuard::new();
// Redirect stdout to file, then dup stderr to stdout — both should go to file // Redirect stdout to file, then dup stderr to stdout — both should go to file
test_input(format!( test_input(format!("{{ echo out; echo err >&2 }} > {} 2>&1", path.display())).unwrap();
"{{ echo out; echo err >&2 }} > {} 2>&1",
path.display()
))
.unwrap();
let contents = std::fs::read_to_string(&path).unwrap(); let contents = std::fs::read_to_string(&path).unwrap();
assert!(contents.contains("out")); assert!(contents.contains("out"));
assert!(contents.contains("err")); assert!(contents.contains("err"));
} }
} }

822
src/readline/complete.rs
View File

File diff suppressed because it is too large Load Diff

12
src/readline/highlight.rs
View File

@@ -88,9 +88,7 @@ impl Highlighter {
while prefix_chars.peek().is_some() { while prefix_chars.peek().is_some() {
match chars.next() { match chars.next() {
Some(c) if c == markers::VISUAL_MODE_START || c == markers::VISUAL_MODE_END => continue, Some(c) if c == markers::VISUAL_MODE_START || c == markers::VISUAL_MODE_END => continue,
Some(c) if Some(&c) == prefix_chars.peek() => { Some(c) if Some(&c) == prefix_chars.peek() => { prefix_chars.next(); }
prefix_chars.next();
}
_ => return text.to_string(), // mismatch, return original _ => return text.to_string(), // mismatch, return original
} }
} }
@@ -106,9 +104,7 @@ impl Highlighter {
let mut si = suffix_chars.len(); let mut si = suffix_chars.len();
while si > 0 { while si > 0 {
if ti == 0 { if ti == 0 { return text.to_string(); }
return text.to_string();
}
ti -= 1; ti -= 1;
if chars[ti] == markers::VISUAL_MODE_START || chars[ti] == markers::VISUAL_MODE_END { if chars[ti] == markers::VISUAL_MODE_START || chars[ti] == markers::VISUAL_MODE_END {
continue; // skip visual markers continue; // skip visual markers
@@ -350,9 +346,7 @@ impl Highlighter {
recursive_highlighter.highlight(); recursive_highlighter.highlight();
// Read back visual state — selection may have started/ended inside // Read back visual state — selection may have started/ended inside
self.in_selection = recursive_highlighter.in_selection; self.in_selection = recursive_highlighter.in_selection;
self self.style_stack.append(&mut recursive_highlighter.style_stack);
.style_stack
.append(&mut recursive_highlighter.style_stack);
if selection_at_entry { if selection_at_entry {
self.emit_style(Style::BgWhite | Style::Black); self.emit_style(Style::BgWhite | Style::Black);
self.output.push_str(prefix); self.output.push_str(prefix);

31
src/readline/history.rs
View File

@@ -203,7 +203,6 @@ fn dedupe_entries(entries: &[HistEntry]) -> Vec<HistEntry> {
.collect() .collect()
} }
#[derive(Default, Clone, Debug)]
pub struct History { pub struct History {
path: PathBuf, path: PathBuf,
pub pending: Option<LineBuf>, // command, cursor_pos pub pending: Option<LineBuf>, // command, cursor_pos
@@ -215,7 +214,6 @@ pub struct History {
//search_direction: Direction, //search_direction: Direction,
ignore_dups: bool, ignore_dups: bool,
max_size: Option<u32>, max_size: Option<u32>,
stateless: bool,
} }
impl History { impl History {
@@ -231,7 +229,6 @@ impl History {
//search_direction: Direction::Backward, //search_direction: Direction::Backward,
ignore_dups: false, ignore_dups: false,
max_size: None, max_size: None,
stateless: true,
} }
} }
pub fn new() -> ShResult<Self> { pub fn new() -> ShResult<Self> {
@@ -269,7 +266,6 @@ impl History {
//search_direction: Direction::Backward, //search_direction: Direction::Backward,
ignore_dups, ignore_dups,
max_size, max_size,
stateless: false,
}) })
} }
@@ -284,7 +280,7 @@ impl History {
.search_mask .search_mask
.clone() .clone()
.into_iter() .into_iter()
.map(|ent| super::complete::Candidate::from(ent.command())); .map(|ent| ent.command().to_string());
self.fuzzy_finder.activate(raw_entries.collect()); self.fuzzy_finder.activate(raw_entries.collect());
None None
} }
@@ -454,9 +450,6 @@ impl History {
} }
pub fn save(&mut self) -> ShResult<()> { pub fn save(&mut self) -> ShResult<()> {
if self.stateless {
return Ok(());
}
let mut file = OpenOptions::new() let mut file = OpenOptions::new()
.create(true) .create(true)
.append(true) .append(true)
@@ -507,8 +500,12 @@ mod tests {
env::set_var(key, val); env::set_var(key, val);
} }
guard(prev, move |p| match p { guard(prev, move |p| match p {
Some(v) => unsafe { env::set_var(key, v) }, Some(v) => unsafe {
None => unsafe { env::remove_var(key) }, env::set_var(key, v)
},
None => unsafe {
env::remove_var(key)
},
}) })
} }
@@ -525,7 +522,12 @@ mod tests {
fn write_history_file(path: &Path) { fn write_history_file(path: &Path) {
fs::write( fs::write(
path, path,
[": 1;1;first\n", ": 2;1;second\n", ": 3;1;third\n"].concat(), [
": 1;1;first\n",
": 2;1;second\n",
": 3;1;third\n",
]
.concat(),
) )
.unwrap(); .unwrap();
} }
@@ -584,7 +586,12 @@ mod tests {
let hist_path = tmp.path().join("history"); let hist_path = tmp.path().join("history");
fs::write( fs::write(
&hist_path, &hist_path,
[": 1;1;repeat\n", ": 2;1;unique\n", ": 3;1;repeat\n"].concat(), [
": 1;1;repeat\n",
": 2;1;unique\n",
": 3;1;repeat\n",
]
.concat(),
) )
.unwrap(); .unwrap();

1695
src/readline/linebuf.rs
View File

File diff suppressed because it is too large Load Diff

385
src/readline/mod.rs
View File

@@ -9,14 +9,14 @@ use vimode::{CmdReplay, ModeReport, ViInsert, ViMode, ViNormal, ViReplace, ViVis
use crate::builtin::keymap::{KeyMapFlags, KeyMapMatch}; use crate::builtin::keymap::{KeyMapFlags, KeyMapMatch};
use crate::expand::expand_prompt; use crate::expand::expand_prompt;
use crate::libsh::sys::TTY_FILENO;
use crate::libsh::utils::AutoCmdVecUtils; use crate::libsh::utils::AutoCmdVecUtils;
use crate::parse::lex::{LexStream, QuoteState}; use crate::parse::lex::{LexStream, QuoteState};
use crate::readline::complete::{FuzzyCompleter, SelectorResponse}; use crate::readline::complete::{FuzzyCompleter, SelectorResponse};
use crate::readline::term::{Pos, TermReader, calc_str_width}; use crate::readline::term::{Pos, TermReader, calc_str_width};
use crate::readline::vimode::{ViEx, ViVerbatim}; use crate::readline::vimode::{ViEx, ViVerbatim};
use crate::state::{ use crate::state::{
AutoCmdKind, ShellParam, Var, VarFlags, VarKind, read_logic, read_shopts, with_vars, write_meta, AutoCmdKind, ShellParam, Var, VarFlags, VarKind, read_logic, read_shopts, with_vars, write_meta, write_vars
write_vars,
}; };
use crate::{ use crate::{
libsh::error::ShResult, libsh::error::ShResult,
@@ -132,18 +132,6 @@ pub mod markers {
pub fn is_marker(c: Marker) -> bool { pub fn is_marker(c: Marker) -> bool {
('\u{e000}'..'\u{efff}').contains(&c) ('\u{e000}'..'\u{efff}').contains(&c)
} }
// Help command formatting markers
pub const TAG: Marker = '\u{e180}';
pub const REFERENCE: Marker = '\u{e181}';
pub const HEADER: Marker = '\u{e182}';
pub const CODE: Marker = '\u{e183}';
/// angle brackets
pub const KEYWORD_1: Marker = '\u{e184}';
/// curly brackets
pub const KEYWORD_2: Marker = '\u{e185}';
/// square brackets
pub const KEYWORD_3: Marker = '\u{e186}';
} }
type Marker = char; type Marker = char;
@@ -253,7 +241,6 @@ impl Default for Prompt {
pub struct ShedVi { pub struct ShedVi {
pub reader: PollReader, pub reader: PollReader,
pub writer: TermWriter, pub writer: TermWriter,
pub tty: RawFd,
pub prompt: Prompt, pub prompt: Prompt,
pub highlighter: Highlighter, pub highlighter: Highlighter,
@@ -265,10 +252,10 @@ pub struct ShedVi {
pub repeat_action: Option<CmdReplay>, pub repeat_action: Option<CmdReplay>,
pub repeat_motion: Option<MotionCmd>, pub repeat_motion: Option<MotionCmd>,
pub editor: LineBuf, pub editor: LineBuf,
pub next_is_escaped: bool,
pub old_layout: Option<Layout>, pub old_layout: Option<Layout>,
pub history: History, pub history: History,
pub ex_history: History,
pub needs_redraw: bool, pub needs_redraw: bool,
} }
@@ -279,10 +266,10 @@ impl ShedVi {
reader: PollReader::new(), reader: PollReader::new(),
writer: TermWriter::new(tty), writer: TermWriter::new(tty),
prompt, prompt,
tty,
completer: Box::new(FuzzyCompleter::default()), completer: Box::new(FuzzyCompleter::default()),
highlighter: Highlighter::new(), highlighter: Highlighter::new(),
mode: Box::new(ViInsert::new()), mode: Box::new(ViInsert::new()),
next_is_escaped: false,
saved_mode: None, saved_mode: None,
pending_keymap: Vec::new(), pending_keymap: Vec::new(),
old_layout: None, old_layout: None,
@@ -290,7 +277,6 @@ impl ShedVi {
repeat_motion: None, repeat_motion: None,
editor: LineBuf::new(), editor: LineBuf::new(),
history: History::new()?, history: History::new()?,
ex_history: History::empty(),
needs_redraw: true, needs_redraw: true,
}; };
write_vars(|v| { write_vars(|v| {
@@ -306,37 +292,36 @@ impl ShedVi {
Ok(new) Ok(new)
} }
pub fn new_no_hist(prompt: Prompt, tty: RawFd) -> ShResult<Self> { pub fn new_no_hist(prompt: Prompt, tty: RawFd) -> ShResult<Self> {
let mut new = Self { let mut new = Self {
reader: PollReader::new(), reader: PollReader::new(),
writer: TermWriter::new(tty), writer: TermWriter::new(tty),
tty, prompt,
prompt, completer: Box::new(FuzzyCompleter::default()),
completer: Box::new(FuzzyCompleter::default()), highlighter: Highlighter::new(),
highlighter: Highlighter::new(), mode: Box::new(ViInsert::new()),
mode: Box::new(ViInsert::new()), next_is_escaped: false,
saved_mode: None, saved_mode: None,
pending_keymap: Vec::new(), pending_keymap: Vec::new(),
old_layout: None, old_layout: None,
repeat_action: None, repeat_action: None,
repeat_motion: None, repeat_motion: None,
editor: LineBuf::new(), editor: LineBuf::new(),
history: History::empty(), history: History::empty(),
ex_history: History::empty(), needs_redraw: true,
needs_redraw: true, };
}; write_vars(|v| {
write_vars(|v| { v.set_var(
v.set_var( "SHED_VI_MODE",
"SHED_VI_MODE", VarKind::Str(new.mode.report_mode().to_string()),
VarKind::Str(new.mode.report_mode().to_string()), VarFlags::NONE,
VarFlags::NONE, )
) })?;
})?; new.prompt.refresh();
new.prompt.refresh(); new.writer.flush_write("\n")?; // ensure we start on a new line, in case the previous command didn't end with a newline
new.writer.flush_write("\n")?; // ensure we start on a new line, in case the previous command didn't end with a newline new.print_line(false)?;
new.print_line(false)?; Ok(new)
Ok(new) }
}
pub fn with_initial(mut self, initial: &str) -> Self { pub fn with_initial(mut self, initial: &str) -> Self {
self.editor = LineBuf::new().with_initial(initial, 0); self.editor = LineBuf::new().with_initial(initial, 0);
@@ -346,21 +331,9 @@ impl ShedVi {
self self
} }
/// A mutable reference to the currently focused editor
/// This includes the main LineBuf, and sub-editors for modes like Ex mode.
pub fn focused_editor(&mut self) -> &mut LineBuf {
self.mode.editor().unwrap_or(&mut self.editor)
}
/// A mutable reference to the currently focused history, if any.
/// This includes the main history struct, and history for sub-editors like Ex mode.
pub fn focused_history(&mut self) -> &mut History {
self.mode.history().unwrap_or(&mut self.history)
}
/// Feed raw bytes from stdin into the reader's buffer /// Feed raw bytes from stdin into the reader's buffer
pub fn feed_bytes(&mut self, bytes: &[u8]) { pub fn feed_bytes(&mut self, bytes: &[u8]) {
self.reader.feed_bytes(bytes); self.reader.feed_bytes(bytes);
} }
/// Mark that the display needs to be redrawn (e.g., after SIGWINCH) /// Mark that the display needs to be redrawn (e.g., after SIGWINCH)
@@ -371,7 +344,7 @@ impl ShedVi {
pub fn fix_column(&mut self) -> ShResult<()> { pub fn fix_column(&mut self) -> ShResult<()> {
self self
.writer .writer
.fix_cursor_column(&mut TermReader::new(self.tty)) .fix_cursor_column(&mut TermReader::new(*TTY_FILENO))
} }
pub fn reset_active_widget(&mut self, full_redraw: bool) -> ShResult<()> { pub fn reset_active_widget(&mut self, full_redraw: bool) -> ShResult<()> {
@@ -379,10 +352,10 @@ impl ShedVi {
self.completer.reset_stay_active(); self.completer.reset_stay_active();
self.needs_redraw = true; self.needs_redraw = true;
Ok(()) Ok(())
} else if self.focused_history().fuzzy_finder.is_active() { } else if self.history.fuzzy_finder.is_active() {
self.focused_history().fuzzy_finder.reset_stay_active(); self.history.fuzzy_finder.reset_stay_active();
self.needs_redraw = true; self.needs_redraw = true;
Ok(()) Ok(())
} else { } else {
self.reset(full_redraw) self.reset(full_redraw)
} }
@@ -441,7 +414,7 @@ impl ShedVi {
LexStream::new(Arc::clone(&input), LexFlags::LEX_UNFINISHED).collect::<ShResult<Vec<_>>>(); LexStream::new(Arc::clone(&input), LexFlags::LEX_UNFINISHED).collect::<ShResult<Vec<_>>>();
let lex_result2 = let lex_result2 =
LexStream::new(Arc::clone(&input), LexFlags::empty()).collect::<ShResult<Vec<_>>>(); LexStream::new(Arc::clone(&input), LexFlags::empty()).collect::<ShResult<Vec<_>>>();
let is_top_level = self.editor.indent_ctx.ctx().is_empty(); let is_top_level = self.editor.auto_indent_level == 0;
let is_complete = match (lex_result1.is_err(), lex_result2.is_err()) { let is_complete = match (lex_result1.is_err(), lex_result2.is_err()) {
(true, true) => { (true, true) => {
@@ -468,29 +441,22 @@ impl ShedVi {
// Process all available keys // Process all available keys
while let Some(key) = self.reader.read_key()? { while let Some(key) = self.reader.read_key()? {
log::debug!("Read key: {key:?} in mode {:?}, self.reader.verbatim = {}", self.mode.report_mode(), self.reader.verbatim);
// If completer or history search are active, delegate input to it // If completer or history search are active, delegate input to it
if self.focused_history().fuzzy_finder.is_active() { if self.history.fuzzy_finder.is_active() {
self.print_line(false)?; self.print_line(false)?;
match self.focused_history().fuzzy_finder.handle_key(key)? { match self.history.fuzzy_finder.handle_key(key)? {
SelectorResponse::Accept(cmd) => { SelectorResponse::Accept(cmd) => {
let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnHistorySelect)); let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnHistorySelect));
{ self.editor.set_buffer(cmd.to_string());
let editor = self.focused_editor(); self.editor.move_cursor_to_end();
editor.set_buffer(cmd.to_string());
editor.move_cursor_to_end();
}
self self
.history .history
.update_pending_cmd((self.editor.as_str(), self.editor.cursor.get())); .update_pending_cmd((self.editor.as_str(), self.editor.cursor.get()));
self.editor.set_hint(None); self.editor.set_hint(None);
{ self.history.fuzzy_finder.clear(&mut self.writer)?;
let mut writer = std::mem::take(&mut self.writer); self.history.fuzzy_finder.reset();
self.focused_history().fuzzy_finder.clear(&mut writer)?;
self.writer = writer;
}
self.focused_history().fuzzy_finder.reset();
with_vars([("_HIST_ENTRY".into(), cmd.clone())], || { with_vars([("_HIST_ENTRY".into(), cmd.clone())], || {
post_cmds.exec_with(&cmd); post_cmds.exec_with(&cmd);
@@ -513,11 +479,7 @@ impl ShedVi {
post_cmds.exec(); post_cmds.exec();
self.editor.set_hint(None); self.editor.set_hint(None);
{ self.history.fuzzy_finder.clear(&mut self.writer)?;
let mut writer = std::mem::take(&mut self.writer);
self.focused_history().fuzzy_finder.clear(&mut writer)?;
self.writer = writer;
}
write_vars(|v| { write_vars(|v| {
v.set_var( v.set_var(
"SHED_VI_MODE", "SHED_VI_MODE",
@@ -544,8 +506,8 @@ impl ShedVi {
let span_start = self.completer.token_span().0; let span_start = self.completer.token_span().0;
let new_cursor = span_start + candidate.len(); let new_cursor = span_start + candidate.len();
let line = self.completer.get_completed_line(&candidate); let line = self.completer.get_completed_line(&candidate);
self.focused_editor().set_buffer(line); self.editor.set_buffer(line);
self.focused_editor().cursor.set(new_cursor); self.editor.cursor.set(new_cursor);
// Don't reset yet — clear() needs old_layout to erase the selector. // Don't reset yet — clear() needs old_layout to erase the selector.
if !self.history.at_pending() { if !self.history.at_pending() {
@@ -662,6 +624,10 @@ impl ShedVi {
pub fn handle_key(&mut self, key: KeyEvent) -> ShResult<Option<ReadlineEvent>> { pub fn handle_key(&mut self, key: KeyEvent) -> ShResult<Option<ReadlineEvent>> {
if self.should_accept_hint(&key) { if self.should_accept_hint(&key) {
log::debug!(
"Accepting hint on key {key:?} in mode {:?}",
self.mode.report_mode()
);
self.editor.accept_hint(); self.editor.accept_hint();
if !self.history.at_pending() { if !self.history.at_pending() {
self.history.reset_to_pending(); self.history.reset_to_pending();
@@ -674,8 +640,7 @@ impl ShedVi {
} }
if let KeyEvent(KeyCode::Tab, mod_keys) = key { if let KeyEvent(KeyCode::Tab, mod_keys) = key {
if self.mode.report_mode() != ModeReport::Ex if self.editor.attempt_history_expansion(&self.history) {
&& self.editor.attempt_history_expansion(&self.history) {
// If history expansion occurred, don't attempt completion yet // If history expansion occurred, don't attempt completion yet
// allow the user to see the expanded command and accept or edit it before completing // allow the user to see the expanded command and accept or edit it before completing
return Ok(None); return Ok(None);
@@ -685,8 +650,8 @@ impl ShedVi {
ModKeys::SHIFT => -1, ModKeys::SHIFT => -1,
_ => 1, _ => 1,
}; };
let line = self.focused_editor().as_str().to_string(); let line = self.editor.as_str().to_string();
let cursor_pos = self.focused_editor().cursor_byte_pos(); let cursor_pos = self.editor.cursor_byte_pos();
match self.completer.complete(line, cursor_pos, direction) { match self.completer.complete(line, cursor_pos, direction) {
Err(e) => { Err(e) => {
@@ -710,8 +675,8 @@ impl ShedVi {
.map(|c| c.len()) .map(|c| c.len())
.unwrap_or_default(); .unwrap_or_default();
self.focused_editor().set_buffer(line.clone()); self.editor.set_buffer(line.clone());
self.focused_editor().cursor.set(new_cursor); self.editor.cursor.set(new_cursor);
if !self.history.at_pending() { if !self.history.at_pending() {
self.history.reset_to_pending(); self.history.reset_to_pending();
@@ -721,14 +686,13 @@ impl ShedVi {
.update_pending_cmd((self.editor.as_str(), self.editor.cursor.get())); .update_pending_cmd((self.editor.as_str(), self.editor.cursor.get()));
let hint = self.history.get_hint(); let hint = self.history.get_hint();
self.editor.set_hint(hint); self.editor.set_hint(hint);
write_vars(|v| { write_vars(|v| {
v.set_var( v.set_var(
"SHED_VI_MODE", "SHED_VI_MODE",
VarKind::Str(self.mode.report_mode().to_string()), VarKind::Str(self.mode.report_mode().to_string()),
VarFlags::NONE, VarFlags::NONE,
) )
}) }).ok();
.ok();
// If we are here, we hit a case where pressing tab returned a single candidate // If we are here, we hit a case where pressing tab returned a single candidate
// So we can just go ahead and reset the completer after this // So we can just go ahead and reset the completer after this
@@ -736,21 +700,15 @@ impl ShedVi {
} }
Ok(None) => { Ok(None) => {
let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnCompletionStart)); let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnCompletionStart));
let candidates = self.completer.all_candidates(); let candidates = self.completer.all_candidates();
let num_candidates = candidates.len(); let num_candidates = candidates.len();
with_vars( with_vars([
[ ("_NUM_MATCHES".into(), Into::<Var>::into(num_candidates)),
("_NUM_MATCHES".into(), Into::<Var>::into(num_candidates)), ("_MATCHES".into(), Into::<Var>::into(candidates)),
("_MATCHES".into(), Into::<Var>::into(candidates)), ("_SEARCH_STR".into(), Into::<Var>::into(self.completer.token())),
( ], || {
"_SEARCH_STR".into(), post_cmds.exec();
Into::<Var>::into(self.completer.token()), });
),
],
|| {
post_cmds.exec();
},
);
if self.completer.is_active() { if self.completer.is_active() {
write_vars(|v| { write_vars(|v| {
@@ -765,26 +723,27 @@ impl ShedVi {
self.needs_redraw = true; self.needs_redraw = true;
self.editor.set_hint(None); self.editor.set_hint(None);
} else { } else {
self.writer.send_bell().ok(); self.writer.send_bell().ok();
} }
} }
} }
self.needs_redraw = true; self.needs_redraw = true;
return Ok(None); return Ok(None);
} else if let KeyEvent(KeyCode::Char('R'), ModKeys::CTRL) = key } else if let KeyEvent(KeyCode::Char('R'), ModKeys::CTRL) = key
&& matches!(self.mode.report_mode(), ModeReport::Insert | ModeReport::Ex) && self.mode.report_mode() == ModeReport::Insert {
{ let initial = self.editor.as_str();
let initial = self.focused_editor().as_str().to_string(); match self.history.start_search(initial) {
match self.focused_history().start_search(&initial) {
Some(entry) => { Some(entry) => {
let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnHistorySelect)); let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnHistorySelect));
with_vars([("_HIST_ENTRY".into(), entry.clone())], || { with_vars([
("_HIST_ENTRY".into(), entry.clone()),
], || {
post_cmds.exec_with(&entry); post_cmds.exec_with(&entry);
}); });
self.focused_editor().set_buffer(entry); self.editor.set_buffer(entry);
self.focused_editor().move_cursor_to_end(); self.editor.move_cursor_to_end();
self self
.history .history
.update_pending_cmd((self.editor.as_str(), self.editor.cursor.get())); .update_pending_cmd((self.editor.as_str(), self.editor.cursor.get()));
@@ -792,32 +751,27 @@ impl ShedVi {
} }
None => { None => {
let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnHistoryOpen)); let post_cmds = read_logic(|l| l.get_autocmds(AutoCmdKind::OnHistoryOpen));
let entries = self.focused_history().fuzzy_finder.candidates().to_vec(); let entries = self.history.fuzzy_finder.candidates();
let matches = self let matches = self.history.fuzzy_finder
.focused_history() .filtered()
.fuzzy_finder .iter()
.filtered() .cloned()
.iter() .map(|sc| sc.content)
.cloned() .collect::<Vec<_>>();
.map(|sc| sc.content)
.collect::<Vec<_>>();
let num_entries = entries.len(); let num_entries = entries.len();
let num_matches = matches.len(); let num_matches = matches.len();
with_vars( with_vars([
[ ("_ENTRIES".into(),Into::<Var>::into(entries)),
("_ENTRIES".into(), Into::<Var>::into(entries)), ("_NUM_ENTRIES".into(),Into::<Var>::into(num_entries)),
("_NUM_ENTRIES".into(), Into::<Var>::into(num_entries)), ("_MATCHES".into(),Into::<Var>::into(matches)),
("_MATCHES".into(), Into::<Var>::into(matches)), ("_NUM_MATCHES".into(),Into::<Var>::into(num_matches)),
("_NUM_MATCHES".into(), Into::<Var>::into(num_matches)), ("_SEARCH_STR".into(), Into::<Var>::into(initial)),
("_SEARCH_STR".into(), Into::<Var>::into(initial)), ], || {
], post_cmds.exec();
|| { });
post_cmds.exec();
},
);
if self.focused_history().fuzzy_finder.is_active() { if self.history.fuzzy_finder.is_active() {
write_vars(|v| { write_vars(|v| {
v.set_var( v.set_var(
"SHED_VI_MODE", "SHED_VI_MODE",
@@ -830,16 +784,23 @@ impl ShedVi {
self.needs_redraw = true; self.needs_redraw = true;
self.editor.set_hint(None); self.editor.set_hint(None);
} else { } else {
self.writer.send_bell().ok(); self.writer.send_bell().ok();
} }
} }
} }
} }
if let KeyEvent(KeyCode::Char('\\'), ModKeys::NONE) = key
&& !self.next_is_escaped
{
self.next_is_escaped = true;
} else {
self.next_is_escaped = false;
}
let Ok(cmd) = self.mode.handle_key_fallible(key) else { let Ok(cmd) = self.mode.handle_key_fallible(key) else {
// it's an ex mode error // it's an ex mode error
self.swap_mode(&mut (Box::new(ViNormal::new()) as Box<dyn ViMode>)); self.mode = Box::new(ViNormal::new()) as Box<dyn ViMode>;
return Ok(None); return Ok(None);
}; };
@@ -855,7 +816,8 @@ impl ShedVi {
} }
if cmd.is_submit_action() if cmd.is_submit_action()
&& !self.editor.cursor_is_escaped() && !self.next_is_escaped
&& !self.editor.buffer.ends_with('\\')
&& (self.should_submit()? || !read_shopts(|o| o.prompt.linebreak_on_incomplete)) && (self.should_submit()? || !read_shopts(|o| o.prompt.linebreak_on_incomplete))
{ {
if self.editor.attempt_history_expansion(&self.history) { if self.editor.attempt_history_expansion(&self.history) {
@@ -874,10 +836,10 @@ impl ShedVi {
} }
if cmd.verb().is_some_and(|v| v.1 == Verb::EndOfFile) { if cmd.verb().is_some_and(|v| v.1 == Verb::EndOfFile) {
if self.focused_editor().buffer.is_empty() { if self.editor.buffer.is_empty() {
return Ok(Some(ReadlineEvent::Eof)); return Ok(Some(ReadlineEvent::Eof));
} else { } else {
*self.focused_editor() = LineBuf::new(); self.editor = LineBuf::new();
self.mode = Box::new(ViInsert::new()); self.mode = Box::new(ViInsert::new());
self.needs_redraw = true; self.needs_redraw = true;
return Ok(None); return Ok(None);
@@ -885,22 +847,9 @@ impl ShedVi {
} }
let has_edit_verb = cmd.verb().is_some_and(|v| v.1.is_edit()); let has_edit_verb = cmd.verb().is_some_and(|v| v.1.is_edit());
let is_shell_cmd = cmd.verb().is_some_and(|v| matches!(v.1, Verb::ShellCmd(_)));
let is_ex_cmd = cmd.flags.contains(CmdFlags::IS_EX_CMD);
log::debug!("is_ex_cmd: {is_ex_cmd}");
if is_shell_cmd {
self.old_layout = None;
}
if is_ex_cmd {
self.ex_history.push(cmd.raw_seq.clone());
self.ex_history.reset();
log::debug!("ex_history: {:?}", self.ex_history.entries());
}
let before = self.editor.buffer.clone(); let before = self.editor.buffer.clone();
self.exec_cmd(cmd, false)?; self.exec_cmd(cmd, false)?;
if let Some(keys) = write_meta(|m| m.take_pending_widget_keys()) { if let Some(keys) = write_meta(|m| m.take_pending_widget_keys()) {
for key in keys { for key in keys {
self.handle_key(key)?; self.handle_key(key)?;
@@ -925,7 +874,7 @@ impl ShedVi {
pub fn get_layout(&mut self, line: &str) -> Layout { pub fn get_layout(&mut self, line: &str) -> Layout {
let to_cursor = self.editor.slice_to_cursor().unwrap_or_default(); let to_cursor = self.editor.slice_to_cursor().unwrap_or_default();
let (cols, _) = get_win_size(self.tty); let (cols, _) = get_win_size(*TTY_FILENO);
Layout::from_parts(cols, self.prompt.get_ps1(), to_cursor, line) Layout::from_parts(cols, self.prompt.get_ps1(), to_cursor, line)
} }
pub fn scroll_history(&mut self, cmd: ViCmd) { pub fn scroll_history(&mut self, cmd: ViCmd) {
@@ -1032,11 +981,7 @@ impl ShedVi {
let one_line = new_layout.end.row == 0; let one_line = new_layout.end.row == 0;
self.completer.clear(&mut self.writer)?; self.completer.clear(&mut self.writer)?;
{ self.history.fuzzy_finder.clear(&mut self.writer)?;
let mut writer = std::mem::take(&mut self.writer);
self.focused_history().fuzzy_finder.clear(&mut writer)?;
self.writer = writer;
}
if let Some(layout) = self.old_layout.as_ref() { if let Some(layout) = self.old_layout.as_ref() {
self.writer.clear_rows(layout)?; self.writer.clear_rows(layout)?;
@@ -1108,7 +1053,6 @@ impl ShedVi {
let pending_seq = self.mode.pending_seq().unwrap_or_default(); let pending_seq = self.mode.pending_seq().unwrap_or_default();
write!(buf, "\n: {pending_seq}").unwrap(); write!(buf, "\n: {pending_seq}").unwrap();
new_layout.end.row += 1; new_layout.end.row += 1;
new_layout.cursor.row += 1;
} }
write!(buf, "{}", &self.mode.cursor_style()).unwrap(); write!(buf, "{}", &self.mode.cursor_style()).unwrap();
@@ -1129,15 +1073,10 @@ impl ShedVi {
self.completer.draw(&mut self.writer)?; self.completer.draw(&mut self.writer)?;
self self
.focused_history() .history
.fuzzy_finder .fuzzy_finder
.set_prompt_line_context(preceding_width, new_layout.cursor.col); .set_prompt_line_context(preceding_width, new_layout.cursor.col);
self.history.fuzzy_finder.draw(&mut self.writer)?;
{
let mut writer = std::mem::take(&mut self.writer);
self.focused_history().fuzzy_finder.draw(&mut writer)?;
self.writer = writer;
}
self.old_layout = Some(new_layout); self.old_layout = Some(new_layout);
self.needs_redraw = false; self.needs_redraw = false;
@@ -1187,14 +1126,10 @@ impl ShedVi {
match cmd.verb().unwrap().1 { match cmd.verb().unwrap().1 {
Verb::Change | Verb::InsertModeLineBreak(_) | Verb::InsertMode => { Verb::Change | Verb::InsertModeLineBreak(_) | Verb::InsertMode => {
is_insert_mode = true; is_insert_mode = true;
Box::new( Box::new(ViInsert::new().with_count(count as u16).record_cmd(cmd.clone()))
ViInsert::new()
.with_count(count as u16)
.record_cmd(cmd.clone()),
)
} }
Verb::ExMode => Box::new(ViEx::new(self.ex_history.clone())), Verb::ExMode => Box::new(ViEx::new()),
Verb::VerbatimMode => { Verb::VerbatimMode => {
self.reader.verbatim_single = true; self.reader.verbatim_single = true;
@@ -1279,17 +1214,17 @@ impl ShedVi {
Ok(()) Ok(())
} }
pub fn clone_mode(&self) -> Box<dyn ViMode> { pub fn clone_mode(&self) -> Box<dyn ViMode> {
match self.mode.report_mode() { match self.mode.report_mode() {
ModeReport::Normal => Box::new(ViNormal::new()), ModeReport::Normal => Box::new(ViNormal::new()),
ModeReport::Insert => Box::new(ViInsert::new()), ModeReport::Insert => Box::new(ViInsert::new()),
ModeReport::Visual => Box::new(ViVisual::new()), ModeReport::Visual => Box::new(ViVisual::new()),
ModeReport::Ex => Box::new(ViEx::new(self.ex_history.clone())), ModeReport::Ex => Box::new(ViEx::new()),
ModeReport::Replace => Box::new(ViReplace::new()), ModeReport::Replace => Box::new(ViReplace::new()),
ModeReport::Verbatim => Box::new(ViVerbatim::new()), ModeReport::Verbatim => Box::new(ViVerbatim::new()),
ModeReport::Unknown => unreachable!(), ModeReport::Unknown => unreachable!(),
} }
} }
pub fn exec_cmd(&mut self, mut cmd: ViCmd, from_replay: bool) -> ShResult<()> { pub fn exec_cmd(&mut self, mut cmd: ViCmd, from_replay: bool) -> ShResult<()> {
if cmd.is_mode_transition() { if cmd.is_mode_transition() {
@@ -1306,35 +1241,35 @@ impl ShedVi {
repeat = count as u16; repeat = count as u16;
} }
let old_mode = self.mode.report_mode(); let old_mode = self.mode.report_mode();
for _ in 0..repeat { for _ in 0..repeat {
let cmds = cmds.clone(); let cmds = cmds.clone();
for (i, cmd) in cmds.iter().enumerate() { for (i, cmd) in cmds.iter().enumerate() {
log::debug!("Replaying command {cmd:?} in mode {:?}, replay {i}/{repeat}", self.mode.report_mode());
self.exec_cmd(cmd.clone(), true)?; self.exec_cmd(cmd.clone(), true)?;
// After the first command, start merging so all subsequent // After the first command, start merging so all subsequent
// edits fold into one undo entry (e.g. cw + inserted chars) // edits fold into one undo entry (e.g. cw + inserted chars)
if i == 0 if i == 0
&& let Some(edit) = self.editor.undo_stack.last_mut() && let Some(edit) = self.editor.undo_stack.last_mut() {
{ edit.start_merge();
edit.start_merge(); }
}
} }
// Stop merging at the end of the replay // Stop merging at the end of the replay
if let Some(edit) = self.editor.undo_stack.last_mut() { if let Some(edit) = self.editor.undo_stack.last_mut() {
edit.stop_merge(); edit.stop_merge();
} }
let old_mode_clone = match old_mode { let old_mode_clone = match old_mode {
ModeReport::Normal => Box::new(ViNormal::new()) as Box<dyn ViMode>, ModeReport::Normal => Box::new(ViNormal::new()) as Box<dyn ViMode>,
ModeReport::Insert => Box::new(ViInsert::new()) as Box<dyn ViMode>, ModeReport::Insert => Box::new(ViInsert::new()) as Box<dyn ViMode>,
ModeReport::Visual => Box::new(ViVisual::new()) as Box<dyn ViMode>, ModeReport::Visual => Box::new(ViVisual::new()) as Box<dyn ViMode>,
ModeReport::Ex => Box::new(ViEx::new(self.ex_history.clone())) as Box<dyn ViMode>, ModeReport::Ex => Box::new(ViEx::new()) as Box<dyn ViMode>,
ModeReport::Replace => Box::new(ViReplace::new()) as Box<dyn ViMode>, ModeReport::Replace => Box::new(ViReplace::new()) as Box<dyn ViMode>,
ModeReport::Verbatim => Box::new(ViVerbatim::new()) as Box<dyn ViMode>, ModeReport::Verbatim => Box::new(ViVerbatim::new()) as Box<dyn ViMode>,
ModeReport::Unknown => unreachable!(), ModeReport::Unknown => unreachable!(),
}; };
self.mode = old_mode_clone; self.mode = old_mode_clone;
} }
} }
CmdReplay::Single(mut cmd) => { CmdReplay::Single(mut cmd) => {
@@ -1416,11 +1351,7 @@ impl ShedVi {
self.editor.exec_cmd(cmd.clone())?; self.editor.exec_cmd(cmd.clone())?;
if self.mode.report_mode() == ModeReport::Visual if self.mode.report_mode() == ModeReport::Visual && cmd.verb().is_some_and(|v| v.1.is_edit() || v.1 == Verb::Yank) {
&& cmd
.verb()
.is_some_and(|v| v.1.is_edit() || v.1 == Verb::Yank)
{
self.editor.stop_selecting(); self.editor.stop_selecting();
let mut mode: Box<dyn ViMode> = Box::new(ViNormal::new()); let mut mode: Box<dyn ViMode> = Box::new(ViNormal::new());
self.swap_mode(&mut mode); self.swap_mode(&mut mode);
@@ -1569,7 +1500,7 @@ pub fn get_insertions(input: &str) -> Vec<(usize, Marker)> {
pub fn marker_for(class: &TkRule) -> Option<Marker> { pub fn marker_for(class: &TkRule) -> Option<Marker> {
match class { match class {
TkRule::Pipe TkRule::Pipe
| TkRule::Bang | TkRule::Bang
| TkRule::ErrPipe | TkRule::ErrPipe
| TkRule::And | TkRule::And
| TkRule::Or | TkRule::Or
@@ -1661,12 +1592,6 @@ pub fn annotate_token(token: Tk) -> Vec<(usize, Marker)> {
let mut insertions: Vec<(usize, Marker)> = vec![]; let mut insertions: Vec<(usize, Marker)> = vec![];
// Heredoc tokens have spans covering the body content far from the <<
// operator, which breaks position tracking after marker insertions
if token.flags.contains(TkFlags::IS_HEREDOC) {
return insertions;
}
if token.class != TkRule::Str if token.class != TkRule::Str
&& let Some(marker) = marker_for(&token.class) && let Some(marker) = marker_for(&token.class)
{ {

14
src/readline/register.rs
View File

@@ -7,17 +7,17 @@ pub static SAVED_REGISTERS: Mutex<Option<Registers>> = Mutex::new(None);
#[cfg(test)] #[cfg(test)]
pub fn save_registers() { pub fn save_registers() {
let mut saved = SAVED_REGISTERS.lock().unwrap(); let mut saved = SAVED_REGISTERS.lock().unwrap();
*saved = Some(REGISTERS.lock().unwrap().clone()); *saved = Some(REGISTERS.lock().unwrap().clone());
} }
#[cfg(test)] #[cfg(test)]
pub fn restore_registers() { pub fn restore_registers() {
let mut saved = SAVED_REGISTERS.lock().unwrap(); let mut saved = SAVED_REGISTERS.lock().unwrap();
if let Some(ref registers) = *saved { if let Some(ref registers) = *saved {
*REGISTERS.lock().unwrap() = registers.clone(); *REGISTERS.lock().unwrap() = registers.clone();
} }
*saved = None; *saved = None;
} }
pub fn read_register(ch: Option<char>) -> Option<RegisterContent> { pub fn read_register(ch: Option<char>) -> Option<RegisterContent> {

257
src/readline/term.rs
View File

@@ -294,14 +294,12 @@ impl Read for TermBuffer {
struct KeyCollector { struct KeyCollector {
events: VecDeque<KeyEvent>, events: VecDeque<KeyEvent>,
ss3_pending: bool,
} }
impl KeyCollector { impl KeyCollector {
fn new() -> Self { fn new() -> Self {
Self { Self {
events: VecDeque::new(), events: VecDeque::new(),
ss3_pending: false,
} }
} }
@@ -339,55 +337,7 @@ impl Default for KeyCollector {
impl Perform for KeyCollector { impl Perform for KeyCollector {
fn print(&mut self, c: char) { fn print(&mut self, c: char) {
log::trace!("print: {c:?}");
// vte routes 0x7f (DEL) to print instead of execute // vte routes 0x7f (DEL) to print instead of execute
if self.ss3_pending {
self.ss3_pending = false;
match c {
'A' => {
self.push(KeyEvent(KeyCode::Up, ModKeys::empty()));
return;
}
'B' => {
self.push(KeyEvent(KeyCode::Down, ModKeys::empty()));
return;
}
'C' => {
self.push(KeyEvent(KeyCode::Right, ModKeys::empty()));
return;
}
'D' => {
self.push(KeyEvent(KeyCode::Left, ModKeys::empty()));
return;
}
'H' => {
self.push(KeyEvent(KeyCode::Home, ModKeys::empty()));
return;
}
'F' => {
self.push(KeyEvent(KeyCode::End, ModKeys::empty()));
return;
}
'P' => {
self.push(KeyEvent(KeyCode::F(1), ModKeys::empty()));
return;
}
'Q' => {
self.push(KeyEvent(KeyCode::F(2), ModKeys::empty()));
return;
}
'R' => {
self.push(KeyEvent(KeyCode::F(3), ModKeys::empty()));
return;
}
'S' => {
self.push(KeyEvent(KeyCode::F(4), ModKeys::empty()));
return;
}
_ => {}
}
}
if c == '\x7f' { if c == '\x7f' {
self.push(KeyEvent(KeyCode::Backspace, ModKeys::empty())); self.push(KeyEvent(KeyCode::Backspace, ModKeys::empty()));
} else { } else {
@@ -396,7 +346,6 @@ impl Perform for KeyCollector {
} }
fn execute(&mut self, byte: u8) { fn execute(&mut self, byte: u8) {
log::trace!("execute: {byte:#04x}");
let event = match byte { let event = match byte {
0x00 => KeyEvent(KeyCode::Char(' '), ModKeys::CTRL), // Ctrl+Space / Ctrl+@ 0x00 => KeyEvent(KeyCode::Char(' '), ModKeys::CTRL), // Ctrl+Space / Ctrl+@
0x09 => KeyEvent(KeyCode::Tab, ModKeys::empty()), // Tab (Ctrl+I) 0x09 => KeyEvent(KeyCode::Tab, ModKeys::empty()), // Tab (Ctrl+I)
@@ -421,9 +370,6 @@ impl Perform for KeyCollector {
_ignore: bool, _ignore: bool,
action: char, action: char,
) { ) {
log::trace!(
"CSI dispatch: params={params:?}, intermediates={intermediates:?}, action={action:?}"
);
let params: Vec<u16> = params let params: Vec<u16> = params
.iter() .iter()
.map(|p| p.first().copied().unwrap_or(0)) .map(|p| p.first().copied().unwrap_or(0))
@@ -498,8 +444,8 @@ impl Perform for KeyCollector {
21 => KeyCode::F(10), 21 => KeyCode::F(10),
23 => KeyCode::F(11), 23 => KeyCode::F(11),
24 => KeyCode::F(12), 24 => KeyCode::F(12),
200 => KeyCode::BracketedPasteStart, 200 => KeyCode::BracketedPasteStart,
201 => KeyCode::BracketedPasteEnd, 201 => KeyCode::BracketedPasteEnd,
_ => return, _ => return,
}; };
KeyEvent(key, mods) KeyEvent(key, mods)
@@ -535,11 +481,16 @@ impl Perform for KeyCollector {
} }
fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, byte: u8) { fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, byte: u8) {
log::trace!("ESC dispatch: intermediates={intermediates:?}, byte={byte:#04x}"); // SS3 sequences (ESC O P/Q/R/S for F1-F4)
// SS3 sequences if intermediates == [b'O'] {
if byte == b'O' { let key = match byte {
self.ss3_pending = true; b'P' => KeyCode::F(1),
return; b'Q' => KeyCode::F(2),
b'R' => KeyCode::F(3),
b'S' => KeyCode::F(4),
_ => return,
};
self.push(KeyEvent(key, ModKeys::empty()));
} }
} }
} }
@@ -547,9 +498,9 @@ impl Perform for KeyCollector {
pub struct PollReader { pub struct PollReader {
parser: Parser, parser: Parser,
collector: KeyCollector, collector: KeyCollector,
byte_buf: VecDeque<u8>, byte_buf: VecDeque<u8>,
pub verbatim_single: bool, pub verbatim_single: bool,
pub verbatim: bool, pub verbatim: bool,
} }
impl PollReader { impl PollReader {
@@ -557,45 +508,42 @@ impl PollReader {
Self { Self {
parser: Parser::new(), parser: Parser::new(),
collector: KeyCollector::new(), collector: KeyCollector::new(),
byte_buf: VecDeque::new(), byte_buf: VecDeque::new(),
verbatim_single: false, verbatim_single: false,
verbatim: false, verbatim: false,
} }
} }
pub fn handle_bracket_paste(&mut self) -> Option<KeyEvent> { pub fn handle_bracket_paste(&mut self) -> Option<KeyEvent> {
let end_marker = b"\x1b[201~"; let end_marker = b"\x1b[201~";
let mut raw = vec![]; let mut raw = vec![];
while let Some(byte) = self.byte_buf.pop_front() { while let Some(byte) = self.byte_buf.pop_front() {
raw.push(byte); raw.push(byte);
if raw.ends_with(end_marker) { if raw.ends_with(end_marker) {
// Strip the end marker from the raw sequence // Strip the end marker from the raw sequence
raw.truncate(raw.len() - end_marker.len()); raw.truncate(raw.len() - end_marker.len());
let paste = String::from_utf8_lossy(&raw).to_string(); let paste = String::from_utf8_lossy(&raw).to_string();
self.verbatim = false; self.verbatim = false;
return Some(KeyEvent(KeyCode::Verbatim(paste.into()), ModKeys::empty())); return Some(KeyEvent(KeyCode::Verbatim(paste.into()), ModKeys::empty()));
} }
} }
self.verbatim = true; self.verbatim = true;
self.byte_buf.extend(raw); self.byte_buf.extend(raw);
None None
} }
pub fn read_one_verbatim(&mut self) -> Option<KeyEvent> { pub fn read_one_verbatim(&mut self) -> Option<KeyEvent> {
if self.byte_buf.is_empty() { if self.byte_buf.is_empty() {
return None; return None;
} }
let bytes: Vec<u8> = self.byte_buf.drain(..).collect(); let bytes: Vec<u8> = self.byte_buf.drain(..).collect();
let verbatim_str = String::from_utf8_lossy(&bytes).to_string(); let verbatim_str = String::from_utf8_lossy(&bytes).to_string();
Some(KeyEvent( Some(KeyEvent(KeyCode::Verbatim(verbatim_str.into()), ModKeys::empty()))
KeyCode::Verbatim(verbatim_str.into()), }
ModKeys::empty(),
))
}
pub fn feed_bytes(&mut self, bytes: &[u8]) { pub fn feed_bytes(&mut self, bytes: &[u8]) {
self.byte_buf.extend(bytes); self.byte_buf.extend(bytes);
} }
} }
@@ -607,42 +555,44 @@ impl Default for PollReader {
impl KeyReader for PollReader { impl KeyReader for PollReader {
fn read_key(&mut self) -> Result<Option<KeyEvent>, ShErr> { fn read_key(&mut self) -> Result<Option<KeyEvent>, ShErr> {
if self.verbatim_single { if self.verbatim_single {
if let Some(key) = self.read_one_verbatim() { if let Some(key) = self.read_one_verbatim() {
self.verbatim_single = false; self.verbatim_single = false;
return Ok(Some(key)); return Ok(Some(key));
} }
return Ok(None); return Ok(None);
} }
if self.verbatim { if self.verbatim {
if let Some(paste) = self.handle_bracket_paste() { if let Some(paste) = self.handle_bracket_paste() {
return Ok(Some(paste)); return Ok(Some(paste));
} }
// If we're in verbatim mode but haven't seen the end marker yet, don't attempt to parse keys // If we're in verbatim mode but haven't seen the end marker yet, don't attempt to parse keys
return Ok(None); return Ok(None);
} else if self.byte_buf.front() == Some(&b'\x1b') { } else if self.byte_buf.front() == Some(&b'\x1b') {
// Escape: if it's the only byte, or the next byte isn't a valid // Escape: if it's the only byte, or the next byte isn't a valid
// escape sequence prefix ([ or O), emit a standalone Escape // escape sequence prefix ([ or O), emit a standalone Escape
if self.byte_buf.len() == 1 || !matches!(self.byte_buf.get(1), Some(b'[') | Some(b'O')) { if self.byte_buf.len() == 1
self.byte_buf.pop_front(); || !matches!(self.byte_buf.get(1), Some(b'[') | Some(b'O'))
return Ok(Some(KeyEvent(KeyCode::Esc, ModKeys::empty()))); {
} self.byte_buf.pop_front();
} return Ok(Some(KeyEvent(KeyCode::Esc, ModKeys::empty())));
while let Some(byte) = self.byte_buf.pop_front() { }
self.parser.advance(&mut self.collector, &[byte]); }
if let Some(key) = self.collector.pop() { while let Some(byte) = self.byte_buf.pop_front() {
match key { self.parser.advance(&mut self.collector, &[byte]);
KeyEvent(KeyCode::BracketedPasteStart, _) => { if let Some(key) = self.collector.pop() {
if let Some(paste) = self.handle_bracket_paste() { match key {
return Ok(Some(paste)); KeyEvent(KeyCode::BracketedPasteStart, _) => {
} else { if let Some(paste) = self.handle_bracket_paste() {
continue; return Ok(Some(paste));
} } else {
} continue;
_ => return Ok(Some(key)), }
} }
} _ => return Ok(Some(key))
} }
}
}
Ok(None) Ok(None)
} }
} }
@@ -893,9 +843,8 @@ impl Default for Layout {
} }
} }
#[derive(Clone, Debug, Default)]
pub struct TermWriter { pub struct TermWriter {
last_bell: Option<Instant>, last_bell: Option<Instant>,
out: RawFd, out: RawFd,
pub t_cols: Col, // terminal width pub t_cols: Col, // terminal width
buffer: String, buffer: String,
@@ -905,7 +854,7 @@ impl TermWriter {
pub fn new(out: RawFd) -> Self { pub fn new(out: RawFd) -> Self {
let (t_cols, _) = get_win_size(out); let (t_cols, _) = get_win_size(out);
Self { Self {
last_bell: None, last_bell: None,
out, out,
t_cols, t_cols,
buffer: String::new(), buffer: String::new(),
@@ -1142,24 +1091,24 @@ impl LineWriter for TermWriter {
Ok(()) Ok(())
} }
fn send_bell(&mut self) -> ShResult<()> { fn send_bell(&mut self) -> ShResult<()> {
if read_shopts(|o| o.core.bell_enabled) { if read_shopts(|o| o.core.bell_enabled) {
// we use a cooldown because I don't like having my ears assaulted by 1 million bells // we use a cooldown because I don't like having my ears assaulted by 1 million bells
// whenever i finish clearing the line using backspace. // whenever i finish clearing the line using backspace.
let now = Instant::now(); let now = Instant::now();
// surprisingly, a fixed cooldown like '100' is actually more annoying than 1 million bells. // surprisingly, a fixed cooldown like '100' is actually more annoying than 1 million bells.
// I've found this range of 50-150 to be the best balance // I've found this range of 50-150 to be the best balance
let cooldown = rand::random_range(50..150); let cooldown = rand::random_range(50..150);
let should_send = match self.last_bell { let should_send = match self.last_bell {
None => true, None => true,
Some(time) => now.duration_since(time).as_millis() > cooldown, Some(time) => now.duration_since(time).as_millis() > cooldown,
}; };
if should_send { if should_send {
self.flush_write("\x07")?; self.flush_write("\x07")?;
self.last_bell = Some(now); self.last_bell = Some(now);
} }
} }
Ok(()) Ok(())
} }
} }

685
src/readline/tests.rs
View File

@@ -1,15 +1,7 @@
#![allow(non_snake_case)] #![allow(non_snake_case)]
use std::os::fd::AsRawFd; use std::os::fd::AsRawFd;
use crate::{ use crate::{readline::{Prompt, ShedVi}, testutil::TestGuard};
readline::{Prompt, ShedVi, annotate_input},
testutil::TestGuard,
};
fn assert_annotated(input: &str, expected: &str) {
let result = annotate_input(input);
assert_eq!(result, expected, "\nInput: {input:?}");
}
/// Tests for our vim logic emulation. Each test consists of an initial text, a sequence of keys to feed, and the expected final text and cursor position. /// Tests for our vim logic emulation. Each test consists of an initial text, a sequence of keys to feed, and the expected final text and cursor position.
macro_rules! vi_test { macro_rules! vi_test {
@@ -31,488 +23,207 @@ macro_rules! vi_test {
}; };
} }
// ===================== Annotation Tests =====================
#[test]
fn annotate_simple_command() {
assert_annotated("echo hello", "\u{e101}echo\u{e11a} \u{e102}hello\u{e11a}");
}
#[test]
fn annotate_pipeline() {
assert_annotated(
"ls | grep foo",
"\u{e100}ls\u{e11a} \u{e104}|\u{e11a} \u{e100}grep\u{e11a} \u{e102}foo\u{e11a}",
);
}
#[test]
fn annotate_conjunction() {
assert_annotated(
"echo foo && echo bar",
"\u{e101}echo\u{e11a} \u{e102}foo\u{e11a} \u{e104}&&\u{e11a} \u{e101}echo\u{e11a} \u{e102}bar\u{e11a}",
);
}
#[test]
fn annotate_redirect_output() {
assert_annotated(
"echo hello > file.txt",
"\u{e101}echo\u{e11a} \u{e102}hello\u{e11a} \u{e105}>\u{e11a} \u{e102}file.txt\u{e11a}",
);
}
#[test]
fn annotate_redirect_append() {
assert_annotated(
"echo hello >> file.txt",
"\u{e101}echo\u{e11a} \u{e102}hello\u{e11a} \u{e105}>>\u{e11a} \u{e102}file.txt\u{e11a}",
);
}
#[test]
fn annotate_redirect_input() {
assert_annotated(
"cat < file.txt",
"\u{e100}cat\u{e11a} \u{e105}<\u{e11a} \u{e102}file.txt\u{e11a}",
);
}
#[test]
fn annotate_fd_redirect() {
assert_annotated("cmd 2>&1", "\u{e100}cmd\u{e11a} \u{e105}2>&1\u{e11a}");
}
#[test]
fn annotate_variable_sub() {
assert_annotated(
"echo $HOME",
"\u{e101}echo\u{e11a} \u{e102}\u{e10c}$HOME\u{e10d}\u{e11a}",
);
}
#[test]
fn annotate_variable_brace_sub() {
assert_annotated(
"echo ${HOME}",
"\u{e101}echo\u{e11a} \u{e102}\u{e10c}${HOME}\u{e10d}\u{e11a}",
);
}
#[test]
fn annotate_command_sub() {
assert_annotated(
"echo $(ls)",
"\u{e101}echo\u{e11a} \u{e102}\u{e10e}$(ls)\u{e10f}\u{e11a}",
);
}
#[test]
fn annotate_single_quoted_string() {
assert_annotated(
"echo 'hello world'",
"\u{e101}echo\u{e11a} \u{e102}\u{e114}'hello world'\u{e115}\u{e11a}",
);
}
#[test]
fn annotate_double_quoted_string() {
assert_annotated(
"echo \"hello world\"",
"\u{e101}echo\u{e11a} \u{e102}\u{e112}\"hello world\"\u{e113}\u{e11a}",
);
}
#[test]
fn annotate_assignment() {
assert_annotated("FOO=bar", "\u{e107}FOO=bar\u{e11a}");
}
#[test]
fn annotate_assignment_with_command() {
assert_annotated(
"FOO=bar echo hello",
"\u{e107}FOO=bar\u{e11a} \u{e101}echo\u{e11a} \u{e102}hello\u{e11a}",
);
}
#[test]
fn annotate_if_statement() {
assert_annotated(
"if true; then echo yes; fi",
"\u{e103}if\u{e11a} \u{e101}true\u{e11a}\u{e108}; \u{e11a}\u{e103}then\u{e11a} \u{e101}echo\u{e11a} \u{e102}yes\u{e11a}\u{e108}; \u{e11a}\u{e103}fi\u{e11a}",
);
}
#[test]
fn annotate_for_loop() {
assert_annotated(
"for i in a b c; do echo $i; done",
"\u{e103}for\u{e11a} \u{e102}i\u{e11a} \u{e103}in\u{e11a} \u{e102}a\u{e11a} \u{e102}b\u{e11a} \u{e102}c\u{e11a}\u{e108}; \u{e11a}\u{e103}do\u{e11a} \u{e101}echo\u{e11a} \u{e102}\u{e10c}$i\u{e10d}\u{e11a}\u{e108}; \u{e11a}\u{e103}done\u{e11a}",
);
}
#[test]
fn annotate_while_loop() {
assert_annotated(
"while true; do echo hello; done",
"\u{e103}while\u{e11a} \u{e101}true\u{e11a}\u{e108}; \u{e11a}\u{e103}do\u{e11a} \u{e101}echo\u{e11a} \u{e102}hello\u{e11a}\u{e108}; \u{e11a}\u{e103}done\u{e11a}",
);
}
#[test]
fn annotate_case_statement() {
assert_annotated(
"case foo in bar) echo bar;; esac",
"\u{e103}case\u{e11a} \u{e102}foo\u{e11a} \u{e103}in\u{e11a} \u{e104}bar\u{e109})\u{e11a} \u{e101}echo\u{e11a} \u{e102}bar\u{e11a}\u{e108};; \u{e11a}\u{e103}esac\u{e11a}",
);
}
#[test]
fn annotate_brace_group() {
assert_annotated(
"{ echo hello; }",
"\u{e104}{\u{e11a} \u{e101}echo\u{e11a} \u{e102}hello\u{e11a}\u{e108}; \u{e11a}\u{e104}}\u{e11a}",
);
}
#[test]
fn annotate_comment() {
assert_annotated(
"echo hello # this is a comment",
"\u{e101}echo\u{e11a} \u{e102}hello\u{e11a} \u{e106}# this is a comment\u{e11a}",
);
}
#[test]
fn annotate_semicolon_sep() {
assert_annotated(
"echo foo; echo bar",
"\u{e101}echo\u{e11a} \u{e102}foo\u{e11a}\u{e108}; \u{e11a}\u{e101}echo\u{e11a} \u{e102}bar\u{e11a}",
);
}
#[test]
fn annotate_escaped_char() {
assert_annotated(
"echo hello\\ world",
"\u{e101}echo\u{e11a} \u{e102}hello\\ world\u{e11a}",
);
}
#[test]
fn annotate_glob() {
assert_annotated(
"ls *.txt",
"\u{e100}ls\u{e11a} \u{e102}\u{e117}*\u{e11a}.txt\u{e11a}",
);
}
#[test]
fn annotate_heredoc_operator() {
assert_annotated(
"cat <<EOF",
"\u{e100}cat\u{e11a} \u{e105}<<\u{e11a}\u{e102}EOF\u{e11a}",
);
}
#[test]
fn annotate_herestring_operator() {
assert_annotated(
"cat <<< hello",
"\u{e100}cat\u{e11a} \u{e105}<<<\u{e11a} \u{e102}hello\u{e11a}",
);
}
#[test]
fn annotate_nested_command_sub() {
assert_annotated(
"echo $(echo $(ls))",
"\u{e101}echo\u{e11a} \u{e102}\u{e10e}$(echo $(ls))\u{e10f}\u{e11a}",
);
}
#[test]
fn annotate_var_in_double_quotes() {
assert_annotated(
"echo \"hello $USER\"",
"\u{e101}echo\u{e11a} \u{e102}\u{e112}\"hello \u{e10c}$USER\u{e10d}\"\u{e113}\u{e11a}",
);
}
#[test]
fn annotate_func_def() {
assert_annotated(
"foo() { echo hello; }",
"\u{e103}foo()\u{e11a} \u{e104}{\u{e11a} \u{e101}echo\u{e11a} \u{e102}hello\u{e11a}\u{e108}; \u{e11a}\u{e104}}\u{e11a}",
);
}
#[test]
fn annotate_negate() {
assert_annotated(
"! echo hello",
"\u{e104}!\u{e11a} \u{e101}echo\u{e11a} \u{e102}hello\u{e11a}",
);
}
#[test]
fn annotate_or_conjunction() {
assert_annotated(
"false || echo fallback",
"\u{e101}false\u{e11a} \u{e104}||\u{e11a} \u{e101}echo\u{e11a} \u{e102}fallback\u{e11a}",
);
}
#[test]
fn annotate_complex_pipeline() {
assert_annotated(
"cat file.txt | grep pattern | wc -l",
"\u{e100}cat\u{e11a} \u{e102}file.txt\u{e11a} \u{e104}|\u{e11a} \u{e100}grep\u{e11a} \u{e102}pattern\u{e11a} \u{e104}|\u{e11a} \u{e100}wc\u{e11a} \u{e102}-l\u{e11a}",
);
}
#[test]
fn annotate_multiple_redirects() {
assert_annotated(
"cmd > out.txt 2> err.txt",
"\u{e100}cmd\u{e11a} \u{e105}>\u{e11a} \u{e102}out.txt\u{e11a} \u{e105}2>\u{e11a} \u{e102}err.txt\u{e11a}",
);
}
// ===================== Vi Tests =====================
fn test_vi(initial: &str) -> (ShedVi, TestGuard) { fn test_vi(initial: &str) -> (ShedVi, TestGuard) {
let g = TestGuard::new(); let g = TestGuard::new();
let prompt = Prompt::default(); let prompt = Prompt::default();
let vi = ShedVi::new_no_hist(prompt, g.pty_slave().as_raw_fd()) let vi = ShedVi::new_no_hist(prompt, g.pty_slave().as_raw_fd())
.unwrap() .unwrap()
.with_initial(initial); .with_initial(initial);
(vi, g) (vi, g)
} }
// Why can't I marry a programming language // Why can't I marry a programming language
vi_test! { vi_test! {
vi_dw_basic : "hello world" => "dw" => "world", 0; vi_dw_basic : "hello world" => "dw" => "world", 0;
vi_dw_middle : "one two three" => "wdw" => "one three", 4; vi_dw_middle : "one two three" => "wdw" => "one three", 4;
vi_dd_whole_line : "hello world" => "dd" => "", 0; vi_dd_whole_line : "hello world" => "dd" => "", 0;
vi_x_single : "hello" => "x" => "ello", 0; vi_x_single : "hello" => "x" => "ello", 0;
vi_x_middle : "hello" => "llx" => "helo", 2; vi_x_middle : "hello" => "llx" => "helo", 2;
vi_X_backdelete : "hello" => "llX" => "hllo", 1; vi_X_backdelete : "hello" => "llX" => "hllo", 1;
vi_h_motion : "hello" => "$h" => "hello", 3; vi_h_motion : "hello" => "$h" => "hello", 3;
vi_l_motion : "hello" => "l" => "hello", 1; vi_l_motion : "hello" => "l" => "hello", 1;
vi_h_at_start : "hello" => "h" => "hello", 0; vi_h_at_start : "hello" => "h" => "hello", 0;
vi_l_at_end : "hello" => "$l" => "hello", 4; vi_l_at_end : "hello" => "$l" => "hello", 4;
vi_w_forward : "one two three" => "w" => "one two three", 4; vi_w_forward : "one two three" => "w" => "one two three", 4;
vi_b_backward : "one two three" => "$b" => "one two three", 8; vi_b_backward : "one two three" => "$b" => "one two three", 8;
vi_e_end : "one two three" => "e" => "one two three", 2; vi_e_end : "one two three" => "e" => "one two three", 2;
vi_ge_back_end : "one two three" => "$ge" => "one two three", 6; vi_ge_back_end : "one two three" => "$ge" => "one two three", 6;
vi_w_punctuation : "foo.bar baz" => "w" => "foo.bar baz", 3; vi_w_punctuation : "foo.bar baz" => "w" => "foo.bar baz", 3;
vi_e_punctuation : "foo.bar baz" => "e" => "foo.bar baz", 2; vi_e_punctuation : "foo.bar baz" => "e" => "foo.bar baz", 2;
vi_b_punctuation : "foo.bar baz" => "$b" => "foo.bar baz", 8; vi_b_punctuation : "foo.bar baz" => "$b" => "foo.bar baz", 8;
vi_w_at_eol : "hello" => "$w" => "hello", 4; vi_w_at_eol : "hello" => "$w" => "hello", 4;
vi_b_at_bol : "hello" => "b" => "hello", 0; vi_b_at_bol : "hello" => "b" => "hello", 0;
vi_W_forward : "foo.bar baz" => "W" => "foo.bar baz", 8; vi_W_forward : "foo.bar baz" => "W" => "foo.bar baz", 8;
vi_B_backward : "foo.bar baz" => "$B" => "foo.bar baz", 8; vi_B_backward : "foo.bar baz" => "$B" => "foo.bar baz", 8;
vi_E_end : "foo.bar baz" => "E" => "foo.bar baz", 6; vi_E_end : "foo.bar baz" => "E" => "foo.bar baz", 6;
vi_gE_back_end : "one two three" => "$gE" => "one two three", 6; vi_gE_back_end : "one two three" => "$gE" => "one two three", 6;
vi_W_skip_punct : "one-two three" => "W" => "one-two three", 8; vi_W_skip_punct : "one-two three" => "W" => "one-two three", 8;
vi_B_skip_punct : "one two-three" => "$B" => "one two-three", 4; vi_B_skip_punct : "one two-three" => "$B" => "one two-three", 4;
vi_E_skip_punct : "one-two three" => "E" => "one-two three", 6; vi_E_skip_punct : "one-two three" => "E" => "one-two three", 6;
vi_dW_big : "foo.bar baz" => "dW" => "baz", 0; vi_dW_big : "foo.bar baz" => "dW" => "baz", 0;
vi_cW_big : "foo.bar baz" => "cWx\x1b" => "x baz", 0; vi_cW_big : "foo.bar baz" => "cWx\x1b" => "x baz", 0;
vi_zero_bol : " hello" => "$0" => " hello", 0; vi_zero_bol : " hello" => "$0" => " hello", 0;
vi_caret_first_char : " hello" => "$^" => " hello", 2; vi_caret_first_char : " hello" => "$^" => " hello", 2;
vi_dollar_eol : "hello world" => "$" => "hello world", 10; vi_dollar_eol : "hello world" => "$" => "hello world", 10;
vi_g_last_nonws : "hello " => "g_" => "hello ", 4; vi_g_last_nonws : "hello " => "g_" => "hello ", 4;
vi_g_no_trailing : "hello" => "g_" => "hello", 4; vi_g_no_trailing : "hello" => "g_" => "hello", 4;
vi_pipe_column : "hello world" => "6|" => "hello world", 5; vi_pipe_column : "hello world" => "6|" => "hello world", 5;
vi_pipe_col1 : "hello world" => "1|" => "hello world", 0; vi_pipe_col1 : "hello world" => "1|" => "hello world", 0;
vi_I_insert_front : " hello" => "Iworld \x1b" => " world hello", 7; vi_I_insert_front : " hello" => "Iworld \x1b" => " world hello", 7;
vi_A_append_end : "hello" => "A world\x1b" => "hello world", 10; vi_A_append_end : "hello" => "A world\x1b" => "hello world", 10;
vi_f_find : "hello world" => "fo" => "hello world", 4; vi_f_find : "hello world" => "fo" => "hello world", 4;
vi_F_find_back : "hello world" => "$Fo" => "hello world", 7; vi_F_find_back : "hello world" => "$Fo" => "hello world", 7;
vi_t_till : "hello world" => "tw" => "hello world", 5; vi_t_till : "hello world" => "tw" => "hello world", 5;
vi_T_till_back : "hello world" => "$To" => "hello world", 8; vi_T_till_back : "hello world" => "$To" => "hello world", 8;
vi_f_no_match : "hello" => "fz" => "hello", 0; vi_f_no_match : "hello" => "fz" => "hello", 0;
vi_semicolon_repeat : "abcabc" => "fa;;" => "abcabc", 3; vi_semicolon_repeat : "abcabc" => "fa;;" => "abcabc", 3;
vi_comma_reverse : "abcabc" => "fa;;," => "abcabc", 0; vi_comma_reverse : "abcabc" => "fa;;," => "abcabc", 0;
vi_df_semicolon : "abcabc" => "fa;;dfa" => "abcabc", 3; vi_df_semicolon : "abcabc" => "fa;;dfa" => "abcabc", 3;
vi_t_at_target : "aab" => "lta" => "aab", 1; vi_t_at_target : "aab" => "lta" => "aab", 1;
vi_D_to_end : "hello world" => "wD" => "hello ", 5; vi_D_to_end : "hello world" => "wD" => "hello ", 5;
vi_d_dollar : "hello world" => "wd$" => "hello ", 5; vi_d_dollar : "hello world" => "wd$" => "hello ", 5;
vi_d0_to_start : "hello world" => "$d0" => "d", 0; vi_d0_to_start : "hello world" => "$d0" => "d", 0;
vi_dw_multiple : "one two three" => "d2w" => "three", 0; vi_dw_multiple : "one two three" => "d2w" => "three", 0;
vi_dt_char : "hello world" => "dtw" => "world", 0; vi_dt_char : "hello world" => "dtw" => "world", 0;
vi_df_char : "hello world" => "dfw" => "orld", 0; vi_df_char : "hello world" => "dfw" => "orld", 0;
vi_dh_back : "hello" => "lldh" => "hllo", 1; vi_dh_back : "hello" => "lldh" => "hllo", 1;
vi_dl_forward : "hello" => "dl" => "ello", 0; vi_dl_forward : "hello" => "dl" => "ello", 0;
vi_dge_back_end : "one two three" => "$dge" => "one tw", 5; vi_dge_back_end : "one two three" => "$dge" => "one tw", 5;
vi_dG_to_end : "hello world" => "dG" => "", 0; vi_dG_to_end : "hello world" => "dG" => "", 0;
vi_dgg_to_start : "hello world" => "$dgg" => "", 0; vi_dgg_to_start : "hello world" => "$dgg" => "", 0;
vi_d_semicolon : "abcabc" => "fad;" => "abcabc", 3; vi_d_semicolon : "abcabc" => "fad;" => "abcabc", 3;
vi_cw_basic : "hello world" => "cwfoo\x1b" => "foo world", 2; vi_cw_basic : "hello world" => "cwfoo\x1b" => "foo world", 2;
vi_C_to_end : "hello world" => "wCfoo\x1b" => "hello foo", 8; vi_C_to_end : "hello world" => "wCfoo\x1b" => "hello foo", 8;
vi_cc_whole : "hello world" => "ccfoo\x1b" => "foo", 2; vi_cc_whole : "hello world" => "ccfoo\x1b" => "foo", 2;
vi_ct_char : "hello world" => "ctwfoo\x1b" => "fooworld", 2; vi_ct_char : "hello world" => "ctwfoo\x1b" => "fooworld", 2;
vi_s_single : "hello" => "sfoo\x1b" => "fooello", 2; vi_s_single : "hello" => "sfoo\x1b" => "fooello", 2;
vi_S_whole_line : "hello world" => "Sfoo\x1b" => "foo", 2; vi_S_whole_line : "hello world" => "Sfoo\x1b" => "foo", 2;
vi_cl_forward : "hello" => "clX\x1b" => "Xello", 0; vi_cl_forward : "hello" => "clX\x1b" => "Xello", 0;
vi_ch_backward : "hello" => "llchX\x1b" => "hXllo", 1; vi_ch_backward : "hello" => "llchX\x1b" => "hXllo", 1;
vi_cb_word_back : "hello world" => "$cbfoo\x1b" => "hello food", 8; vi_cb_word_back : "hello world" => "$cbfoo\x1b" => "hello food", 8;
vi_ce_word_end : "hello world" => "cefoo\x1b" => "foo world", 2; vi_ce_word_end : "hello world" => "cefoo\x1b" => "foo world", 2;
vi_c0_to_start : "hello world" => "wc0foo\x1b" => "fooworld", 2; vi_c0_to_start : "hello world" => "wc0foo\x1b" => "fooworld", 2;
vi_yw_p_basic : "hello world" => "ywwP" => "hello hello world", 11; vi_yw_p_basic : "hello world" => "ywwP" => "hello hello world", 11;
vi_dw_p_paste : "hello world" => "dwP" => "hello world", 5; vi_dw_p_paste : "hello world" => "dwP" => "hello world", 5;
vi_dd_p_paste : "hello world" => "ddp" => "\nhello world", 1; vi_dd_p_paste : "hello world" => "ddp" => "\nhello world", 1;
vi_y_dollar_p : "hello world" => "wy$P" => "hello worldworld", 10; vi_y_dollar_p : "hello world" => "wy$P" => "hello worldworld", 10;
vi_ye_p : "hello world" => "yewP" => "hello helloworld", 10; vi_ye_p : "hello world" => "yewP" => "hello helloworld", 10;
vi_yy_p : "hello world" => "yyp" => "hello world\nhello world", 12; vi_yy_p : "hello world" => "yyp" => "hello world\nhello world", 12;
vi_Y_p : "hello world" => "Yp" => "hhello worldello world", 11; vi_Y_p : "hello world" => "Yp" => "hhello worldello world", 11;
vi_p_after_x : "hello" => "xp" => "ehllo", 1; vi_p_after_x : "hello" => "xp" => "ehllo", 1;
vi_P_before : "hello" => "llxP" => "hello", 2; vi_P_before : "hello" => "llxP" => "hello", 2;
vi_paste_empty : "hello" => "p" => "hello", 0; vi_paste_empty : "hello" => "p" => "hello", 0;
vi_r_replace : "hello" => "ra" => "aello", 0; vi_r_replace : "hello" => "ra" => "aello", 0;
vi_r_middle : "hello" => "llra" => "healo", 2; vi_r_middle : "hello" => "llra" => "healo", 2;
vi_r_at_end : "hello" => "$ra" => "hella", 4; vi_r_at_end : "hello" => "$ra" => "hella", 4;
vi_r_space : "hello" => "r " => " ello", 0; vi_r_space : "hello" => "r " => " ello", 0;
vi_r_with_count : "hello" => "3rx" => "xxxlo", 2; vi_r_with_count : "hello" => "3rx" => "xxxlo", 2;
vi_tilde_single : "hello" => "~" => "Hello", 1; vi_tilde_single : "hello" => "~" => "Hello", 1;
vi_tilde_count : "hello" => "3~" => "HELlo", 3; vi_tilde_count : "hello" => "3~" => "HELlo", 3;
vi_tilde_at_end : "HELLO" => "$~" => "HELLo", 4; vi_tilde_at_end : "HELLO" => "$~" => "HELLo", 4;
vi_tilde_mixed : "hElLo" => "5~" => "HeLlO", 4; vi_tilde_mixed : "hElLo" => "5~" => "HeLlO", 4;
vi_gu_word : "HELLO world" => "guw" => "hello world", 0; vi_gu_word : "HELLO world" => "guw" => "hello world", 0;
vi_gU_word : "hello WORLD" => "gUw" => "HELLO WORLD", 0; vi_gU_word : "hello WORLD" => "gUw" => "HELLO WORLD", 0;
vi_gu_dollar : "HELLO WORLD" => "gu$" => "hello world", 0; vi_gu_dollar : "HELLO WORLD" => "gu$" => "hello world", 0;
vi_gU_dollar : "hello world" => "gU$" => "HELLO WORLD", 0; vi_gU_dollar : "hello world" => "gU$" => "HELLO WORLD", 0;
vi_gu_0 : "HELLO WORLD" => "$gu0" => "hello worlD", 0; vi_gu_0 : "HELLO WORLD" => "$gu0" => "hello worlD", 0;
vi_gU_0 : "hello world" => "$gU0" => "HELLO WORLd", 0; vi_gU_0 : "hello world" => "$gU0" => "HELLO WORLd", 0;
vi_gtilde_word : "hello WORLD" => "g~w" => "HELLO WORLD", 0; vi_gtilde_word : "hello WORLD" => "g~w" => "HELLO WORLD", 0;
vi_gtilde_dollar : "hello WORLD" => "g~$" => "HELLO world", 0; vi_gtilde_dollar : "hello WORLD" => "g~$" => "HELLO world", 0;
vi_diw_inner : "one two three" => "wdiw" => "one three", 4; vi_diw_inner : "one two three" => "wdiw" => "one three", 4;
vi_ciw_replace : "hello world" => "ciwfoo\x1b" => "foo world", 2; vi_ciw_replace : "hello world" => "ciwfoo\x1b" => "foo world", 2;
vi_daw_around : "one two three" => "wdaw" => "one three", 4; vi_daw_around : "one two three" => "wdaw" => "one three", 4;
vi_yiw_p : "hello world" => "yiwAp \x1bp" => "hello worldp hello", 17; vi_yiw_p : "hello world" => "yiwAp \x1bp" => "hello worldp hello", 17;
vi_diW_big_inner : "one-two three" => "diW" => " three", 0; vi_diW_big_inner : "one-two three" => "diW" => " three", 0;
vi_daW_big_around : "one two-three end" => "wdaW" => "one end", 4; vi_daW_big_around : "one two-three end" => "wdaW" => "one end", 4;
vi_ciW_big : "one-two three" => "ciWx\x1b" => "x three", 0; vi_ciW_big : "one-two three" => "ciWx\x1b" => "x three", 0;
vi_di_dquote : "one \"two\" three" => "f\"di\"" => "one \"\" three", 5; vi_di_dquote : "one \"two\" three" => "f\"di\"" => "one \"\" three", 5;
vi_da_dquote : "one \"two\" three" => "f\"da\"" => "one three", 4; vi_da_dquote : "one \"two\" three" => "f\"da\"" => "one three", 4;
vi_ci_dquote : "one \"two\" three" => "f\"ci\"x\x1b" => "one \"x\" three", 5; vi_ci_dquote : "one \"two\" three" => "f\"ci\"x\x1b" => "one \"x\" three", 5;
vi_di_squote : "one 'two' three" => "f'di'" => "one '' three", 5; vi_di_squote : "one 'two' three" => "f'di'" => "one '' three", 5;
vi_da_squote : "one 'two' three" => "f'da'" => "one three", 4; vi_da_squote : "one 'two' three" => "f'da'" => "one three", 4;
vi_di_backtick : "one `two` three" => "f`di`" => "one `` three", 5; vi_di_backtick : "one `two` three" => "f`di`" => "one `` three", 5;
vi_da_backtick : "one `two` three" => "f`da`" => "one three", 4; vi_da_backtick : "one `two` three" => "f`da`" => "one three", 4;
vi_ci_dquote_empty : "one \"\" three" => "f\"ci\"x\x1b" => "one \"x\" three", 5; vi_ci_dquote_empty : "one \"\" three" => "f\"ci\"x\x1b" => "one \"x\" three", 5;
vi_di_paren : "one (two) three" => "f(di(" => "one () three", 5; vi_di_paren : "one (two) three" => "f(di(" => "one () three", 5;
vi_da_paren : "one (two) three" => "f(da(" => "one three", 4; vi_da_paren : "one (two) three" => "f(da(" => "one three", 4;
vi_ci_paren : "one (two) three" => "f(ci(x\x1b" => "one (x) three", 5; vi_ci_paren : "one (two) three" => "f(ci(x\x1b" => "one (x) three", 5;
vi_di_brace : "one {two} three" => "f{di{" => "one {} three", 5; vi_di_brace : "one {two} three" => "f{di{" => "one {} three", 5;
vi_da_brace : "one {two} three" => "f{da{" => "one three", 4; vi_da_brace : "one {two} three" => "f{da{" => "one three", 4;
vi_di_bracket : "one [two] three" => "f[di[" => "one [] three", 5; vi_di_bracket : "one [two] three" => "f[di[" => "one [] three", 5;
vi_da_bracket : "one [two] three" => "f[da[" => "one three", 4; vi_da_bracket : "one [two] three" => "f[da[" => "one three", 4;
vi_di_angle : "one <two> three" => "f<di<" => "one <> three", 5; vi_di_angle : "one <two> three" => "f<di<" => "one <> three", 5;
vi_da_angle : "one <two> three" => "f<da<" => "one three", 4; vi_da_angle : "one <two> three" => "f<da<" => "one three", 4;
vi_di_paren_nested : "fn(a, (b, c))" => "f(di(" => "fn()", 3; vi_di_paren_nested : "fn(a, (b, c))" => "f(di(" => "fn()", 3;
vi_di_paren_empty : "fn() end" => "f(di(" => "fn() end", 3; vi_di_paren_empty : "fn() end" => "f(di(" => "fn() end", 3;
vi_dib_alias : "one (two) three" => "f(dib" => "one () three", 5; vi_dib_alias : "one (two) three" => "f(dib" => "one () three", 5;
vi_diB_alias : "one {two} three" => "f{diB" => "one {} three", 5; vi_diB_alias : "one {two} three" => "f{diB" => "one {} three", 5;
vi_percent_paren : "(hello) world" => "%" => "(hello) world", 6; vi_percent_paren : "(hello) world" => "%" => "(hello) world", 6;
vi_percent_brace : "{hello} world" => "%" => "{hello} world", 6; vi_percent_brace : "{hello} world" => "%" => "{hello} world", 6;
vi_percent_bracket : "[hello] world" => "%" => "[hello] world", 6; vi_percent_bracket : "[hello] world" => "%" => "[hello] world", 6;
vi_percent_from_close: "(hello) world" => "f)%" => "(hello) world", 0; vi_percent_from_close: "(hello) world" => "f)%" => "(hello) world", 0;
vi_d_percent_paren : "(hello) world" => "d%" => " world", 0; vi_d_percent_paren : "(hello) world" => "d%" => " world", 0;
vi_i_insert : "hello" => "iX\x1b" => "Xhello", 0; vi_i_insert : "hello" => "iX\x1b" => "Xhello", 0;
vi_a_append : "hello" => "aX\x1b" => "hXello", 1; vi_a_append : "hello" => "aX\x1b" => "hXello", 1;
vi_I_front : " hello" => "IX\x1b" => " Xhello", 2; vi_I_front : " hello" => "IX\x1b" => " Xhello", 2;
vi_A_end : "hello" => "AX\x1b" => "helloX", 5; vi_A_end : "hello" => "AX\x1b" => "helloX", 5;
vi_o_open_below : "hello" => "oworld\x1b" => "hello\nworld", 10; vi_o_open_below : "hello" => "oworld\x1b" => "hello\nworld", 10;
vi_O_open_above : "hello" => "Oworld\x1b" => "world\nhello", 4; vi_O_open_above : "hello" => "Oworld\x1b" => "world\nhello", 4;
vi_empty_input : "" => "i hello\x1b" => " hello", 5; vi_empty_input : "" => "i hello\x1b" => " hello", 5;
vi_insert_escape : "hello" => "aX\x1b" => "hXello", 1; vi_insert_escape : "hello" => "aX\x1b" => "hXello", 1;
vi_ctrl_w_del_word : "hello world" => "A\x17\x1b" => "hello ", 5; vi_ctrl_w_del_word : "hello world" => "A\x17\x1b" => "hello ", 5;
vi_ctrl_h_backspace : "hello" => "A\x08\x1b" => "hell", 3; vi_ctrl_h_backspace : "hello" => "A\x08\x1b" => "hell", 3;
vi_u_undo_delete : "hello world" => "dwu" => "hello world", 0; vi_u_undo_delete : "hello world" => "dwu" => "hello world", 0;
vi_u_undo_change : "hello world" => "ciwfoo\x1bu" => "hello world", 0; vi_u_undo_change : "hello world" => "ciwfoo\x1bu" => "hello world", 0;
vi_u_undo_x : "hello" => "xu" => "hello", 0; vi_u_undo_x : "hello" => "xu" => "hello", 0;
vi_ctrl_r_redo : "hello" => "xu\x12" => "ello", 0; vi_ctrl_r_redo : "hello" => "xu\x12" => "ello", 0;
vi_u_multiple : "hello world" => "xdwu" => "ello world", 0; vi_u_multiple : "hello world" => "xdwu" => "ello world", 0;
vi_redo_after_undo : "hello world" => "dwu\x12" => "world", 0; vi_redo_after_undo : "hello world" => "dwu\x12" => "world", 0;
vi_dot_repeat_x : "hello" => "x." => "llo", 0; vi_dot_repeat_x : "hello" => "x." => "llo", 0;
vi_dot_repeat_dw : "one two three" => "dw." => "three", 0; vi_dot_repeat_dw : "one two three" => "dw." => "three", 0;
vi_dot_repeat_cw : "one two three" => "cwfoo\x1bw." => "foo foo three", 6; vi_dot_repeat_cw : "one two three" => "cwfoo\x1bw." => "foo foo three", 6;
vi_dot_repeat_r : "hello" => "ra.." => "aello", 0; vi_dot_repeat_r : "hello" => "ra.." => "aello", 0;
vi_dot_repeat_s : "hello" => "sX\x1bl." => "XXllo", 1; vi_dot_repeat_s : "hello" => "sX\x1bl." => "XXllo", 1;
vi_count_h : "hello world" => "$3h" => "hello world", 7; vi_count_h : "hello world" => "$3h" => "hello world", 7;
vi_count_l : "hello world" => "3l" => "hello world", 3; vi_count_l : "hello world" => "3l" => "hello world", 3;
vi_count_w : "one two three four" => "2w" => "one two three four", 8; vi_count_w : "one two three four" => "2w" => "one two three four", 8;
vi_count_b : "one two three four" => "$2b" => "one two three four", 8; vi_count_b : "one two three four" => "$2b" => "one two three four", 8;
vi_count_x : "hello" => "3x" => "lo", 0; vi_count_x : "hello" => "3x" => "lo", 0;
vi_count_dw : "one two three four" => "2dw" => "three four", 0; vi_count_dw : "one two three four" => "2dw" => "three four", 0;
vi_verb_count_motion : "one two three four" => "d2w" => "three four", 0; vi_verb_count_motion : "one two three four" => "d2w" => "three four", 0;
vi_count_s : "hello" => "3sX\x1b" => "Xlo", 0; vi_count_s : "hello" => "3sX\x1b" => "Xlo", 0;
vi_indent_line : "hello" => ">>" => "\thello", 1; vi_indent_line : "hello" => ">>" => "\thello", 0;
vi_dedent_line : "\thello" => "<<" => "hello", 0; vi_dedent_line : "\thello" => "<<" => "hello", 0;
vi_indent_double : "hello" => ">>>>" => "\t\thello", 2; vi_indent_double : "hello" => ">>>>" => "\t\thello", 0;
vi_J_join_lines : "hello\nworld" => "J" => "hello world", 5; vi_J_join_lines : "hello\nworld" => "J" => "hello world", 5;
vi_v_u_lower : "HELLO" => "vlllu" => "hellO", 0; vi_v_u_lower : "HELLO" => "vlllu" => "hellO", 0;
vi_v_U_upper : "hello" => "vlllU" => "HELLo", 0; vi_v_U_upper : "hello" => "vlllU" => "HELLo", 0;
vi_v_d_delete : "hello world" => "vwwd" => "", 0; vi_v_d_delete : "hello world" => "vwwd" => "", 0;
vi_v_x_delete : "hello world" => "vwwx" => "", 0; vi_v_x_delete : "hello world" => "vwwx" => "", 0;
vi_v_c_change : "hello world" => "vwcfoo\x1b" => "fooorld", 2; vi_v_c_change : "hello world" => "vwcfoo\x1b" => "fooorld", 2;
vi_v_y_p_yank : "hello world" => "vwyAp \x1bp" => "hello worldp hello w", 19; vi_v_y_p_yank : "hello world" => "vwyAp \x1bp" => "hello worldp hello w", 19;
vi_v_dollar_d : "hello world" => "wv$d" => "hello ", 5; vi_v_dollar_d : "hello world" => "wv$d" => "hello ", 5;
vi_v_0_d : "hello world" => "$v0d" => "", 0; vi_v_0_d : "hello world" => "$v0d" => "", 0;
vi_ve_d : "hello world" => "ved" => " world", 0; vi_ve_d : "hello world" => "ved" => " world", 0;
vi_v_o_swap : "hello world" => "vllod" => "lo world", 0; vi_v_o_swap : "hello world" => "vllod" => "lo world", 0;
vi_v_r_replace : "hello" => "vlllrx" => "xxxxo", 0; vi_v_r_replace : "hello" => "vlllrx" => "xxxxo", 0;
vi_v_tilde_case : "hello" => "vlll~" => "HELLo", 0; vi_v_tilde_case : "hello" => "vlll~" => "HELLo", 0;
vi_V_d_delete : "hello world" => "Vd" => "", 0; vi_V_d_delete : "hello world" => "Vd" => "", 0;
vi_V_y_p : "hello world" => "Vyp" => "hello world\nhello world", 12; vi_V_y_p : "hello world" => "Vyp" => "hello world\nhello world", 12;
vi_V_S_change : "hello world" => "VSfoo\x1b" => "foo", 2; vi_V_S_change : "hello world" => "VSfoo\x1b" => "foo", 2;
vi_ctrl_a_inc : "num 5 end" => "w\x01" => "num 6 end", 4; vi_ctrl_a_inc : "num 5 end" => "w\x01" => "num 6 end", 4;
vi_ctrl_x_dec : "num 5 end" => "w\x18" => "num 4 end", 4; vi_ctrl_x_dec : "num 5 end" => "w\x18" => "num 4 end", 4;
vi_ctrl_a_negative : "num -3 end" => "w\x01" => "num -2 end", 4; vi_ctrl_a_negative : "num -3 end" => "w\x01" => "num -2 end", 4;
vi_ctrl_x_to_neg : "num 0 end" => "w\x18" => "num -1 end", 4; vi_ctrl_x_to_neg : "num 0 end" => "w\x18" => "num -1 end", 4;
vi_ctrl_a_count : "num 5 end" => "w3\x01" => "num 8 end", 4; vi_ctrl_a_count : "num 5 end" => "w3\x01" => "num 8 end", 4;
vi_ctrl_a_width : "num -00001 end" => "w\x01" => "num 00000 end", 4; vi_ctrl_a_width : "num -00001 end" => "w\x01" => "num 00000 end", 4;
vi_delete_empty : "" => "x" => "", 0; vi_delete_empty : "" => "x" => "", 0;
vi_undo_on_empty : "" => "u" => "", 0; vi_undo_on_empty : "" => "u" => "", 0;
vi_w_single_char : "a b c" => "w" => "a b c", 2; vi_w_single_char : "a b c" => "w" => "a b c", 2;
vi_dw_last_word : "hello" => "dw" => "", 0; vi_dw_last_word : "hello" => "dw" => "", 0;
vi_dollar_single : "h" => "$" => "h", 0; vi_dollar_single : "h" => "$" => "h", 0;
vi_caret_no_ws : "hello" => "$^" => "hello", 0; vi_caret_no_ws : "hello" => "$^" => "hello", 0;
vi_f_last_char : "hello" => "fo" => "hello", 4; vi_f_last_char : "hello" => "fo" => "hello", 4;
vi_r_on_space : "hello world" => "5|r-" => "hell- world", 4; vi_r_on_space : "hello world" => "5|r-" => "hell- world", 4
vi_vw_doesnt_crash : "" => "vw" => "", 0;
vi_indent_cursor_pos : "echo foo" => ">>" => "\techo foo", 1;
vi_join_indent_lines : "echo foo\n\t\techo bar" => "J" => "echo foo echo bar", 8
}
#[test]
fn vi_auto_indent() {
let (mut vi, _g) = test_vi("");
// Type each line and press Enter separately so auto-indent triggers
let lines = [
"func() {",
"case foo in",
"bar)",
"while true; do",
"echo foo \\\rbar \\\rbiz \\\rbazz\rbreak\rdone\r;;\resac\r}",
];
for (i, line) in lines.iter().enumerate() {
vi.feed_bytes(line.as_bytes());
if i != lines.len() - 1 {
vi.feed_bytes(b"\r");
}
vi.process_input().unwrap();
}
assert_eq!(
vi.editor.as_str(),
"func() {\n\tcase foo in\n\t\tbar)\n\t\t\twhile true; do\n\t\t\t\techo foo \\\n\t\t\t\t\tbar \\\n\t\t\t\t\tbiz \\\n\t\t\t\t\tbazz\n\t\t\t\tbreak\n\t\t\tdone\n\t\t;;\n\tesac\n}"
);
} }

32
src/readline/vicmd.rs
View File

@@ -1,9 +1,5 @@
use std::path::PathBuf;
use bitflags::bitflags; use bitflags::bitflags;
use crate::readline::vimode::ex::SubFlags;
use super::register::{RegisterContent, append_register, read_register, write_register}; use super::register::{RegisterContent, append_register, read_register, write_register};
//TODO: write tests that take edit results and cursor positions from actual //TODO: write tests that take edit results and cursor positions from actual
@@ -68,7 +64,6 @@ bitflags! {
const VISUAL_LINE = 1<<1; const VISUAL_LINE = 1<<1;
const VISUAL_BLOCK = 1<<2; const VISUAL_BLOCK = 1<<2;
const EXIT_CUR_MODE = 1<<3; const EXIT_CUR_MODE = 1<<3;
const IS_EX_CMD = 1<<4;
} }
} }
@@ -260,8 +255,7 @@ pub enum Verb {
Normal(String), Normal(String),
Read(ReadSrc), Read(ReadSrc),
Write(WriteDest), Write(WriteDest),
Edit(PathBuf), Substitute(String, String, super::vimode::ex::SubFlags),
Substitute(String, String, SubFlags),
RepeatSubstitute, RepeatSubstitute,
RepeatGlobal, RepeatGlobal,
} }
@@ -307,9 +301,6 @@ impl Verb {
| Self::JoinLines | Self::JoinLines
| Self::InsertChar(_) | Self::InsertChar(_)
| Self::Insert(_) | Self::Insert(_)
| Self::Dedent
| Self::Indent
| Self::Equalize
| Self::Rot13 | Self::Rot13
| Self::EndOfFile | Self::EndOfFile
| Self::IncrementNumber(_) | Self::IncrementNumber(_)
@@ -341,8 +332,16 @@ pub enum Motion {
ForwardCharForced, ForwardCharForced,
LineUp, LineUp,
LineUpCharwise, LineUpCharwise,
ScreenLineUp,
ScreenLineUpCharwise,
LineDown, LineDown,
LineDownCharwise, LineDownCharwise,
ScreenLineDown,
ScreenLineDownCharwise,
BeginningOfScreenLine,
FirstGraphicalOnScreenLine,
HalfOfScreen,
HalfOfScreenLineText,
WholeBuffer, WholeBuffer,
StartOfBuffer, StartOfBuffer,
EndOfBuffer, EndOfBuffer,
@@ -382,8 +381,12 @@ impl Motion {
&self, &self,
Self::BeginningOfLine Self::BeginningOfLine
| Self::BeginningOfFirstWord | Self::BeginningOfFirstWord
| Self::BeginningOfScreenLine
| Self::FirstGraphicalOnScreenLine
| Self::LineDownCharwise | Self::LineDownCharwise
| Self::LineUpCharwise | Self::LineUpCharwise
| Self::ScreenLineUpCharwise
| Self::ScreenLineDownCharwise
| Self::ToColumn | Self::ToColumn
| Self::TextObj(TextObj::Sentence(_)) | Self::TextObj(TextObj::Sentence(_))
| Self::TextObj(TextObj::Paragraph(_)) | Self::TextObj(TextObj::Paragraph(_))
@@ -392,13 +395,20 @@ impl Motion {
| Self::ToBrace(_) | Self::ToBrace(_)
| Self::ToBracket(_) | Self::ToBracket(_)
| Self::ToParen(_) | Self::ToParen(_)
| Self::ScreenLineDown
| Self::ScreenLineUp
| Self::Range(_, _) | Self::Range(_, _)
) )
} }
pub fn is_linewise(&self) -> bool { pub fn is_linewise(&self) -> bool {
matches!( matches!(
self, self,
Self::WholeLineInclusive | Self::WholeLineExclusive | Self::LineUp | Self::LineDown Self::WholeLineInclusive
| Self::WholeLineExclusive
| Self::LineUp
| Self::LineDown
| Self::ScreenLineDown
| Self::ScreenLineUp
) )
} }
} }

149
src/readline/vimode/ex.rs
View File

@@ -5,11 +5,7 @@ use std::str::Chars;
use itertools::Itertools; use itertools::Itertools;
use crate::bitflags; use crate::bitflags;
use crate::expand::{Expander, expand_raw};
use crate::libsh::error::{ShErr, ShErrKind, ShResult}; use crate::libsh::error::{ShErr, ShErrKind, ShResult};
use crate::parse::lex::TkFlags;
use crate::readline::complete::SimpleCompleter;
use crate::readline::history::History;
use crate::readline::keys::KeyEvent; use crate::readline::keys::KeyEvent;
use crate::readline::linebuf::LineBuf; use crate::readline::linebuf::LineBuf;
use crate::readline::vicmd::{ use crate::readline::vicmd::{
@@ -17,7 +13,7 @@ use crate::readline::vicmd::{
WriteDest, WriteDest,
}; };
use crate::readline::vimode::{ModeReport, ViInsert, ViMode}; use crate::readline::vimode::{ModeReport, ViInsert, ViMode};
use crate::state::{get_home, write_meta}; use crate::state::write_meta;
bitflags! { bitflags! {
#[derive(Debug,Clone,Copy,PartialEq,Eq)] #[derive(Debug,Clone,Copy,PartialEq,Eq)]
@@ -37,64 +33,16 @@ bitflags! {
struct ExEditor { struct ExEditor {
buf: LineBuf, buf: LineBuf,
mode: ViInsert, mode: ViInsert,
history: History,
} }
impl ExEditor { impl ExEditor {
pub fn new(history: History) -> Self {
let mut new = Self {
history,
..Default::default()
};
new.buf.update_graphemes();
new
}
pub fn clear(&mut self) { pub fn clear(&mut self) {
*self = Self::default() *self = Self::default()
} }
pub fn should_grab_history(&mut self, cmd: &ViCmd) -> bool {
cmd.verb().is_none()
&& (cmd
.motion()
.is_some_and(|m| matches!(m, MotionCmd(_, Motion::LineUpCharwise)))
&& self.buf.start_of_line() == 0)
|| (cmd
.motion()
.is_some_and(|m| matches!(m, MotionCmd(_, Motion::LineDownCharwise)))
&& self.buf.end_of_line() == self.buf.cursor_max())
}
pub fn scroll_history(&mut self, cmd: ViCmd) {
let count = &cmd.motion().unwrap().0;
let motion = &cmd.motion().unwrap().1;
let count = match motion {
Motion::LineUpCharwise => -(*count as isize),
Motion::LineDownCharwise => *count as isize,
_ => unreachable!(),
};
let entry = self.history.scroll(count);
if let Some(entry) = entry {
let buf = std::mem::take(&mut self.buf);
self.buf.set_buffer(entry.command().to_string());
if self.history.pending.is_none() {
self.history.pending = Some(buf);
}
self.buf.set_hint(None);
self.buf.move_cursor_to_end();
} else if let Some(pending) = self.history.pending.take() {
self.buf = pending;
}
}
pub fn handle_key(&mut self, key: KeyEvent) -> ShResult<()> { pub fn handle_key(&mut self, key: KeyEvent) -> ShResult<()> {
let Some(mut cmd) = self.mode.handle_key(key) else { let Some(cmd) = self.mode.handle_key(key) else {
return Ok(()); return Ok(());
}; };
cmd.alter_line_motion_if_no_verb();
log::debug!("ExEditor got cmd: {:?}", cmd);
if self.should_grab_history(&cmd) {
log::debug!("Grabbing history for cmd: {:?}", cmd);
self.scroll_history(cmd);
return Ok(());
}
self.buf.exec_cmd(cmd) self.buf.exec_cmd(cmd)
} }
} }
@@ -105,10 +53,8 @@ pub struct ViEx {
} }
impl ViEx { impl ViEx {
pub fn new(history: History) -> Self { pub fn new() -> Self {
Self { Self::default()
pending_cmd: ExEditor::new(history),
}
} }
} }
@@ -116,12 +62,18 @@ impl ViMode for ViEx {
// Ex mode can return errors, so we use this fallible method instead of the normal one // Ex mode can return errors, so we use this fallible method instead of the normal one
fn handle_key_fallible(&mut self, key: KeyEvent) -> ShResult<Option<ViCmd>> { fn handle_key_fallible(&mut self, key: KeyEvent) -> ShResult<Option<ViCmd>> {
use crate::readline::keys::{KeyCode as C, KeyEvent as E, ModKeys as M}; use crate::readline::keys::{KeyCode as C, KeyEvent as E, ModKeys as M};
log::debug!("[ViEx] handle_key_fallible: key={:?}", key);
match key { match key {
E(C::Char('\r'), M::NONE) | E(C::Enter, M::NONE) => { E(C::Char('\r'), M::NONE) | E(C::Enter, M::NONE) => {
let input = self.pending_cmd.buf.as_str(); let input = self.pending_cmd.buf.as_str();
log::debug!("[ViEx] Enter pressed, pending_cmd={:?}", input);
match parse_ex_cmd(input) { match parse_ex_cmd(input) {
Ok(cmd) => Ok(cmd), Ok(cmd) => {
log::debug!("[ViEx] parse_ex_cmd Ok: {:?}", cmd);
Ok(cmd)
}
Err(e) => { Err(e) => {
log::debug!("[ViEx] parse_ex_cmd Err: {:?}", e);
let msg = e.unwrap_or(format!("Not an editor command: {}", input)); let msg = e.unwrap_or(format!("Not an editor command: {}", input));
write_meta(|m| m.post_system_message(msg.clone())); write_meta(|m| m.post_system_message(msg.clone()));
Err(ShErr::simple(ShErrKind::ParseErr, msg)) Err(ShErr::simple(ShErrKind::ParseErr, msg))
@@ -129,21 +81,29 @@ impl ViMode for ViEx {
} }
} }
E(C::Char('C'), M::CTRL) => { E(C::Char('C'), M::CTRL) => {
log::debug!("[ViEx] Ctrl-C, clearing");
self.pending_cmd.clear(); self.pending_cmd.clear();
Ok(None) Ok(None)
} }
E(C::Esc, M::NONE) => Ok(Some(ViCmd { E(C::Esc, M::NONE) => {
register: RegisterName::default(), log::debug!("[ViEx] Esc, returning to normal mode");
verb: Some(VerbCmd(1, Verb::NormalMode)), Ok(Some(ViCmd {
motion: None, register: RegisterName::default(),
flags: CmdFlags::empty(), verb: Some(VerbCmd(1, Verb::NormalMode)),
raw_seq: "".into(), motion: None,
})), flags: CmdFlags::empty(),
_ => self.pending_cmd.handle_key(key).map(|_| None), raw_seq: "".into(),
}))
}
_ => {
log::debug!("[ViEx] forwarding key to ExEditor");
self.pending_cmd.handle_key(key).map(|_| None)
}
} }
} }
fn handle_key(&mut self, key: KeyEvent) -> Option<ViCmd> { fn handle_key(&mut self, key: KeyEvent) -> Option<ViCmd> {
let result = self.handle_key_fallible(key); let result = self.handle_key_fallible(key);
log::debug!("[ViEx] handle_key result: {:?}", result);
result.ok().flatten() result.ok().flatten()
} }
fn is_repeatable(&self) -> bool { fn is_repeatable(&self) -> bool {
@@ -154,14 +114,6 @@ impl ViMode for ViEx {
None None
} }
fn editor(&mut self) -> Option<&mut LineBuf> {
Some(&mut self.pending_cmd.buf)
}
fn history(&mut self) -> Option<&mut History> {
Some(&mut self.pending_cmd.history)
}
fn cursor_style(&self) -> String { fn cursor_style(&self) -> String {
"\x1b[3 q".to_string() "\x1b[3 q".to_string()
} }
@@ -225,7 +177,7 @@ fn parse_ex_cmd(raw: &str) -> Result<Option<ViCmd>, Option<String>> {
verb, verb,
motion, motion,
raw_seq: raw.to_string(), raw_seq: raw.to_string(),
flags: CmdFlags::EXIT_CUR_MODE | CmdFlags::IS_EX_CMD, flags: CmdFlags::EXIT_CUR_MODE,
})) }))
} }
@@ -255,7 +207,7 @@ fn parse_ex_command(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Opt
let mut cmd_name = String::new(); let mut cmd_name = String::new();
while let Some(ch) = chars.peek() { while let Some(ch) = chars.peek() {
if cmd_name.is_empty() && ch == &'!' { if ch == &'!' {
cmd_name.push(*ch); cmd_name.push(*ch);
chars.next(); chars.next();
break; break;
@@ -272,17 +224,12 @@ fn parse_ex_command(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Opt
let cmd = unescape_shell_cmd(&cmd); let cmd = unescape_shell_cmd(&cmd);
Ok(Some(Verb::ShellCmd(cmd))) Ok(Some(Verb::ShellCmd(cmd)))
} }
_ if "help".starts_with(&cmd_name) => {
let cmd = "help ".to_string() + chars.collect::<String>().trim();
Ok(Some(Verb::ShellCmd(cmd)))
}
"normal!" => parse_normal(chars), "normal!" => parse_normal(chars),
_ if "delete".starts_with(&cmd_name) => Ok(Some(Verb::Delete)), _ if "delete".starts_with(&cmd_name) => Ok(Some(Verb::Delete)),
_ if "yank".starts_with(&cmd_name) => Ok(Some(Verb::Yank)), _ if "yank".starts_with(&cmd_name) => Ok(Some(Verb::Yank)),
_ if "put".starts_with(&cmd_name) => Ok(Some(Verb::Put(Anchor::After))), _ if "put".starts_with(&cmd_name) => Ok(Some(Verb::Put(Anchor::After))),
_ if "read".starts_with(&cmd_name) => parse_read(chars), _ if "read".starts_with(&cmd_name) => parse_read(chars),
_ if "write".starts_with(&cmd_name) => parse_write(chars), _ if "write".starts_with(&cmd_name) => parse_write(chars),
_ if "edit".starts_with(&cmd_name) => parse_edit(chars),
_ if "substitute".starts_with(&cmd_name) => parse_substitute(chars), _ if "substitute".starts_with(&cmd_name) => parse_substitute(chars),
_ => Err(None), _ => Err(None),
} }
@@ -297,19 +244,6 @@ fn parse_normal(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<
Ok(Some(Verb::Normal(seq))) Ok(Some(Verb::Normal(seq)))
} }
fn parse_edit(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<String>> {
chars
.peeking_take_while(|c| c.is_whitespace())
.for_each(drop);
let arg: String = chars.collect();
if arg.trim().is_empty() {
return Err(Some("Expected file path after ':edit'".into()));
}
let arg_path = get_path(arg.trim())?;
Ok(Some(Verb::Edit(arg_path)))
}
fn parse_read(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<String>> { fn parse_read(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<String>> {
chars chars
.peeking_take_while(|c| c.is_whitespace()) .peeking_take_while(|c| c.is_whitespace())
@@ -332,20 +266,23 @@ fn parse_read(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<St
if is_shell_read { if is_shell_read {
Ok(Some(Verb::Read(ReadSrc::Cmd(arg)))) Ok(Some(Verb::Read(ReadSrc::Cmd(arg))))
} else { } else {
let arg_path = get_path(arg.trim())?; let arg_path = get_path(arg.trim());
Ok(Some(Verb::Read(ReadSrc::File(arg_path)))) Ok(Some(Verb::Read(ReadSrc::File(arg_path))))
} }
} }
fn get_path(path: &str) -> Result<PathBuf, Option<String>> { fn get_path(path: &str) -> PathBuf {
log::debug!("Expanding path: {}", path); if let Some(stripped) = path.strip_prefix("~/")
let expanded = Expander::from_raw(path, TkFlags::empty()) && let Some(home) = std::env::var_os("HOME")
.map_err(|e| Some(format!("Error expanding path: {}", e)))? {
.expand() return PathBuf::from(home).join(stripped);
.map_err(|e| Some(format!("Error expanding path: {}", e)))? }
.join(" "); if path == "~"
log::debug!("Expanded path: {}", expanded); && let Some(home) = std::env::var_os("HOME")
Ok(PathBuf::from(&expanded)) {
return PathBuf::from(home);
}
PathBuf::from(path)
} }
fn parse_write(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<String>> { fn parse_write(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<String>> {
@@ -368,7 +305,7 @@ fn parse_write(chars: &mut Peekable<Chars<'_>>) -> Result<Option<Verb>, Option<S
} }
let arg: String = chars.collect(); let arg: String = chars.collect();
let arg_path = get_path(arg.trim())?; let arg_path = get_path(arg.trim());
let dest = if is_file_append { let dest = if is_file_append {
WriteDest::FileAppend(arg_path) WriteDest::FileAppend(arg_path)

18
src/readline/vimode/insert.rs
View File

@@ -13,10 +13,10 @@ impl ViInsert {
pub fn new() -> Self { pub fn new() -> Self {
Self::default() Self::default()
} }
pub fn record_cmd(mut self, cmd: ViCmd) -> Self { pub fn record_cmd(mut self, cmd: ViCmd) -> Self {
self.cmds.push(cmd); self.cmds.push(cmd);
self self
} }
pub fn with_count(mut self, repeat_count: u16) -> Self { pub fn with_count(mut self, repeat_count: u16) -> Self {
self.repeat_count = repeat_count; self.repeat_count = repeat_count;
self self
@@ -65,12 +65,10 @@ impl ViMode for ViInsert {
raw_seq: String::new(), raw_seq: String::new(),
flags: Default::default(), flags: Default::default(),
}), }),
E(K::Verbatim(seq), _) => { E(K::Verbatim(seq), _) => {
self self.pending_cmd.set_verb(VerbCmd(1, Verb::Insert(seq.to_string())));
.pending_cmd self.register_and_return()
.set_verb(VerbCmd(1, Verb::Insert(seq.to_string()))); }
self.register_and_return()
}
E(K::Char('W'), M::CTRL) => { E(K::Char('W'), M::CTRL) => {
self.pending_cmd.set_verb(VerbCmd(1, Verb::Delete)); self.pending_cmd.set_verb(VerbCmd(1, Verb::Delete));
self.pending_cmd.set_motion(MotionCmd( self.pending_cmd.set_motion(MotionCmd(

8
src/readline/vimode/mod.rs
View File

@@ -3,9 +3,7 @@ use std::fmt::Display;
use unicode_segmentation::UnicodeSegmentation; use unicode_segmentation::UnicodeSegmentation;
use crate::libsh::error::ShResult; use crate::libsh::error::ShResult;
use crate::readline::history::History;
use crate::readline::keys::{KeyCode as K, KeyEvent as E, ModKeys as M}; use crate::readline::keys::{KeyCode as K, KeyEvent as E, ModKeys as M};
use crate::readline::linebuf::LineBuf;
use crate::readline::vicmd::{Motion, MotionCmd, To, Verb, VerbCmd, ViCmd}; use crate::readline::vicmd::{Motion, MotionCmd, To, Verb, VerbCmd, ViCmd};
pub mod ex; pub mod ex;
@@ -84,12 +82,6 @@ pub trait ViMode {
fn pending_cursor(&self) -> Option<usize> { fn pending_cursor(&self) -> Option<usize> {
None None
} }
fn editor(&mut self) -> Option<&mut LineBuf> {
None
}
fn history(&mut self) -> Option<&mut History> {
None
}
fn move_cursor_on_undo(&self) -> bool; fn move_cursor_on_undo(&self) -> bool;
fn clamp_cursor(&self) -> bool; fn clamp_cursor(&self) -> bool;
fn hist_scroll_start_pos(&self) -> Option<To>; fn hist_scroll_start_pos(&self) -> Option<To>;

16
src/readline/vimode/normal.rs
View File

@@ -450,10 +450,26 @@ impl ViNormal {
Motion::WordMotion(To::End, Word::Big, Direction::Backward), Motion::WordMotion(To::End, Word::Big, Direction::Backward),
)); ));
} }
'k' => {
chars = chars_clone;
break 'motion_parse Some(MotionCmd(count, Motion::ScreenLineUp));
}
'j' => {
chars = chars_clone;
break 'motion_parse Some(MotionCmd(count, Motion::ScreenLineDown));
}
'_' => { '_' => {
chars = chars_clone; chars = chars_clone;
break 'motion_parse Some(MotionCmd(count, Motion::EndOfLastWord)); break 'motion_parse Some(MotionCmd(count, Motion::EndOfLastWord));
} }
'0' => {
chars = chars_clone;
break 'motion_parse Some(MotionCmd(count, Motion::BeginningOfScreenLine));
}
'^' => {
chars = chars_clone;
break 'motion_parse Some(MotionCmd(count, Motion::FirstGraphicalOnScreenLine));
}
_ => return self.quit_parse(), _ => return self.quit_parse(),
} }
} }

26
src/readline/vimode/visual.rs
View File

@@ -213,7 +213,7 @@ impl ViVisual {
let ch = chars_clone.next()?; let ch = chars_clone.next()?;
return Some(ViCmd { return Some(ViCmd {
register, register,
verb: Some(VerbCmd(1, Verb::ReplaceCharInplace(ch, 1))), verb: Some(VerbCmd(1, Verb::ReplaceCharInplace(ch,1))),
motion: None, motion: None,
raw_seq: self.take_cmd(), raw_seq: self.take_cmd(),
flags: CmdFlags::empty(), flags: CmdFlags::empty(),
@@ -301,13 +301,13 @@ impl ViVisual {
}); });
} }
'y' => { 'y' => {
return Some(ViCmd { return Some(ViCmd {
register, register,
verb: Some(VerbCmd(count, Verb::Yank)), verb: Some(VerbCmd(count, Verb::Yank)),
motion: None, motion: None,
raw_seq: self.take_cmd(), raw_seq: self.take_cmd(),
flags: CmdFlags::empty(), flags: CmdFlags::empty(),
}); });
} }
'd' => { 'd' => {
chars = chars_clone; chars = chars_clone;
@@ -376,6 +376,16 @@ impl ViVisual {
Motion::WordMotion(To::End, Word::Big, Direction::Backward), Motion::WordMotion(To::End, Word::Big, Direction::Backward),
)); ));
} }
'k' => {
chars_clone.next();
chars = chars_clone;
break 'motion_parse Some(MotionCmd(count, Motion::ScreenLineUp));
}
'j' => {
chars_clone.next();
chars = chars_clone;
break 'motion_parse Some(MotionCmd(count, Motion::ScreenLineDown));
}
_ => return self.quit_parse(), _ => return self.quit_parse(),
} }
} else { } else {

643
src/shopt.rs
View File

@@ -2,35 +2,6 @@ use std::{fmt::Display, str::FromStr};
use crate::libsh::error::{ShErr, ShErrKind, ShResult}; use crate::libsh::error::{ShErr, ShErrKind, ShResult};
/// Escapes a string for embedding inside single quotes.
/// Only escapes unescaped `\` and `'` characters.
pub fn escape_for_single_quote(s: &str) -> String {
let mut result = String::with_capacity(s.len());
let mut chars = s.chars().peekable();
while let Some(ch) = chars.next() {
if ch == '\\' {
match chars.peek() {
Some(&'\\') | Some(&'\'') => {
// Already escaped — pass through both characters
result.push(ch);
result.push(chars.next().unwrap());
}
_ => {
// Lone backslash — escape it
result.push('\\');
result.push('\\');
}
}
} else if ch == '\'' {
result.push('\\');
result.push('\'');
} else {
result.push(ch);
}
}
result
}
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
pub enum ShedBellStyle { pub enum ShedBellStyle {
Audible, Audible,
@@ -53,97 +24,34 @@ impl FromStr for ShedBellStyle {
} }
} }
/// Generates a shopt group struct with `set`, `get`, `Display`, and `Default` impls. #[derive(Default, Clone, Copy, Debug)]
/// pub enum ShedEditMode {
/// Doc comments on each field become the description shown by `shopt get`. #[default]
/// Every field type must implement `FromStr + Display`. Vi,
/// Emacs,
/// Optional per-field validation: `#[validate(|val| expr)]` runs after parsing }
/// and must return `Result<(), String>` where the error string is the message.
macro_rules! shopt_group {
(
$(#[$struct_meta:meta])*
pub struct $name:ident ($group_name:literal) {
$(
$(#[doc = $desc:literal])*
$(#[validate($validator:expr)])?
$field:ident : $ty:ty = $default:expr
),* $(,)?
}
) => {
$(#[$struct_meta])*
pub struct $name {
$(pub $field: $ty,)*
}
impl Default for $name { impl FromStr for ShedEditMode {
fn default() -> Self { type Err = ShErr;
Self { fn from_str(s: &str) -> Result<Self, Self::Err> {
$($field: $default,)* match s.to_ascii_lowercase().as_str() {
} "vi" => Ok(Self::Vi),
} "emacs" => Ok(Self::Emacs),
_ => Err(ShErr::simple(
ShErrKind::SyntaxErr,
format!("Invalid edit mode '{s}'"),
)),
} }
}
}
impl $name { impl Display for ShedEditMode {
pub fn set(&mut self, opt: &str, val: &str) -> ShResult<()> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match opt { match self {
$( ShedEditMode::Vi => write!(f, "vi"),
stringify!($field) => { ShedEditMode::Emacs => write!(f, "emacs"),
let parsed = val.parse::<$ty>().map_err(|_| {
ShErr::simple(
ShErrKind::SyntaxErr,
format!("shopt: invalid value '{}' for {}.{}", val, $group_name, opt),
)
})?;
$(
let validate: fn(&$ty) -> Result<(), String> = $validator;
validate(&parsed).map_err(|msg| {
ShErr::simple(ShErrKind::SyntaxErr, format!("shopt: {msg}"))
})?;
)?
self.$field = parsed;
}
)*
_ => {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
format!("shopt: unexpected '{}' option '{opt}'", $group_name),
));
}
}
Ok(())
}
pub fn get(&self, query: &str) -> ShResult<Option<String>> {
if query.is_empty() {
return Ok(Some(format!("{self}")));
}
match query {
$(
stringify!($field) => {
let desc = concat!($($desc, "\n",)*);
let output = format!("{}{}", desc, self.$field);
Ok(Some(output))
}
)*
_ => Err(ShErr::simple(
ShErrKind::SyntaxErr,
format!("shopt: unexpected '{}' option '{query}'", $group_name),
)),
}
}
} }
}
impl Display for $name {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let output = [
$(format!("{}.{}='{}'", $group_name, stringify!($field),
$crate::shopt::escape_for_single_quote(&self.$field.to_string())),)*
];
writeln!(f, "{}", output.join("\n"))
}
}
};
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@@ -174,8 +82,8 @@ impl ShOpts {
pub fn display_opts(&mut self) -> ShResult<String> { pub fn display_opts(&mut self) -> ShResult<String> {
let output = [ let output = [
self.query("core")?.unwrap_or_default().to_string(), format!("core:\n{}", self.query("core")?.unwrap_or_default()),
self.query("prompt")?.unwrap_or_default().to_string(), format!("prompt:\n{}", self.query("prompt")?.unwrap_or_default()),
]; ];
Ok(output.join("\n")) Ok(output.join("\n"))
@@ -227,78 +135,409 @@ impl ShOpts {
} }
} }
shopt_group! { #[derive(Clone, Debug)]
#[derive(Clone, Debug)] pub struct ShOptCore {
pub struct ShOptCore ("core") { pub dotglob: bool,
/// Include hidden files in glob patterns pub autocd: bool,
dotglob: bool = false, pub hist_ignore_dupes: bool,
pub max_hist: isize,
pub interactive_comments: bool,
pub auto_hist: bool,
pub bell_enabled: bool,
pub max_recurse_depth: usize,
pub xpg_echo: bool,
}
/// Allow navigation to directories by passing the directory as a command directly impl ShOptCore {
autocd: bool = false, pub fn set(&mut self, opt: &str, val: &str) -> ShResult<()> {
match opt {
"dotglob" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for dotglob value",
));
};
self.dotglob = val;
}
"autocd" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for autocd value",
));
};
self.autocd = val;
}
"hist_ignore_dupes" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for hist_ignore_dupes value",
));
};
self.hist_ignore_dupes = val;
}
"max_hist" => {
let Ok(val) = val.parse::<isize>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected an integer for max_hist value (-1 for unlimited)",
));
};
if val < -1 {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected a non-negative integer or -1 for max_hist value",
));
}
self.max_hist = val;
}
"interactive_comments" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for interactive_comments value",
));
};
self.interactive_comments = val;
}
"auto_hist" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for auto_hist value",
));
};
self.auto_hist = val;
}
"bell_enabled" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for bell_enabled value",
));
};
self.bell_enabled = val;
}
"max_recurse_depth" => {
let Ok(val) = val.parse::<usize>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected a positive integer for max_recurse_depth value",
));
};
self.max_recurse_depth = val;
}
"xpg_echo" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for xpg_echo value",
));
};
self.xpg_echo = val;
}
_ => {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
format!("shopt: Unexpected 'core' option '{opt}'"),
));
}
}
Ok(())
}
pub fn get(&self, query: &str) -> ShResult<Option<String>> {
if query.is_empty() {
return Ok(Some(format!("{self}")));
}
/// Ignore consecutive duplicate command history entries match query {
hist_ignore_dupes: bool = true, "dotglob" => {
let mut output = String::from("Include hidden files in glob patterns\n");
/// Maximum number of entries in the command history file (-1 for unlimited) output.push_str(&format!("{}", self.dotglob));
#[validate(|v: &isize| if *v < -1 { Ok(Some(output))
Err("expected a non-negative integer or -1 for max_hist value".into()) }
} else { "autocd" => {
Ok(()) let mut output = String::from(
})] "Allow navigation to directories by passing the directory as a command directly\n",
max_hist: isize = 10_000, );
output.push_str(&format!("{}", self.autocd));
/// Whether or not to allow comments in interactive mode Ok(Some(output))
interactive_comments: bool = true, }
"hist_ignore_dupes" => {
/// Whether or not to automatically save commands to the command history file let mut output = String::from("Ignore consecutive duplicate command history entries\n");
auto_hist: bool = true, output.push_str(&format!("{}", self.hist_ignore_dupes));
Ok(Some(output))
/// Whether or not to allow shed to trigger the terminal bell }
bell_enabled: bool = true, "max_hist" => {
let mut output = String::from(
/// Maximum limit of recursive shell function calls "Maximum number of entries in the command history file (-1 for unlimited)\n",
max_recurse_depth: usize = 1000, );
output.push_str(&format!("{}", self.max_hist));
/// Whether echo expands escape sequences by default Ok(Some(output))
xpg_echo: bool = false, }
"interactive_comments" => {
/// Prevent > from overwriting existing files (use >| to override) let mut output = String::from("Whether or not to allow comments in interactive mode\n");
noclobber: bool = false, output.push_str(&format!("{}", self.interactive_comments));
Ok(Some(output))
}
"auto_hist" => {
let mut output = String::from(
"Whether or not to automatically save commands to the command history file\n",
);
output.push_str(&format!("{}", self.auto_hist));
Ok(Some(output))
}
"bell_enabled" => {
let mut output = String::from("Whether or not to allow shed to trigger the terminal bell");
output.push_str(&format!("{}", self.bell_enabled));
Ok(Some(output))
}
"max_recurse_depth" => {
let mut output = String::from("Maximum limit of recursive shell function calls\n");
output.push_str(&format!("{}", self.max_recurse_depth));
Ok(Some(output))
}
"xpg_echo" => {
let mut output = String::from("Whether echo expands escape sequences by default\n");
output.push_str(&format!("{}", self.xpg_echo));
Ok(Some(output))
}
_ => Err(ShErr::simple(
ShErrKind::SyntaxErr,
format!("shopt: Unexpected 'core' option '{query}'"),
)),
}
} }
} }
shopt_group! { impl Display for ShOptCore {
#[derive(Clone, Debug)] fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
pub struct ShOptPrompt ("prompt") { let mut output = vec![];
/// Maximum number of path segments used in the '\W' prompt escape sequence output.push(format!("dotglob = {}", self.dotglob));
trunc_prompt_path: usize = 4, output.push(format!("autocd = {}", self.autocd));
output.push(format!("hist_ignore_dupes = {}", self.hist_ignore_dupes));
output.push(format!("max_hist = {}", self.max_hist));
output.push(format!(
"interactive_comments = {}",
self.interactive_comments
));
output.push(format!("auto_hist = {}", self.auto_hist));
output.push(format!("bell_enabled = {}", self.bell_enabled));
output.push(format!("max_recurse_depth = {}", self.max_recurse_depth));
output.push(format!("xpg_echo = {}", self.xpg_echo));
/// Maximum number of completion candidates displayed upon pressing tab let final_output = output.join("\n");
comp_limit: usize = 100,
/// Whether to enable or disable syntax highlighting on the prompt writeln!(f, "{final_output}")
highlight: bool = true, }
}
/// Whether to automatically indent new lines in multiline commands impl Default for ShOptCore {
auto_indent: bool = true, fn default() -> Self {
ShOptCore {
dotglob: false,
autocd: false,
hist_ignore_dupes: true,
max_hist: 10_000,
interactive_comments: true,
auto_hist: true,
bell_enabled: true,
max_recurse_depth: 1000,
xpg_echo: false,
}
}
}
/// Whether to automatically insert a newline when the input is incomplete #[derive(Clone, Debug)]
linebreak_on_incomplete: bool = true, pub struct ShOptPrompt {
pub trunc_prompt_path: usize,
pub edit_mode: ShedEditMode,
pub comp_limit: usize,
pub highlight: bool,
pub auto_indent: bool,
pub linebreak_on_incomplete: bool,
pub leader: String,
pub line_numbers: bool,
}
/// The leader key sequence used in keymap bindings impl ShOptPrompt {
leader: String = " ".to_string(), pub fn set(&mut self, opt: &str, val: &str) -> ShResult<()> {
match opt {
"trunc_prompt_path" => {
let Ok(val) = val.parse::<usize>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected a positive integer for trunc_prompt_path value",
));
};
self.trunc_prompt_path = val;
}
"edit_mode" => {
let Ok(val) = val.parse::<ShedEditMode>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'vi' or 'emacs' for edit_mode value",
));
};
self.edit_mode = val;
}
"comp_limit" => {
let Ok(val) = val.parse::<usize>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected a positive integer for comp_limit value",
));
};
self.comp_limit = val;
}
"highlight" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for highlight value",
));
};
self.highlight = val;
}
"auto_indent" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for auto_indent value",
));
};
self.auto_indent = val;
}
"linebreak_on_incomplete" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for linebreak_on_incomplete value",
));
};
self.linebreak_on_incomplete = val;
}
"leader" => {
self.leader = val.to_string();
}
"line_numbers" => {
let Ok(val) = val.parse::<bool>() else {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
"shopt: expected 'true' or 'false' for line_numbers value",
));
};
self.line_numbers = val;
}
"custom" => {
todo!()
}
_ => {
return Err(ShErr::simple(
ShErrKind::SyntaxErr,
format!("shopt: Unexpected 'prompt' option '{opt}'"),
));
}
}
Ok(())
}
pub fn get(&self, query: &str) -> ShResult<Option<String>> {
if query.is_empty() {
return Ok(Some(format!("{self}")));
}
/// Whether to display line numbers in multiline input match query {
line_numbers: bool = true, "trunc_prompt_path" => {
let mut output = String::from(
"Maximum number of path segments used in the '\\W' prompt escape sequence\n",
);
output.push_str(&format!("{}", self.trunc_prompt_path));
Ok(Some(output))
}
"edit_mode" => {
let mut output =
String::from("The style of editor shortcuts used in the line-editing of the prompt\n");
output.push_str(&format!("{}", self.edit_mode));
Ok(Some(output))
}
"comp_limit" => {
let mut output =
String::from("Maximum number of completion candidates displayed upon pressing tab\n");
output.push_str(&format!("{}", self.comp_limit));
Ok(Some(output))
}
"highlight" => {
let mut output =
String::from("Whether to enable or disable syntax highlighting on the prompt\n");
output.push_str(&format!("{}", self.highlight));
Ok(Some(output))
}
"auto_indent" => {
let mut output =
String::from("Whether to automatically indent new lines in multiline commands\n");
output.push_str(&format!("{}", self.auto_indent));
Ok(Some(output))
}
"linebreak_on_incomplete" => {
let mut output =
String::from("Whether to automatically insert a newline when the input is incomplete\n");
output.push_str(&format!("{}", self.linebreak_on_incomplete));
Ok(Some(output))
}
"leader" => {
let mut output = String::from("The leader key sequence used in keymap bindings\n");
output.push_str(&self.leader);
Ok(Some(output))
}
"line_numbers" => {
let mut output = String::from("Whether to display line numbers in multiline input\n");
output.push_str(&format!("{}", self.line_numbers));
Ok(Some(output))
}
_ => Err(ShErr::simple(
ShErrKind::SyntaxErr,
format!("shopt: Unexpected 'prompt' option '{query}'"),
)),
}
}
}
/// Command to execute as a screensaver after idle timeout impl Display for ShOptPrompt {
screensaver_cmd: String = String::new(), fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut output = vec![];
/// Idle time in seconds before running screensaver_cmd (0 = disabled) output.push(format!("trunc_prompt_path = {}", self.trunc_prompt_path));
screensaver_idle_time: usize = 0, output.push(format!("edit_mode = {}", self.edit_mode));
output.push(format!("comp_limit = {}", self.comp_limit));
output.push(format!("highlight = {}", self.highlight));
output.push(format!("auto_indent = {}", self.auto_indent));
output.push(format!(
"linebreak_on_incomplete = {}",
self.linebreak_on_incomplete
));
output.push(format!("leader = {}", self.leader));
output.push(format!("line_numbers = {}", self.line_numbers));
/// Whether tab completion matching is case-insensitive let final_output = output.join("\n");
completion_ignore_case: bool = false,
writeln!(f, "{final_output}")
}
}
impl Default for ShOptPrompt {
fn default() -> Self {
ShOptPrompt {
trunc_prompt_path: 4,
edit_mode: ShedEditMode::Vi,
comp_limit: 100,
highlight: true,
auto_indent: true,
linebreak_on_incomplete: true,
leader: "\\".to_string(),
line_numbers: true,
}
} }
} }
@@ -308,31 +547,23 @@ mod tests {
#[test] #[test]
fn all_core_fields_covered() { fn all_core_fields_covered() {
let ShOptCore { let ShOptCore {
dotglob, dotglob, autocd, hist_ignore_dupes, max_hist,
autocd, interactive_comments, auto_hist, bell_enabled, max_recurse_depth,
hist_ignore_dupes, xpg_echo,
max_hist, } = ShOptCore::default();
interactive_comments, // If a field is added to the struct, this destructure fails to compile.
auto_hist, let _ = (
bell_enabled, dotglob,
max_recurse_depth, autocd,
xpg_echo, hist_ignore_dupes,
noclobber, max_hist,
} = ShOptCore::default(); interactive_comments,
// If a field is added to the struct, this destructure fails to compile. auto_hist,
let _ = ( bell_enabled,
dotglob, max_recurse_depth,
autocd, xpg_echo,
hist_ignore_dupes, );
max_hist,
interactive_comments,
auto_hist,
bell_enabled,
max_recurse_depth,
xpg_echo,
noclobber,
);
} }
#[test] #[test]
@@ -358,13 +589,19 @@ mod tests {
opts.set("core.max_hist", "-1").unwrap(); opts.set("core.max_hist", "-1").unwrap();
assert_eq!(opts.core.max_hist, -1); assert_eq!(opts.core.max_hist, -1);
assert!(opts.set("core.max_hist", "-500").is_err()); assert!(opts.set("core.max_hist", "-500").is_err());
} }
#[test] #[test]
fn set_and_get_prompt_opts() { fn set_and_get_prompt_opts() {
let mut opts = ShOpts::default(); let mut opts = ShOpts::default();
opts.set("prompt.edit_mode", "emacs").unwrap();
assert!(matches!(opts.prompt.edit_mode, ShedEditMode::Emacs));
opts.set("prompt.edit_mode", "vi").unwrap();
assert!(matches!(opts.prompt.edit_mode, ShedEditMode::Vi));
opts.set("prompt.comp_limit", "50").unwrap(); opts.set("prompt.comp_limit", "50").unwrap();
assert_eq!(opts.prompt.comp_limit, 50); assert_eq!(opts.prompt.comp_limit, 50);
@@ -409,6 +646,7 @@ mod tests {
assert!(opts.set("core.dotglob", "notabool").is_err()); assert!(opts.set("core.dotglob", "notabool").is_err());
assert!(opts.set("core.max_hist", "notanint").is_err()); assert!(opts.set("core.max_hist", "notanint").is_err());
assert!(opts.set("core.max_recurse_depth", "-5").is_err()); assert!(opts.set("core.max_recurse_depth", "-5").is_err());
assert!(opts.set("prompt.edit_mode", "notepad").is_err());
assert!(opts.set("prompt.comp_limit", "abc").is_err()); assert!(opts.set("prompt.comp_limit", "abc").is_err());
} }
@@ -422,6 +660,7 @@ mod tests {
assert!(core_output.contains("bell_enabled")); assert!(core_output.contains("bell_enabled"));
let prompt_output = opts.get("prompt").unwrap().unwrap(); let prompt_output = opts.get("prompt").unwrap().unwrap();
assert!(prompt_output.contains("edit_mode"));
assert!(prompt_output.contains("comp_limit")); assert!(prompt_output.contains("comp_limit"));
assert!(prompt_output.contains("highlight")); assert!(prompt_output.contains("highlight"));
} }

61
src/signal.rs
View File

@@ -1,45 +1,31 @@
use std::{ use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
collections::VecDeque,
sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering},
};
use nix::{ use nix::sys::signal::{SaFlags, SigAction, sigaction};
sys::signal::{SaFlags, SigAction, sigaction},
unistd::getpid,
};
use crate::{ use crate::{
builtin::trap::TrapTarget, builtin::trap::TrapTarget,
jobs::{Job, JobCmdFlags, JobID, take_term}, jobs::{JobCmdFlags, JobID, take_term},
libsh::error::{ShErr, ShErrKind, ShResult}, libsh::error::{ShErr, ShErrKind, ShResult},
parse::execute::exec_input, parse::execute::exec_input,
prelude::*, prelude::*,
state::{ state::{AutoCmd, AutoCmdKind, read_jobs, read_logic, write_jobs, write_meta},
AutoCmd, AutoCmdKind, VarFlags, VarKind, read_jobs, read_logic, write_jobs, write_meta,
write_vars,
},
}; };
static SIGNALS: AtomicU64 = AtomicU64::new(0); static SIGNALS: AtomicU64 = AtomicU64::new(0);
pub static REAPING_ENABLED: AtomicBool = AtomicBool::new(true); pub static REAPING_ENABLED: AtomicBool = AtomicBool::new(true);
pub static SHOULD_QUIT: AtomicBool = AtomicBool::new(false); pub static SHOULD_QUIT: AtomicBool = AtomicBool::new(false);
pub static GOT_SIGWINCH: AtomicBool = AtomicBool::new(false);
pub static JOB_DONE: AtomicBool = AtomicBool::new(false); pub static JOB_DONE: AtomicBool = AtomicBool::new(false);
pub static QUIT_CODE: AtomicI32 = AtomicI32::new(0); pub static QUIT_CODE: AtomicI32 = AtomicI32::new(0);
/// Window size change signal const MISC_SIGNALS: [Signal; 22] = [
pub static GOT_SIGWINCH: AtomicBool = AtomicBool::new(false);
/// SIGUSR1 tells the prompt that it needs to fully refresh.
/// Useful for dynamic prompt content and asynchronous refreshing
pub static GOT_SIGUSR1: AtomicBool = AtomicBool::new(false);
const MISC_SIGNALS: [Signal; 21] = [
Signal::SIGILL, Signal::SIGILL,
Signal::SIGTRAP, Signal::SIGTRAP,
Signal::SIGABRT, Signal::SIGABRT,
Signal::SIGBUS, Signal::SIGBUS,
Signal::SIGFPE, Signal::SIGFPE,
Signal::SIGUSR1,
Signal::SIGSEGV, Signal::SIGSEGV,
Signal::SIGUSR2, Signal::SIGUSR2,
Signal::SIGPIPE, Signal::SIGPIPE,
@@ -79,7 +65,7 @@ pub fn check_signals() -> ShResult<()> {
if got_signal(Signal::SIGINT) { if got_signal(Signal::SIGINT) {
interrupt()?; interrupt()?;
run_trap(Signal::SIGINT)?; run_trap(Signal::SIGINT)?;
return Err(ShErr::simple(ShErrKind::Interrupt, "")); return Err(ShErr::simple(ShErrKind::ClearReadline, ""));
} }
if got_signal(Signal::SIGHUP) { if got_signal(Signal::SIGHUP) {
run_trap(Signal::SIGHUP)?; run_trap(Signal::SIGHUP)?;
@@ -101,10 +87,6 @@ pub fn check_signals() -> ShResult<()> {
GOT_SIGWINCH.store(true, Ordering::SeqCst); GOT_SIGWINCH.store(true, Ordering::SeqCst);
run_trap(Signal::SIGWINCH)?; run_trap(Signal::SIGWINCH)?;
} }
if got_signal(Signal::SIGUSR1) {
GOT_SIGUSR1.store(true, Ordering::SeqCst);
run_trap(Signal::SIGUSR1)?;
}
for sig in MISC_SIGNALS { for sig in MISC_SIGNALS {
if got_signal(sig) { if got_signal(sig) {
@@ -183,10 +165,10 @@ pub fn reset_signals(is_fg: bool) {
if sig == Signal::SIGKILL || sig == Signal::SIGSTOP { if sig == Signal::SIGKILL || sig == Signal::SIGSTOP {
continue; continue;
} }
if is_fg && (sig == Signal::SIGTTIN || sig == Signal::SIGTTOU) { if is_fg && (sig == Signal::SIGTTIN || sig == Signal::SIGTTOU) {
log::debug!("Not resetting SIGTTIN/SIGTTOU in foreground child"); log::debug!("Not resetting SIGTTIN/SIGTTOU in foreground child");
continue; continue;
} }
let _ = sigaction(sig, &default); let _ = sigaction(sig, &default);
} }
} }
@@ -334,25 +316,6 @@ pub fn child_exited(pid: Pid, status: WtStat) -> ShResult<()> {
let result = read_jobs(|j| j.query(JobID::Pgid(pgid)).cloned()); let result = read_jobs(|j| j.query(JobID::Pgid(pgid)).cloned());
if let Some(job) = result { if let Some(job) = result {
let job_complete_msg = job.display(&job_order, JobCmdFlags::PIDS).to_string(); let job_complete_msg = job.display(&job_order, JobCmdFlags::PIDS).to_string();
let statuses = job.get_stats();
for status in &statuses {
if let WtStat::Signaled(_, sig, _) = status
&& *sig == Signal::SIGINT
{
// Necessary to interrupt stuff like shell loops
kill(getpid(), Signal::SIGINT).ok();
}
}
if let Some(pipe_status) = Job::pipe_status(&statuses) {
let pipe_status = pipe_status
.into_iter()
.map(|s| s.to_string())
.collect::<VecDeque<String>>();
write_vars(|v| v.set_var("PIPESTATUS", VarKind::Arr(pipe_status), VarFlags::NONE))?;
}
let post_job_hooks = read_logic(|l| l.get_autocmds(AutoCmdKind::OnJobFinish)); let post_job_hooks = read_logic(|l| l.get_autocmds(AutoCmdKind::OnJobFinish));
for cmd in post_job_hooks { for cmd in post_job_hooks {

268
src/state.rs
View File

@@ -1,14 +1,8 @@
use std::{ use std::{
cell::RefCell, cell::RefCell, collections::{HashMap, HashSet, VecDeque, hash_map::Entry}, fmt::Display, ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign}, os::unix::fs::PermissionsExt, str::FromStr, time::Duration
collections::{HashMap, HashSet, VecDeque, hash_map::Entry},
fmt::Display,
ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign},
os::unix::fs::PermissionsExt,
str::FromStr,
time::Duration,
}; };
use nix::unistd::{User, gethostname, getppid, getuid}; use nix::unistd::{User, gethostname, getppid};
use regex::Regex; use regex::Regex;
use crate::{ use crate::{
@@ -31,7 +25,7 @@ use crate::{
}, },
prelude::*, prelude::*,
readline::{ readline::{
complete::{BashCompSpec, Candidate, CompSpec}, complete::{BashCompSpec, CompSpec},
keys::KeyEvent, keys::KeyEvent,
markers, markers,
}, },
@@ -42,7 +36,7 @@ thread_local! {
pub static SHED: Shed = Shed::new(); pub static SHED: Shed = Shed::new();
} }
#[derive(Clone, Debug)] #[derive(Clone,Debug)]
pub struct Shed { pub struct Shed {
pub jobs: RefCell<JobTab>, pub jobs: RefCell<JobTab>,
pub var_scopes: RefCell<ScopeStack>, pub var_scopes: RefCell<ScopeStack>,
@@ -50,8 +44,8 @@ pub struct Shed {
pub logic: RefCell<LogTab>, pub logic: RefCell<LogTab>,
pub shopts: RefCell<ShOpts>, pub shopts: RefCell<ShOpts>,
#[cfg(test)] #[cfg(test)]
saved: RefCell<Option<Box<Self>>>, saved: RefCell<Option<Box<Self>>>,
} }
impl Shed { impl Shed {
@@ -63,8 +57,8 @@ impl Shed {
logic: RefCell::new(LogTab::new()), logic: RefCell::new(LogTab::new()),
shopts: RefCell::new(ShOpts::default()), shopts: RefCell::new(ShOpts::default()),
#[cfg(test)] #[cfg(test)]
saved: RefCell::new(None), saved: RefCell::new(None),
} }
} }
} }
@@ -77,27 +71,27 @@ impl Default for Shed {
#[cfg(test)] #[cfg(test)]
impl Shed { impl Shed {
pub fn save(&self) { pub fn save(&self) {
let saved = Self { let saved = Self {
jobs: RefCell::new(self.jobs.borrow().clone()), jobs: RefCell::new(self.jobs.borrow().clone()),
var_scopes: RefCell::new(self.var_scopes.borrow().clone()), var_scopes: RefCell::new(self.var_scopes.borrow().clone()),
meta: RefCell::new(self.meta.borrow().clone()), meta: RefCell::new(self.meta.borrow().clone()),
logic: RefCell::new(self.logic.borrow().clone()), logic: RefCell::new(self.logic.borrow().clone()),
shopts: RefCell::new(self.shopts.borrow().clone()), shopts: RefCell::new(self.shopts.borrow().clone()),
saved: RefCell::new(None), saved: RefCell::new(None),
}; };
*self.saved.borrow_mut() = Some(Box::new(saved)); *self.saved.borrow_mut() = Some(Box::new(saved));
} }
pub fn restore(&self) { pub fn restore(&self) {
if let Some(saved) = self.saved.take() { if let Some(saved) = self.saved.take() {
*self.jobs.borrow_mut() = saved.jobs.into_inner(); *self.jobs.borrow_mut() = saved.jobs.into_inner();
*self.var_scopes.borrow_mut() = saved.var_scopes.into_inner(); *self.var_scopes.borrow_mut() = saved.var_scopes.into_inner();
*self.meta.borrow_mut() = saved.meta.into_inner(); *self.meta.borrow_mut() = saved.meta.into_inner();
*self.logic.borrow_mut() = saved.logic.into_inner(); *self.logic.borrow_mut() = saved.logic.into_inner();
*self.shopts.borrow_mut() = saved.shopts.into_inner(); *self.shopts.borrow_mut() = saved.shopts.into_inner();
} }
} }
} }
#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)] #[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
@@ -321,34 +315,6 @@ impl ScopeStack {
}; };
scope.set_var(var_name, val, flags) scope.set_var(var_name, val, flags)
} }
pub fn get_magic_var(&self, var_name: &str) -> Option<String> {
match var_name {
"SECONDS" => {
let shell_time = read_meta(|m| m.shell_time());
let secs = Instant::now().duration_since(shell_time).as_secs();
Some(secs.to_string())
}
"EPOCHREALTIME" => {
let epoch = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or(Duration::from_secs(0))
.as_secs_f64();
Some(epoch.to_string())
}
"EPOCHSECONDS" => {
let epoch = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or(Duration::from_secs(0))
.as_secs();
Some(epoch.to_string())
}
"RANDOM" => {
let random = rand::random_range(0..32768);
Some(random.to_string())
}
_ => None,
}
}
pub fn get_arr_elems(&self, var_name: &str) -> ShResult<Vec<String>> { pub fn get_arr_elems(&self, var_name: &str) -> ShResult<Vec<String>> {
for scope in self.scopes.iter().rev() { for scope in self.scopes.iter().rev() {
if scope.var_exists(var_name) if scope.var_exists(var_name)
@@ -474,9 +440,7 @@ impl ScopeStack {
pub fn try_get_var(&self, var_name: &str) -> Option<String> { pub fn try_get_var(&self, var_name: &str) -> Option<String> {
// This version of get_var() is mainly used internally // This version of get_var() is mainly used internally
// so that we have access to Option methods // so that we have access to Option methods
if let Some(magic) = self.get_magic_var(var_name) { if let Ok(param) = var_name.parse::<ShellParam>() {
return Some(magic);
} else if let Ok(param) = var_name.parse::<ShellParam>() {
let val = self.get_param(param); let val = self.get_param(param);
if !val.is_empty() { if !val.is_empty() {
return Some(val); return Some(val);
@@ -499,9 +463,6 @@ impl ScopeStack {
var var
} }
pub fn get_var(&self, var_name: &str) -> String { pub fn get_var(&self, var_name: &str) -> String {
if let Some(magic) = self.get_magic_var(var_name) {
return magic;
}
if let Ok(param) = var_name.parse::<ShellParam>() { if let Ok(param) = var_name.parse::<ShellParam>() {
return self.get_param(param); return self.get_param(param);
} }
@@ -534,10 +495,7 @@ impl ScopeStack {
return val.clone(); return val.clone();
} }
// Positional params are scope-local; only check the current scope // Positional params are scope-local; only check the current scope
if matches!( if matches!(param, ShellParam::Pos(_) | ShellParam::AllArgs | ShellParam::AllArgsStr | ShellParam::ArgCount) {
param,
ShellParam::Pos(_) | ShellParam::AllArgs | ShellParam::AllArgsStr | ShellParam::ArgCount
) {
if let Some(scope) = self.scopes.last() { if let Some(scope) = self.scopes.last() {
return scope.get_param(param); return scope.get_param(param);
} }
@@ -996,24 +954,17 @@ impl Display for Var {
} }
impl From<Vec<String>> for Var { impl From<Vec<String>> for Var {
fn from(value: Vec<String>) -> Self { fn from(value: Vec<String>) -> Self {
Self::new(VarKind::Arr(value.into()), VarFlags::NONE) Self::new(VarKind::Arr(value.into()), VarFlags::NONE)
}
}
impl From<Vec<Candidate>> for Var {
fn from(value: Vec<Candidate>) -> Self {
let as_strs = value.into_iter().map(|c| c.0).collect::<Vec<_>>();
Self::new(VarKind::Arr(as_strs.into()), VarFlags::NONE)
} }
} }
impl From<&[String]> for Var { impl From<&[String]> for Var {
fn from(value: &[String]) -> Self { fn from(value: &[String]) -> Self {
let mut new = VecDeque::new(); let mut new = VecDeque::new();
new.extend(value.iter().cloned()); new.extend(value.iter().cloned());
Self::new(VarKind::Arr(new), VarFlags::NONE) Self::new(VarKind::Arr(new), VarFlags::NONE)
} }
} }
macro_rules! impl_var_from { macro_rules! impl_var_from {
@@ -1027,7 +978,19 @@ macro_rules! impl_var_from {
} }
impl_var_from!( impl_var_from!(
i8, i16, i32, i64, isize, u8, u16, u32, u64, usize, String, &str, bool i8,
i16,
i32,
i64,
isize,
u8,
u16,
u32,
u64,
usize,
String,
&str,
bool
); );
#[derive(Default, Clone, Debug)] #[derive(Default, Clone, Debug)]
@@ -1049,7 +1012,7 @@ impl VarTab {
} }
} }
pub fn new() -> Self { pub fn new() -> Self {
let vars = Self::init_sh_vars(); let vars = HashMap::new();
let params = Self::init_params(); let params = Self::init_params();
Self::init_env(); Self::init_env();
let mut var_tab = Self { let mut var_tab = Self {
@@ -1068,11 +1031,6 @@ impl VarTab {
params.insert(ShellParam::LastJob, "".into()); // PID of the last background job (if any) params.insert(ShellParam::LastJob, "".into()); // PID of the last background job (if any)
params params
} }
fn init_sh_vars() -> HashMap<String, Var> {
let mut vars = HashMap::new();
vars.insert("COMP_WORDBREAKS".into(), " \t\n\"'@><=;|&(".into());
vars
}
fn init_env() { fn init_env() {
let pathbuf_to_string = let pathbuf_to_string =
|pb: Result<PathBuf, std::io::Error>| pb.unwrap_or_default().to_string_lossy().to_string(); |pb: Result<PathBuf, std::io::Error>| pb.unwrap_or_default().to_string_lossy().to_string();
@@ -1105,8 +1063,6 @@ impl VarTab {
.map(|hname| hname.to_string_lossy().to_string()) .map(|hname| hname.to_string_lossy().to_string())
.unwrap_or_default(); .unwrap_or_default();
let help_paths = format!("/usr/share/shed/doc:{home}/.local/share/shed/doc");
unsafe { unsafe {
env::set_var("IFS", " \t\n"); env::set_var("IFS", " \t\n");
env::set_var("HOST", hostname.clone()); env::set_var("HOST", hostname.clone());
@@ -1123,7 +1079,6 @@ impl VarTab {
env::set_var("SHELL", pathbuf_to_string(std::env::current_exe())); env::set_var("SHELL", pathbuf_to_string(std::env::current_exe()));
env::set_var("SHED_HIST", format!("{}/.shedhist", home)); env::set_var("SHED_HIST", format!("{}/.shedhist", home));
env::set_var("SHED_RC", format!("{}/.shedrc", home)); env::set_var("SHED_RC", format!("{}/.shedrc", home));
env::set_var("SHED_HPATH", help_paths);
} }
} }
pub fn init_sh_argv(&mut self) { pub fn init_sh_argv(&mut self) {
@@ -1340,15 +1295,6 @@ impl VarTab {
.get(&ShellParam::Status) .get(&ShellParam::Status)
.map(|s| s.to_string()) .map(|s| s.to_string())
.unwrap_or("0".into()), .unwrap_or("0".into()),
ShellParam::AllArgsStr => {
let ifs = get_separator();
self
.params
.get(&ShellParam::AllArgs)
.map(|s| s.replace(markers::ARG_SEP, &ifs).to_string())
.unwrap_or_default()
}
_ => self _ => self
.params .params
.get(&param) .get(&param)
@@ -1359,11 +1305,8 @@ impl VarTab {
} }
/// A table of metadata for the shell /// A table of metadata for the shell
#[derive(Clone, Debug)] #[derive(Clone, Default, Debug)]
pub struct MetaTab { pub struct MetaTab {
// Time when the shell was started, used for calculating shell uptime
shell_time: Instant,
// command running duration // command running duration
runtime_start: Option<Instant>, runtime_start: Option<Instant>,
runtime_stop: Option<Instant>, runtime_stop: Option<Instant>,
@@ -1388,25 +1331,6 @@ pub struct MetaTab {
pending_widget_keys: Vec<KeyEvent>, pending_widget_keys: Vec<KeyEvent>,
} }
impl Default for MetaTab {
fn default() -> Self {
Self {
shell_time: Instant::now(),
runtime_start: None,
runtime_stop: None,
system_msg: vec![],
dir_stack: VecDeque::new(),
getopts_offset: 0,
old_path: None,
old_pwd: None,
path_cache: HashSet::new(),
cwd_cache: HashSet::new(),
comp_specs: HashMap::new(),
pending_widget_keys: vec![],
}
}
}
impl MetaTab { impl MetaTab {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
@@ -1414,9 +1338,6 @@ impl MetaTab {
..Default::default() ..Default::default()
} }
} }
pub fn shell_time(&self) -> Instant {
self.shell_time
}
pub fn set_pending_widget_keys(&mut self, keys: &str) { pub fn set_pending_widget_keys(&mut self, keys: &str) {
let exp = expand_keymap(keys); let exp = expand_keymap(keys);
self.pending_widget_keys = exp; self.pending_widget_keys = exp;
@@ -1861,15 +1782,6 @@ pub fn change_dir<P: AsRef<Path>>(dir: P) -> ShResult<()> {
Ok(()) Ok(())
} }
pub fn get_separator() -> String {
env::var("IFS")
.unwrap_or(String::from(" "))
.chars()
.next()
.unwrap()
.to_string()
}
pub fn get_status() -> i32 { pub fn get_status() -> i32 {
read_vars(|v| v.get_param(ShellParam::Status)) read_vars(|v| v.get_param(ShellParam::Status))
.parse::<i32>() .parse::<i32>()
@@ -1879,44 +1791,19 @@ pub fn set_status(code: i32) {
write_vars(|v| v.set_param(ShellParam::Status, &code.to_string())) write_vars(|v| v.set_param(ShellParam::Status, &code.to_string()))
} }
pub fn source_runtime_file(name: &str, env_var_name: Option<&str>) -> ShResult<()> { pub fn source_rc() -> ShResult<()> {
let etc_path = PathBuf::from(format!("/etc/shed/{name}")); let path = if let Ok(path) = env::var("SHED_RC") {
if etc_path.is_file()
&& let Err(e) = source_file(etc_path)
{
e.print_error();
}
let path = if let Some(name) = env_var_name
&& let Ok(path) = env::var(name)
{
PathBuf::from(&path) PathBuf::from(&path)
} else if let Some(home) = get_home() {
home.join(format!(".{name}"))
} else { } else {
return Err(ShErr::simple( let home = env::var("HOME").unwrap();
ShErrKind::InternalErr, PathBuf::from(format!("{home}/.shedrc"))
"could not determine home path",
));
}; };
if !path.is_file() { if !path.exists() {
return Ok(()); return Err(ShErr::simple(ShErrKind::InternalErr, ".shedrc not found"));
} }
source_file(path) source_file(path)
} }
pub fn source_rc() -> ShResult<()> {
source_runtime_file("shedrc", Some("SHED_RC"))
}
pub fn source_login() -> ShResult<()> {
source_runtime_file("shed_profile", Some("SHED_PROFILE"))
}
pub fn source_env() -> ShResult<()> {
source_runtime_file("shedenv", Some("SHED_ENV"))
}
pub fn source_file(path: PathBuf) -> ShResult<()> { pub fn source_file(path: PathBuf) -> ShResult<()> {
let source_name = path.to_string_lossy().to_string(); let source_name = path.to_string_lossy().to_string();
let mut file = OpenOptions::new().read(true).open(path)?; let mut file = OpenOptions::new().read(true).open(path)?;
@@ -1926,42 +1813,3 @@ pub fn source_file(path: PathBuf) -> ShResult<()> {
exec_input(buf, None, false, Some(source_name))?; exec_input(buf, None, false, Some(source_name))?;
Ok(()) Ok(())
} }
#[track_caller]
pub fn get_home_unchecked() -> PathBuf {
if let Some(home) = get_home() {
home
} else {
let caller = std::panic::Location::caller();
panic!(
"get_home_unchecked: could not determine home directory (called from {}:{})",
caller.file(),
caller.line()
)
}
}
#[track_caller]
pub fn get_home_str_unchecked() -> String {
if let Some(home) = get_home() {
home.to_string_lossy().to_string()
} else {
let caller = std::panic::Location::caller();
panic!(
"get_home_str_unchecked: could not determine home directory (called from {}:{})",
caller.file(),
caller.line()
)
}
}
pub fn get_home() -> Option<PathBuf> {
env::var("HOME")
.ok()
.map(PathBuf::from)
.or_else(|| User::from_uid(getuid()).ok().flatten().map(|u| u.dir))
}
pub fn get_home_str() -> Option<String> {
get_home().map(|h| h.to_string_lossy().to_string())
}

375
src/testutil.rs
View File

@@ -1,240 +1,219 @@
use std::{ use std::{
collections::{HashMap, HashSet}, collections::{HashMap, HashSet},
env, env,
os::fd::{AsRawFd, BorrowedFd, OwnedFd}, os::fd::{AsRawFd, BorrowedFd, OwnedFd},
path::PathBuf, path::PathBuf,
sync::{self, Arc, MutexGuard}, sync::{self, Arc, MutexGuard},
}; };
use nix::{ use nix::{
fcntl::{FcntlArg, OFlag, fcntl}, fcntl::{FcntlArg, OFlag, fcntl},
pty::openpty, pty::openpty,
sys::termios::{OutputFlags, SetArg, tcgetattr, tcsetattr}, sys::termios::{OutputFlags, SetArg, tcgetattr, tcsetattr},
unistd::read, unistd::read,
}; };
use crate::{ use crate::{
expand::expand_aliases, expand::expand_aliases, libsh::error::ShResult, parse::{ParsedSrc, Redir, RedirType, execute::exec_input, lex::LexFlags}, procio::{IoFrame, IoMode, RedirGuard}, readline::register::{restore_registers, save_registers}, state::{MetaTab, SHED, read_logic}
libsh::error::ShResult,
parse::{ParsedSrc, Redir, RedirType, execute::exec_input, lex::LexFlags},
procio::{IoFrame, IoMode, RedirGuard},
readline::register::{restore_registers, save_registers},
state::{MetaTab, SHED, read_logic},
}; };
static TEST_MUTEX: sync::Mutex<()> = sync::Mutex::new(()); static TEST_MUTEX: sync::Mutex<()> = sync::Mutex::new(());
pub fn has_cmds(cmds: &[&str]) -> bool { pub fn has_cmds(cmds: &[&str]) -> bool {
let path_cmds = MetaTab::get_cmds_in_path(); let path_cmds = MetaTab::get_cmds_in_path();
path_cmds.iter().all(|c| cmds.iter().any(|&cmd| c == cmd)) path_cmds.iter().all(|c| cmds.iter().any(|&cmd| c == cmd))
} }
pub fn has_cmd(cmd: &str) -> bool { pub fn has_cmd(cmd: &str) -> bool {
MetaTab::get_cmds_in_path().into_iter().any(|c| c == cmd) MetaTab::get_cmds_in_path().into_iter().any(|c| c == cmd)
} }
pub fn test_input(input: impl Into<String>) -> ShResult<()> { pub fn test_input(input: impl Into<String>) -> ShResult<()> {
exec_input(input.into(), None, false, None) exec_input(input.into(), None, false, None)
} }
pub struct TestGuard { pub struct TestGuard {
_lock: MutexGuard<'static, ()>, _lock: MutexGuard<'static, ()>,
_redir_guard: RedirGuard, _redir_guard: RedirGuard,
old_cwd: PathBuf, old_cwd: PathBuf,
saved_env: HashMap<String, String>, saved_env: HashMap<String, String>,
pty_master: OwnedFd, pty_master: OwnedFd,
pty_slave: OwnedFd, pty_slave: OwnedFd,
cleanups: Vec<Box<dyn FnOnce()>>, cleanups: Vec<Box<dyn FnOnce()>>
} }
impl TestGuard { impl TestGuard {
pub fn new() -> Self { pub fn new() -> Self {
let _lock = TEST_MUTEX.lock().unwrap(); let _lock = TEST_MUTEX.lock().unwrap();
let pty = openpty(None, None).unwrap(); let pty = openpty(None, None).unwrap();
let (pty_master, pty_slave) = (pty.master, pty.slave); let (pty_master,pty_slave) = (pty.master, pty.slave);
let mut attrs = tcgetattr(&pty_slave).unwrap(); let mut attrs = tcgetattr(&pty_slave).unwrap();
attrs.output_flags &= !OutputFlags::ONLCR; attrs.output_flags &= !OutputFlags::ONLCR;
tcsetattr(&pty_slave, SetArg::TCSANOW, &attrs).unwrap(); tcsetattr(&pty_slave, SetArg::TCSANOW, &attrs).unwrap();
let mut frame = IoFrame::new(); let mut frame = IoFrame::new();
frame.push(Redir::new( frame.push(
IoMode::Fd { Redir::new(
tgt_fd: 0, IoMode::Fd {
src_fd: pty_slave.as_raw_fd(), tgt_fd: 0,
}, src_fd: pty_slave.as_raw_fd(),
RedirType::Input, },
)); RedirType::Input,
frame.push(Redir::new( ),
IoMode::Fd { );
tgt_fd: 1, frame.push(
src_fd: pty_slave.as_raw_fd(), Redir::new(
}, IoMode::Fd {
RedirType::Output, tgt_fd: 1,
)); src_fd: pty_slave.as_raw_fd(),
frame.push(Redir::new( },
IoMode::Fd { RedirType::Output,
tgt_fd: 2, ),
src_fd: pty_slave.as_raw_fd(), );
}, frame.push(
RedirType::Output, Redir::new(
)); IoMode::Fd {
tgt_fd: 2,
src_fd: pty_slave.as_raw_fd(),
},
RedirType::Output,
),
);
let _redir_guard = frame.redirect().unwrap(); let _redir_guard = frame.redirect().unwrap();
let old_cwd = env::current_dir().unwrap(); let old_cwd = env::current_dir().unwrap();
let saved_env = env::vars().collect(); let saved_env = env::vars().collect();
SHED.with(|s| s.save()); SHED.with(|s| s.save());
save_registers(); save_registers();
Self { Self {
_lock, _lock,
_redir_guard, _redir_guard,
old_cwd, old_cwd,
saved_env, saved_env,
pty_master, pty_master,
pty_slave, pty_slave,
cleanups: vec![], cleanups: vec![],
} }
} }
pub fn pty_slave(&self) -> BorrowedFd<'_> { pub fn pty_slave(&self) -> BorrowedFd {
unsafe { BorrowedFd::borrow_raw(self.pty_slave.as_raw_fd()) } unsafe { BorrowedFd::borrow_raw(self.pty_slave.as_raw_fd()) }
} }
pub fn add_cleanup(&mut self, f: impl FnOnce() + 'static) { pub fn add_cleanup(&mut self, f: impl FnOnce() + 'static) {
self.cleanups.push(Box::new(f)); self.cleanups.push(Box::new(f));
} }
pub fn read_output(&self) -> String { pub fn read_output(&self) -> String {
let flags = fcntl(self.pty_master.as_raw_fd(), FcntlArg::F_GETFL).unwrap(); let flags = fcntl(self.pty_master.as_raw_fd(), FcntlArg::F_GETFL).unwrap();
let flags = OFlag::from_bits_truncate(flags); let flags = OFlag::from_bits_truncate(flags);
fcntl( fcntl(
self.pty_master.as_raw_fd(), self.pty_master.as_raw_fd(),
FcntlArg::F_SETFL(flags | OFlag::O_NONBLOCK), FcntlArg::F_SETFL(flags | OFlag::O_NONBLOCK),
) ).unwrap();
.unwrap();
let mut out = vec![]; let mut out = vec![];
let mut buf = [0; 4096]; let mut buf = [0;4096];
loop { loop {
match read(self.pty_master.as_raw_fd(), &mut buf) { match read(self.pty_master.as_raw_fd(), &mut buf) {
Ok(0) => break, Ok(0) => break,
Ok(n) => out.extend_from_slice(&buf[..n]), Ok(n) => out.extend_from_slice(&buf[..n]),
Err(_) => break, Err(_) => break,
} }
} }
fcntl(self.pty_master.as_raw_fd(), FcntlArg::F_SETFL(flags)).unwrap(); fcntl(
self.pty_master.as_raw_fd(),
FcntlArg::F_SETFL(flags),
).unwrap();
String::from_utf8_lossy(&out).to_string() String::from_utf8_lossy(&out).to_string()
} }
} }
impl Default for TestGuard { impl Default for TestGuard {
fn default() -> Self { fn default() -> Self {
Self::new() Self::new()
} }
} }
impl Drop for TestGuard { impl Drop for TestGuard {
fn drop(&mut self) { fn drop(&mut self) {
env::set_current_dir(&self.old_cwd).ok(); env::set_current_dir(&self.old_cwd).ok();
for (k, _) in env::vars() { for (k, _) in env::vars() {
unsafe { unsafe { env::remove_var(&k); }
env::remove_var(&k); }
} for (k, v) in &self.saved_env {
} unsafe { env::set_var(k, v); }
for (k, v) in &self.saved_env { }
unsafe { for cleanup in self.cleanups.drain(..).rev() {
env::set_var(k, v); cleanup();
} }
} SHED.with(|s| s.restore());
for cleanup in self.cleanups.drain(..).rev() { restore_registers();
cleanup(); }
}
SHED.with(|s| s.restore());
restore_registers();
}
} }
pub fn get_ast(input: &str) -> ShResult<Vec<crate::parse::Node>> { pub fn get_ast(input: &str) -> ShResult<Vec<crate::parse::Node>> {
let log_tab = read_logic(|l| l.clone()); let log_tab = read_logic(|l| l.clone());
let input = expand_aliases(input.into(), HashSet::new(), &log_tab); let input = expand_aliases(input.into(), HashSet::new(), &log_tab);
let source_name = "test_input".to_string(); let source_name = "test_input".to_string();
let mut parser = ParsedSrc::new(Arc::new(input)) let mut parser = ParsedSrc::new(Arc::new(input))
.with_lex_flags(LexFlags::empty()) .with_lex_flags(LexFlags::empty())
.with_name(source_name.clone()); .with_name(source_name.clone());
parser parser.parse_src().map_err(|e| e.into_iter().next().unwrap())?;
.parse_src()
.map_err(|e| e.into_iter().next().unwrap())?;
Ok(parser.extract_nodes()) Ok(parser.extract_nodes())
} }
impl crate::parse::Node { impl crate::parse::Node {
pub fn assert_structure( pub fn assert_structure(&mut self, expected: &mut impl Iterator<Item = NdKind>) -> Result<(), String> {
&mut self, let mut full_structure = vec![];
expected: &mut impl Iterator<Item = NdKind>, let mut before = vec![];
) -> Result<(), String> { let mut after = vec![];
let mut full_structure = vec![]; let mut offender = None;
let mut before = vec![];
let mut after = vec![];
let mut offender = None;
self.walk_tree(&mut |s| { self.walk_tree(&mut |s| {
let expected_rule = expected.next(); let expected_rule = expected.next();
full_structure.push(s.class.as_nd_kind()); full_structure.push(s.class.as_nd_kind());
if offender.is_none() if offender.is_none() && expected_rule.as_ref().map_or(true, |e| *e != s.class.as_nd_kind()) {
&& expected_rule offender = Some((s.class.as_nd_kind(), expected_rule));
.as_ref() } else if offender.is_none() {
.is_none_or(|e| *e != s.class.as_nd_kind()) before.push(s.class.as_nd_kind());
{ } else {
offender = Some((s.class.as_nd_kind(), expected_rule)); after.push(s.class.as_nd_kind());
} else if offender.is_none() { }
before.push(s.class.as_nd_kind()); });
} else {
after.push(s.class.as_nd_kind());
}
});
assert!( assert!(expected.next().is_none(), "Expected structure has more nodes than actual structure");
expected.next().is_none(),
"Expected structure has more nodes than actual structure"
);
if let Some((nd_kind, expected_rule)) = offender { if let Some((nd_kind, expected_rule)) = offender {
let expected_rule = expected_rule.map_or("(none — expected array too short)".into(), |e| { let expected_rule = expected_rule.map_or("(none — expected array too short)".into(), |e| format!("{e:?}"));
format!("{e:?}") let full_structure_hint = full_structure.into_iter()
}); .map(|s| format!("\tNdKind::{s:?},"))
let full_structure_hint = full_structure .collect::<Vec<String>>()
.into_iter() .join("\n");
.map(|s| format!("\tNdKind::{s:?},")) let full_structure_hint = format!("let expected = &mut [\n{full_structure_hint}\n].into_iter();");
.collect::<Vec<String>>()
.join("\n");
let full_structure_hint =
format!("let expected = &mut [\n{full_structure_hint}\n].into_iter();");
let output = [ let output = [
"Structure assertion failed!\n".into(), "Structure assertion failed!\n".into(),
format!( format!("Expected node type '{:?}', found '{:?}'", expected_rule, nd_kind),
"Expected node type '{:?}', found '{:?}'", format!("Before offender: {:?}", before),
expected_rule, nd_kind format!("After offender: {:?}\n", after),
), format!("hint: here is the full structure as an array\n {full_structure_hint}"),
format!("Before offender: {:?}", before), ].join("\n");
format!("After offender: {:?}\n", after),
format!("hint: here is the full structure as an array\n {full_structure_hint}"),
]
.join("\n");
Err(output) Err(output)
} else { } else {
Ok(()) Ok(())
} }
} }
} }
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
@@ -248,26 +227,26 @@ pub enum NdKind {
Conjunction, Conjunction,
Assignment, Assignment,
BraceGrp, BraceGrp,
Negate, Negate,
Test, Test,
FuncDef, FuncDef,
} }
impl crate::parse::NdRule { impl crate::parse::NdRule {
pub fn as_nd_kind(&self) -> NdKind { pub fn as_nd_kind(&self) -> NdKind {
match self { match self {
Self::Negate { .. } => NdKind::Negate, Self::Negate { .. } => NdKind::Negate,
Self::IfNode { .. } => NdKind::IfNode, Self::IfNode { .. } => NdKind::IfNode,
Self::LoopNode { .. } => NdKind::LoopNode, Self::LoopNode { .. } => NdKind::LoopNode,
Self::ForNode { .. } => NdKind::ForNode, Self::ForNode { .. } => NdKind::ForNode,
Self::CaseNode { .. } => NdKind::CaseNode, Self::CaseNode { .. } => NdKind::CaseNode,
Self::Command { .. } => NdKind::Command, Self::Command { .. } => NdKind::Command,
Self::Pipeline { .. } => NdKind::Pipeline, Self::Pipeline { .. } => NdKind::Pipeline,
Self::Conjunction { .. } => NdKind::Conjunction, Self::Conjunction { .. } => NdKind::Conjunction,
Self::Assignment { .. } => NdKind::Assignment, Self::Assignment { .. } => NdKind::Assignment,
Self::BraceGrp { .. } => NdKind::BraceGrp, Self::BraceGrp { .. } => NdKind::BraceGrp,
Self::Test { .. } => NdKind::Test, Self::Test { .. } => NdKind::Test,
Self::FuncDef { .. } => NdKind::FuncDef, Self::FuncDef { .. } => NdKind::FuncDef,
} }
} }
} }