Files

118 lines
5.4 KiB
Python

"""A shell command's simple commands, each as its words and the directory it runs in, and which tool a simple command runs through which launchers."""
import dataclasses
import posixpath
import re
import shlex
import typing
# Launchers that run the tool named later in their words, such as uvx --with pytest mutmut run, uv run mutmut run or sudo docker build.
LAUNCHERS = frozenset({"bunx", "doas", "env", "nice", "npx", "pipx", "pnpm", "poetry", "run-heavy", "sudo", "time", "timeout", "uv", "uvx", "yarn"})
HEREDOC = re.compile(r"<<-?[ \t]*([\"']?)([A-Za-z_]\w*)\1[^\n]*\n.*?^[ \t]*\2[ \t]*$", re.DOTALL | re.MULTILINE)
ASSIGNMENT = re.compile(r"[A-Za-z_][A-Za-z0-9_]*=")
OPERATOR = set("\n();&|<>")
# A token that is only a redirect: the command's words go on after its target. `&<` is not one: it is a `&` that ends the command, then a `<`.
REDIRECT = re.compile(r"&>>?|[<>]+[&|]?")
# A quoted string or an escape is taken whole, so a # inside one starts no comment; a comment starts a word.
PIECE = re.compile(r"""'[^']*'|"(?:\\.|[^"\\])*"|\\.|(?<![^\s;&|()])#[^\n]*""", re.DOTALL)
@dataclasses.dataclass(frozen=True)
class Launch:
"""A tool a simple command runs: the launchers it runs through, such as nice and run-heavy; the word that names the tool, as written; the words before that word; and the tool's arguments."""
launchers: frozenset[str]
tool: str
word: str
before: list[str]
arguments: list[str]
@dataclasses.dataclass(frozen=True)
class Simple:
words: list[str]
directory: str
def simple_commands(command: str, cwd: str, home: str) -> list[Simple]:
"""Each simple command, without leading variable assignments or redirect targets, in the directory `cd` left it in."""
directory = cwd
found = []
for words in segments(command):
if words[0] == "cd" and len(words) == 2:
directory = resolved(directory, words[1], home)
found.append(Simple(words, directory))
return found
def segments(command: str) -> list[list[str]]:
"""The command's simple commands as lists of words, split at ; & | ( ) and line breaks, without redirect targets. Shell forms it does not parse:
- a quoted string is one word, so `bash -c "git commit"` and `echo "$(git commit)"` hide the inner command;
- a backtick substitution stays inside its words, while `$(git commit)` outside quotes splits into the `$` and a command of its own;
- a keyword or a brace opens its command's words, so `then git commit` reads as the command `then`;
- `<(...)` and `>(...)` end the command, and the first word inside them is dropped as a redirect target, so `tee >(git commit)` hides the commit;
- a file descriptor before a redirect, as in `2>&1`, stays a word;
- a heredoc's body is dropped;
- variables, aliases and functions are not expanded;
- a line with an unbalanced quote doesn't yield anything."""
text = uncommented(HEREDOC.sub(lambda heredoc: heredoc.group(0).split("\n", 1)[0], command))
tokens = lexed(text)
if tokens is None:
# One unbalanced quote should not hide the other lines.
tokens = [token for line in text.splitlines() for token in (lexed(line) or []) + ["\n"]]
found: list[list[str]] = [[]]
target = False
for token in tokens:
if target:
target = False
elif REDIRECT.fullmatch(token):
# A redirect's target is not an operand.
target = True
elif set(token) <= OPERATOR and token:
# A separator, or a redirect glued to one as in `;>f`, `&<f` or `<(`: the word after the redirect is its target.
target = "<" in token or ">" in token
found.append([])
elif found[-1] or not ASSIGNMENT.match(token):
found[-1].append(token)
return [words for words in found if words]
def lexed(text: str) -> list[str] | None:
lexer = shlex.shlex(text, posix=True, punctuation_chars="();<>|&\n")
lexer.commenters = ""
lexer.whitespace = " \t\r"
lexer.whitespace_split = True
try:
return list(lexer)
except ValueError:
return None
def uncommented(text: str) -> str:
"""The text without its comments; shlex's own would also swallow the line break that ends one, joining two commands."""
return PIECE.sub(lambda piece: "" if piece.group(0).startswith("#") else piece.group(0), text)
def resolved(base: str, path: str, home: str) -> str:
return posixpath.normpath(posixpath.join(base, home + path[1:] if path == "~" or path.startswith("~/") else path))
def home_word(token: str) -> str:
"""The word with a leading $HOME or ${HOME} spelt as ~; the lexer has joined a quoted "$HOME" to the rest of its word."""
return re.sub(r"^\$(HOME|\{HOME\})(?=/|$)", "~", token)
def tool_name(word: str) -> str:
"""The tool a word names, such as mutmut for `mutmut>=3,<4` or `.venv/bin/mutmut`; empty for a word that names none, such as a file name."""
named = re.fullmatch(r"([A-Za-z_-]+)(?:[<>=!~@].*)?", posixpath.basename(word))
return named.group(1) if named else ""
def launched(words: list[str], tools: typing.Collection[str]) -> Launch | None:
"""Which of the given tools the simple command runs, directly or through launchers, taking the first one named; None where it doesn't run any of them."""
names = [tool_name(word) for word in words]
# Past a launcher, the tool may follow the launcher's own options and assignments, as in nice -n 19 docker build; without one, the command itself is the tool.
reachable = names if names[:1] and names[0] in LAUNCHERS else names[:1]
at = next((i for i, name in enumerate(reachable) if name in tools), None)
if at is None:
return None
return Launch(frozenset(LAUNCHERS.intersection(names[:at])), names[at], words[at], words[:at], words[at + 1:])