use std::collections::{HashMap, HashSet};
use tree_sitter::Node;
mod javascript;
mod python;
mod strict;
mod unit;
pub use unit::{Arg, MAX_DEPTH, MAX_LEN, MAX_TREE_DEPTH};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Language {
Python,
JavaScript,
}
#[derive(Debug, Clone)]
pub enum Act {
Remove(Arg),
Write(Arg),
Read(Arg),
ReadTree(Arg),
Opaque(Arg),
Move {
from: Arg,
to: Arg,
},
Link {
target: Arg,
link: Arg,
},
Chmod {
path: Arg,
mode: Arg,
},
Chown(Arg),
Chdir(Arg),
In(Arg, Vec<Act>),
Script(Arg),
Program(Vec<Arg>),
Code(Language, String),
Unread(String),
Downloaded(String),
Loads(String),
Environment,
Started(Vec<Act>),
}
const LOADING: [&str; 17] = [
"PYTHONPATH",
"NODE_OPTIONS",
"NODE_PATH",
"LD_PRELOAD",
"LD_LIBRARY_PATH",
"DYLD_INSERT_LIBRARIES",
"DYLD_LIBRARY_PATH",
"BASH_ENV",
"ENV",
"PATH",
"PYTHONSTARTUP",
"SHELLOPTS",
"PROMPT_COMMAND",
"PS4",
"IFS",
"CDPATH",
"HOME",
];
pub(crate) fn judged_variable(name: &str) -> bool {
let name = name.to_ascii_uppercase();
LOADING.contains(&name.as_str())
|| ["LD_", "DYLD_", "PYTHON", "NODE_", "BASH_FUNC_", "GIT_"]
.iter()
.any(|prefix| name.starts_with(prefix))
}
pub(crate) fn mark_environment(acts: Vec<Act>) -> Vec<Act> {
fn writes(act: &Act) -> bool {
match act {
Act::Environment => true,
Act::In(_, acts) | Act::Started(acts) => acts.iter().any(writes),
_ => false,
}
}
fn mark(act: Act) -> Act {
match act {
Act::Program(_) | Act::Script(_) => Act::Started(vec![act]),
Act::In(dir, acts) => Act::In(dir, acts.into_iter().map(mark).collect()),
other => other,
}
}
if acts.iter().any(writes) {
acts.into_iter().map(mark).collect()
} else {
acts
}
}
#[derive(Debug, Default)]
pub struct Reading {
pub acts: Vec<Act>,
pub deep: bool,
}
impl Reading {
fn unread(&mut self, code: &str) {
self.acts.push(Act::Unread(shorten(code)));
}
}
pub fn read(language: Language, code: &str) -> Reading {
let mut reading = match language {
Language::Python => python::read(code),
Language::JavaScript => javascript::read(code),
};
reading.acts = mark_environment(std::mem::take(&mut reading.acts));
reading
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Understanding {
NotUnderstood,
Understood {
imports: bool,
},
}
pub fn understand(language: Language, code: &str) -> Understanding {
match strict::reads_whole(language, code) {
None => Understanding::NotUnderstood,
Some(imports) => Understanding::Understood { imports },
}
}
pub fn understand_python2(code: &str) -> Understanding {
match strict::reads_whole_python2(code) {
None => Understanding::NotUnderstood,
Some(imports) => Understanding::Understood { imports },
}
}
pub fn declares_other_encoding(code: &str) -> bool {
python::declares_other_encoding(code)
}
#[derive(Clone, Copy)]
pub(crate) struct Ancestor<'t> {
pub(crate) node: Node<'t>,
pub(crate) field: Option<&'static str>,
}
pub(crate) fn walk<'t>(
root: Node<'t>,
mut visit: impl FnMut(Node<'t>, Option<&'static str>, &[Ancestor<'t>]) -> bool,
) {
let mut cursor = root.walk();
let mut above: Vec<Ancestor<'t>> = Vec::new();
loop {
let node = cursor.node();
let field = cursor.field_name();
if !visit(node, field, &above) {
return;
}
if cursor.goto_first_child() {
above.push(Ancestor { node, field });
continue;
}
loop {
if cursor.goto_next_sibling() {
break;
}
if !cursor.goto_parent() {
return;
}
above.pop();
}
}
}
fn shorten(code: &str) -> String {
let line = code.lines().next().unwrap_or_default().trim();
let mut short: String = line.chars().take(60).collect();
if short.len() < line.len() {
short.push('…');
}
short
}
fn path(value: Option<String>, code: &str) -> Arg {
match value {
Some(text) => Arg::Known(text),
None => Arg::Unknown(shorten(code)),
}
}
#[derive(Debug, Default)]
pub(crate) struct Parts {
pub(crate) text: String,
pub(crate) whole: bool,
}
impl Parts {
pub(crate) fn whole(text: String) -> Self {
Self { text, whole: true }
}
pub(crate) fn partial(text: String) -> Self {
Self { text, whole: false }
}
pub(crate) fn unknown() -> Self {
Self::default()
}
pub(crate) fn value(self) -> Option<String> {
self.whole.then_some(self.text)
}
}
pub(crate) fn named_path(text: &str) -> Option<Arg> {
if text.contains('\n') {
return None;
}
if text.is_char_boundary(5) && text[..5].eq_ignore_ascii_case("file:") {
let rest = &text[5..];
let rest = match rest.strip_prefix("//") {
Some(after) => after.find('/').map_or("", |at| &after[at..]),
None => rest,
};
return Some(if rest.is_empty() || rest.contains('%') {
Arg::Unknown(shorten(text))
} else {
Arg::Known(rest.to_string())
});
}
(text.starts_with(['/', '~']) || text == ".." || text.starts_with("../"))
.then(|| Arg::Known(text.to_string()))
}
fn under(known: &str, code: &str) -> Option<Arg> {
let end = known.rfind('/')? + 1;
Some(Arg::Below {
folder: known[..end].to_string(),
source: shorten(code),
})
}
fn read_path(parts: Parts, code: &str) -> Arg {
if parts.whole {
Arg::Known(parts.text)
} else {
under(&parts.text, code).unwrap_or_else(|| Arg::Unknown(shorten(code)))
}
}
pub(crate) fn argument_lists(words: Vec<Vec<Arg>>) -> Vec<Vec<Arg>> {
let mut lists: Vec<Vec<Arg>> = vec![Vec::new()];
for choices in words {
let choices =
if choices.is_empty() || lists.len().saturating_mul(choices.len()) > MAX_CHOICES {
let shown = choices.first().map_or("an argument", Arg::text);
vec![Arg::Unknown(shorten(shown))]
} else {
choices
};
lists = lists
.iter()
.flat_map(|list| {
choices.iter().map(move |choice| {
let mut next = list.clone();
next.push(choice.clone());
next
})
})
.collect();
}
lists
}
pub(crate) const MAX_STRING: usize = 4 * 1024;
const MAX_NOTED: usize = 4 * MAX_LEN;
const MAX_EXPANDED: usize = 1024;
#[derive(Debug, Default)]
struct Noted {
strings: Vec<String>,
seen: HashSet<String>,
folders: Vec<String>,
dropped: bool,
}
#[derive(Debug)]
pub(crate) enum Holds {
Nothing,
One(String),
Below(String),
Lost,
}
#[derive(Debug)]
pub(crate) enum Expansion {
Nothing,
Paths(Vec<Arg>),
Lost,
}
#[derive(Debug, Default)]
pub(crate) struct Constants {
names: HashMap<String, Noted>,
bytes: usize,
expanded: usize,
evaluations: usize,
multi: Vec<String>,
picks: HashMap<String, usize>,
pub(crate) lost: bool,
unresolved: HashSet<String>,
consulted: HashSet<String>,
changed: bool,
everything: bool,
}
pub(crate) const MAX_ROUNDS: usize = 6;
const MAX_CHOICES: usize = 256;
const MAX_EVALUATIONS: usize = 64 * 1024;
impl Constants {
pub(crate) fn note(&mut self, name: &str, value: String) {
let noted = self.names.entry(name.to_string()).or_default();
if noted.dropped || noted.seen.contains(&value) {
return;
}
if value.len() > MAX_STRING || self.bytes + 2 * value.len() > MAX_NOTED {
self.drop_name(name);
return;
}
self.bytes += 2 * value.len();
noted.seen.insert(value.clone());
noted.strings.push(value);
}
pub(crate) fn note_folder(&mut self, name: &str, folder: String) {
let noted = self.names.entry(name.to_string()).or_default();
if noted.dropped || noted.folders.contains(&folder) {
return;
}
if folder.len() > MAX_STRING || self.bytes + folder.len() > MAX_NOTED {
self.drop_name(name);
return;
}
self.bytes += folder.len();
noted.folders.push(folder);
}
pub(crate) fn over(&mut self, on: bool, text: &str) -> bool {
let over = on && text.len() > MAX_STRING;
self.lost |= over;
over
}
pub(crate) fn drop_name(&mut self, name: &str) {
let noted = self.names.entry(name.to_string()).or_default();
let freed: usize = noted
.strings
.iter()
.map(|text| 2 * text.len())
.sum::<usize>()
+ noted.folders.iter().map(String::len).sum::<usize>();
self.bytes = self.bytes.saturating_sub(freed);
*noted = Noted {
dropped: true,
..Noted::default()
};
}
pub(crate) fn holds(&mut self, name: &str) -> Holds {
if self.everything || self.unresolved.contains(name) {
self.lost = true;
} else {
self.consulted.insert(name.to_string());
}
let Some(noted) = self.names.get(name) else {
return Holds::Nothing;
};
if let Some(string) = self.picks.get(name).and_then(|at| noted.strings.get(*at)) {
return Holds::One(string.clone());
}
match (
noted.dropped,
noted.strings.as_slice(),
noted.folders.as_slice(),
) {
(true, _, _) => {
self.lost = true;
Holds::Lost
}
(false, [one], []) => Holds::One(one.clone()),
(false, [], [folder]) => Holds::Below(folder.clone()),
(false, [], []) => Holds::Nothing,
(false, [_, _, ..], []) => {
if !self.multi.iter().any(|met| met == name) {
self.multi.push(name.to_string());
}
Holds::Nothing
}
_ => {
self.lost = true;
Holds::Lost
}
}
}
pub(crate) fn mark(&mut self, name: &str) {
if self.unresolved.insert(name.to_string()) && self.consulted.contains(name) {
self.changed = true;
}
}
pub(crate) fn everything(&mut self) {
self.everything = true;
}
pub(crate) fn stale(&self) -> bool {
self.changed
}
pub(crate) fn start_round(&mut self) {
self.names.clear();
self.bytes = 0;
self.evaluations = 0;
self.consulted.clear();
self.changed = false;
self.lost = false;
self.begin();
}
pub(crate) fn begin(&mut self) {
self.multi.clear();
self.picks.clear();
}
pub(crate) fn pending(&self) -> bool {
self.multi.iter().any(|name| !self.picks.contains_key(name))
}
pub(crate) fn advance(&mut self) -> bool {
if self.multi.is_empty() {
return false;
}
self.evaluations += 1;
if self.evaluations > MAX_EVALUATIONS {
self.lost = true;
return false;
}
let mut met = false;
for name in &self.multi {
if !self.picks.contains_key(name) {
self.picks.insert(name.clone(), 0);
met = true;
}
}
if met {
return true;
}
let total: usize = self
.multi
.iter()
.map(|name| self.names.get(name).map_or(1, |noted| noted.strings.len()))
.fold(1, usize::saturating_mul);
if total > MAX_CHOICES {
self.lost = true;
return false;
}
for name in self.multi.iter().rev() {
let count = self.names.get(name).map_or(1, |noted| noted.strings.len());
let at = self.picks.get(name).copied().unwrap_or(0);
if at + 1 < count {
self.picks.insert(name.clone(), at + 1);
return true;
}
self.picks.insert(name.clone(), 0);
}
false
}
pub(crate) fn spend(&mut self, count: usize) -> bool {
if self.expanded + count > MAX_EXPANDED {
return false;
}
self.expanded += count;
true
}
pub(crate) fn paths(&mut self, name: &str, code: &str) -> Expansion {
let Some(noted) = self.names.get(name) else {
return Expansion::Nothing;
};
if noted.dropped {
return Expansion::Lost;
}
let count = noted.strings.len() + noted.folders.len();
if count == 0 {
return Expansion::Nothing;
}
let unresolved = self.everything || self.unresolved.contains(name);
let count = count + usize::from(unresolved);
if self.expanded + count > MAX_EXPANDED {
return Expansion::Lost;
}
self.expanded += count;
let Some(noted) = self.names.get(name) else {
return Expansion::Nothing;
};
let strings = noted.strings.iter().map(|text| Arg::Known(text.clone()));
let folders = noted
.folders
.iter()
.filter_map(|folder| under(folder, code));
let mut paths: Vec<Arg> = strings.chain(folders).collect();
if unresolved {
paths.push(Arg::Unknown(shorten(code)));
}
Expansion::Paths(paths)
}
}
fn join(base: &str, next: &str) -> String {
if next.starts_with(['/', '~']) || base.is_empty() {
next.to_string()
} else if base.ends_with('/') {
format!("{base}{next}")
} else {
format!("{base}/{next}")
}
}
fn environment(name: &str) -> Option<String> {
match name {
"HOME" | "USERPROFILE" => Some("~".to_string()),
"PWD" => Some(".".to_string()),
"TMPDIR" | "TEMP" | "TMP" => Some("/tmp".to_string()),
_ => None,
}
}
fn mode(literal: &str) -> Option<String> {
let text = literal.replace('_', "");
let lower = text.to_ascii_lowercase();
let number = if let Some(digits) = lower.strip_prefix("0o") {
u32::from_str_radix(digits, 8)
} else if let Some(digits) = lower.strip_prefix("0x") {
u32::from_str_radix(digits, 16)
} else if let Some(digits) = lower.strip_prefix("0b") {
u32::from_str_radix(digits, 2)
} else if lower.len() > 1 && lower.starts_with('0') {
u32::from_str_radix(&lower[1..], 8)
} else {
lower.parse()
};
number.ok().map(|number| format!("{number:o}"))
}
fn pid(literal: &str) -> Option<String> {
let mut text: String = literal.chars().filter(|c| !c.is_whitespace()).collect();
while text.len() > 1 && text.starts_with('(') && text.ends_with(')') {
text = text[1..text.len() - 1].to_string();
}
let mut negative = false;
while let Some(rest) = text.strip_prefix(['-', '+']) {
negative ^= text.starts_with('-');
text = rest.to_string();
}
let lower = text.replace('_', "").to_ascii_lowercase();
let number = if let Some(digits) = lower.strip_prefix("0x") {
i64::from_str_radix(digits, 16)
} else if let Some(digits) = lower.strip_prefix("0o") {
i64::from_str_radix(digits, 8)
} else if let Some(digits) = lower.strip_prefix("0b") {
i64::from_str_radix(digits, 2)
} else if lower.len() > 1 && lower.starts_with('0')
|| !lower.bytes().all(|b| b.is_ascii_digit())
{
return None;
} else {
lower.parse()
};
let number = number.ok()?;
Some(if negative { -number } else { number }.to_string())
}
fn kill(literal: &str) -> Act {
match pid(literal) {
Some(pid) => Act::Program(vec![
Arg::Known("kill".to_string()),
Arg::Known("--".to_string()),
Arg::Known(pid),
]),
None => Act::Unread(shorten(literal)),
}
}
fn writes(mode: Option<&str>) -> bool {
mode.is_some_and(|mode| mode.contains(['w', 'a', 'x', '+']))
}
fn data_url(specifier: &str) -> bool {
let cleaned: String = specifier
.trim_start_matches(|c: char| c <= ' ')
.chars()
.filter(|c| !matches!(c, '\t' | '\n' | '\r'))
.take(5)
.collect();
cleaned.eq_ignore_ascii_case("data:")
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Foreign {
Downloaded,
Outside,
}
fn foreign_module(specifier: &str) -> Option<Foreign> {
let cleaned: String = specifier
.trim_start_matches(|c: char| c <= ' ')
.chars()
.filter(|c| !matches!(c, '\t' | '\n' | '\r'))
.collect();
let lower = cleaned.to_ascii_lowercase();
if ["http:", "https:", "jsr:", "npm:"]
.iter()
.any(|scheme| lower.starts_with(scheme))
{
return Some(Foreign::Downloaded);
}
let drive = {
let mut chars = cleaned.chars();
chars.next().is_some_and(|c| c.is_ascii_alphabetic()) && chars.next() == Some(':')
};
(lower.starts_with("file:")
|| cleaned.starts_with(['/', '\\', '~'])
|| cleaned == ".."
|| cleaned.starts_with("../")
|| cleaned.starts_with("..\\")
|| drive)
.then_some(Foreign::Outside)
}
pub fn is_data_url(specifier: &str) -> bool {
data_url(specifier)
}
pub fn is_foreign_module(specifier: &str) -> bool {
foreign_module(specifier).is_some()
}
pub(crate) fn loads(specifier: &str, code: &str) -> Option<Act> {
Some(match foreign_module(specifier)? {
Foreign::Downloaded => Act::Downloaded(shorten(code)),
Foreign::Outside => Act::Loads(shorten(code)),
})
}
#[cfg(doctest)]
#[allow(
clippy::disallowed_macros,
reason = "the README include is read by rustdoc's doctest pass only"
)]
#[doc = include_str!("../README.md")]
mod readme {}