864 lines
22 KiB
Rust
864 lines
22 KiB
Rust
use std::{
|
|
collections::HashSet, fmt::Debug, path::PathBuf, sync::Arc,
|
|
};
|
|
|
|
use nix::sys::signal::Signal;
|
|
|
|
use crate::{
|
|
builtin::complete::{CompFlags, CompOptFlags, CompOpts},
|
|
libsh::{
|
|
error::ShResult,
|
|
utils::TkVecUtils,
|
|
},
|
|
parse::{
|
|
execute::{VarCtxGuard, exec_input},
|
|
lex::{self, LexFlags, Tk, TkRule, ends_with_unescaped},
|
|
},
|
|
readline::{
|
|
Marker, annotate_input_recursive,
|
|
markers::{self, is_marker},
|
|
},
|
|
state::{VarFlags, VarKind, read_jobs, read_logic, read_meta, read_vars, write_vars},
|
|
};
|
|
|
|
pub fn complete_signals(start: &str) -> Vec<String> {
|
|
Signal::iterator()
|
|
.map(|s| {
|
|
s.to_string()
|
|
.strip_prefix("SIG")
|
|
.unwrap_or(s.as_ref())
|
|
.to_string()
|
|
})
|
|
.filter(|s| s.starts_with(start))
|
|
.collect()
|
|
}
|
|
|
|
pub fn complete_aliases(start: &str) -> Vec<String> {
|
|
read_logic(|l| {
|
|
l.aliases()
|
|
.iter()
|
|
.filter(|a| a.0.starts_with(start))
|
|
.map(|a| a.0.clone())
|
|
.collect()
|
|
})
|
|
}
|
|
|
|
pub fn complete_jobs(start: &str) -> Vec<String> {
|
|
if let Some(prefix) = start.strip_prefix('%') {
|
|
read_jobs(|j| {
|
|
j.jobs()
|
|
.iter()
|
|
.filter_map(|j| j.as_ref())
|
|
.filter_map(|j| j.name())
|
|
.filter(|name| name.starts_with(prefix))
|
|
.map(|name| format!("%{name}"))
|
|
.collect()
|
|
})
|
|
} else {
|
|
read_jobs(|j| {
|
|
j.jobs()
|
|
.iter()
|
|
.filter_map(|j| j.as_ref())
|
|
.map(|j| j.pgid().to_string())
|
|
.filter(|pgid| pgid.starts_with(start))
|
|
.collect()
|
|
})
|
|
}
|
|
}
|
|
|
|
pub fn complete_users(start: &str) -> Vec<String> {
|
|
let Ok(passwd) = std::fs::read_to_string("/etc/passwd") else {
|
|
return vec![];
|
|
};
|
|
passwd
|
|
.lines()
|
|
.filter_map(|line| line.split(':').next())
|
|
.filter(|username| username.starts_with(start))
|
|
.map(|s| s.to_string())
|
|
.collect()
|
|
}
|
|
|
|
pub fn complete_vars(start: &str) -> Vec<String> {
|
|
let Some((var_name, name_start, _end)) = extract_var_name(start) else {
|
|
return vec![];
|
|
};
|
|
if !read_vars(|v| v.get_var(&var_name)).is_empty() {
|
|
return vec![];
|
|
}
|
|
// if we are here, we have a variable substitution that isn't complete
|
|
// so let's try to complete it
|
|
let prefix = &start[..name_start]; // e.g. "$" or "${"
|
|
read_vars(|v| {
|
|
v.flatten_vars()
|
|
.keys()
|
|
.filter(|k| k.starts_with(&var_name) && *k != &var_name)
|
|
.map(|k| format!("{prefix}{k}"))
|
|
.collect::<Vec<_>>()
|
|
})
|
|
}
|
|
|
|
pub fn extract_var_name(text: &str) -> Option<(String, usize, usize)> {
|
|
let mut chars = text.chars().peekable();
|
|
let mut name = String::new();
|
|
let mut reading_name = false;
|
|
let mut pos = 0;
|
|
let mut name_start = 0;
|
|
let mut name_end = 0;
|
|
|
|
while let Some(ch) = chars.next() {
|
|
match ch {
|
|
'$' => {
|
|
if chars.peek() == Some(&'{') {
|
|
continue;
|
|
}
|
|
|
|
reading_name = true;
|
|
name_start = pos + 1; // Start after the '$'
|
|
}
|
|
'{' if !reading_name => {
|
|
reading_name = true;
|
|
name_start = pos + 1;
|
|
}
|
|
ch if ch.is_alphanumeric() || ch == '_' => {
|
|
if reading_name {
|
|
name.push(ch);
|
|
}
|
|
}
|
|
_ => {
|
|
if reading_name {
|
|
name_end = pos; // End before the non-alphanumeric character
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
pos += 1;
|
|
}
|
|
|
|
if !reading_name {
|
|
return None;
|
|
}
|
|
|
|
if name_end == 0 {
|
|
name_end = pos;
|
|
}
|
|
|
|
Some((name, name_start, name_end))
|
|
}
|
|
|
|
fn complete_commands(start: &str) -> Vec<String> {
|
|
let mut candidates: Vec<String> = read_meta(|m| {
|
|
m.cached_cmds()
|
|
.iter()
|
|
.filter(|c| c.starts_with(start))
|
|
.cloned()
|
|
.collect()
|
|
});
|
|
|
|
candidates.sort();
|
|
candidates
|
|
}
|
|
|
|
fn complete_dirs(start: &str) -> Vec<String> {
|
|
let filenames = complete_filename(start);
|
|
filenames
|
|
.into_iter()
|
|
.filter(|f| std::fs::metadata(f).map(|m| m.is_dir()).unwrap_or(false))
|
|
.collect()
|
|
}
|
|
|
|
fn complete_filename(start: &str) -> Vec<String> {
|
|
let mut candidates = vec![];
|
|
let has_dotslash = start.starts_with("./");
|
|
|
|
// Split path into directory and filename parts
|
|
// Use "." if start is empty (e.g., after "foo=")
|
|
let path = PathBuf::from(if start.is_empty() { "." } else { start });
|
|
let (dir, prefix) = if start.ends_with('/') || start.is_empty() {
|
|
// Completing inside a directory: "src/" → dir="src/", prefix=""
|
|
(path, "")
|
|
} else if let Some(parent) = path.parent()
|
|
&& !parent.as_os_str().is_empty()
|
|
{
|
|
// Has directory component: "src/ma" → dir="src", prefix="ma"
|
|
(
|
|
parent.to_path_buf(),
|
|
path.file_name().unwrap().to_str().unwrap_or(""),
|
|
)
|
|
} else {
|
|
// No directory: "fil" → dir=".", prefix="fil"
|
|
(PathBuf::from("."), start)
|
|
};
|
|
|
|
let Ok(entries) = std::fs::read_dir(&dir) else {
|
|
return candidates;
|
|
};
|
|
|
|
for entry in entries.flatten() {
|
|
let file_name = entry.file_name();
|
|
let file_str = file_name.to_string_lossy();
|
|
|
|
// Skip hidden files unless explicitly requested
|
|
if !prefix.starts_with('.') && file_str.starts_with('.') {
|
|
continue;
|
|
}
|
|
|
|
if file_str.starts_with(prefix) {
|
|
// Reconstruct full path
|
|
let mut full_path = dir.join(&file_name);
|
|
|
|
// Add trailing slash for directories
|
|
if entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false) {
|
|
full_path.push(""); // adds trailing /
|
|
}
|
|
|
|
let mut path_raw = full_path.to_string_lossy().to_string();
|
|
if path_raw.starts_with("./") && !has_dotslash {
|
|
path_raw = path_raw.trim_start_matches("./").to_string();
|
|
}
|
|
|
|
candidates.push(path_raw);
|
|
}
|
|
}
|
|
|
|
candidates.sort();
|
|
candidates
|
|
}
|
|
|
|
pub enum CompSpecResult {
|
|
NoSpec, // No compspec registered
|
|
NoMatch { flags: CompOptFlags }, /* Compspec found but no candidates matched, returns
|
|
* behavior flags */
|
|
Match { result: CompResult, flags: CompOptFlags }, // Compspec found and candidates returned
|
|
}
|
|
|
|
#[derive(Default, Debug, Clone)]
|
|
pub struct BashCompSpec {
|
|
/// -F: The name of a function to generate the possible completions.
|
|
pub function: Option<String>,
|
|
/// -W: The list of words
|
|
pub wordlist: Option<Vec<String>>,
|
|
/// -f: complete file names
|
|
pub files: bool,
|
|
/// -d: complete directory names
|
|
pub dirs: bool,
|
|
/// -c: complete command names
|
|
pub commands: bool,
|
|
/// -u: complete user names
|
|
pub users: bool,
|
|
/// -v: complete variable names
|
|
pub vars: bool,
|
|
/// -A signal: complete signal names
|
|
pub signals: bool,
|
|
/// -j: complete job pids or names
|
|
pub jobs: bool,
|
|
/// -a: complete aliases
|
|
pub aliases: bool,
|
|
|
|
pub flags: CompOptFlags,
|
|
/// The original command
|
|
pub source: String,
|
|
}
|
|
|
|
impl BashCompSpec {
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
pub fn with_func(mut self, func: String) -> Self {
|
|
self.function = Some(func);
|
|
self
|
|
}
|
|
pub fn with_wordlist(mut self, wordlist: Vec<String>) -> Self {
|
|
self.wordlist = Some(wordlist);
|
|
self
|
|
}
|
|
pub fn with_source(mut self, source: String) -> Self {
|
|
self.source = source;
|
|
self
|
|
}
|
|
pub fn files(mut self, enable: bool) -> Self {
|
|
self.files = enable;
|
|
self
|
|
}
|
|
pub fn dirs(mut self, enable: bool) -> Self {
|
|
self.dirs = enable;
|
|
self
|
|
}
|
|
pub fn commands(mut self, enable: bool) -> Self {
|
|
self.commands = enable;
|
|
self
|
|
}
|
|
pub fn users(mut self, enable: bool) -> Self {
|
|
self.users = enable;
|
|
self
|
|
}
|
|
pub fn vars(mut self, enable: bool) -> Self {
|
|
self.vars = enable;
|
|
self
|
|
}
|
|
pub fn signals(mut self, enable: bool) -> Self {
|
|
self.signals = enable;
|
|
self
|
|
}
|
|
pub fn jobs(mut self, enable: bool) -> Self {
|
|
self.jobs = enable;
|
|
self
|
|
}
|
|
pub fn aliases(mut self, enable: bool) -> Self {
|
|
self.aliases = enable;
|
|
self
|
|
}
|
|
pub fn from_comp_opts(opts: CompOpts) -> Self {
|
|
let CompOpts {
|
|
func,
|
|
wordlist,
|
|
action: _,
|
|
flags,
|
|
opt_flags,
|
|
} = opts;
|
|
Self {
|
|
function: func,
|
|
wordlist,
|
|
files: flags.contains(CompFlags::FILES),
|
|
dirs: flags.contains(CompFlags::DIRS),
|
|
commands: flags.contains(CompFlags::CMDS),
|
|
users: flags.contains(CompFlags::USERS),
|
|
vars: flags.contains(CompFlags::VARS),
|
|
jobs: flags.contains(CompFlags::JOBS),
|
|
aliases: flags.contains(CompFlags::ALIAS),
|
|
flags: opt_flags,
|
|
signals: false, // TODO: implement signal completion
|
|
source: String::new(),
|
|
}
|
|
}
|
|
pub fn exec_comp_func(&self, ctx: &CompContext) -> ShResult<Vec<String>> {
|
|
let mut vars_to_unset = HashSet::new();
|
|
for var in [
|
|
"COMP_WORDS",
|
|
"COMP_CWORD",
|
|
"COMP_LINE",
|
|
"COMP_POINT",
|
|
"COMPREPLY",
|
|
] {
|
|
vars_to_unset.insert(var.to_string());
|
|
}
|
|
let _guard = VarCtxGuard::new(vars_to_unset);
|
|
|
|
let CompContext {
|
|
words,
|
|
cword,
|
|
line,
|
|
cursor_pos,
|
|
} = ctx;
|
|
|
|
let raw_words = words.iter().clone().map(|tk| tk.to_string()).collect();
|
|
write_vars(|v| {
|
|
v.set_var(
|
|
"COMP_WORDS",
|
|
VarKind::arr_from_vec(raw_words),
|
|
VarFlags::NONE,
|
|
)
|
|
})?;
|
|
write_vars(|v| {
|
|
v.set_var(
|
|
"COMP_CWORD",
|
|
VarKind::Str(cword.to_string()),
|
|
VarFlags::NONE,
|
|
)
|
|
})?;
|
|
write_vars(|v| v.set_var("COMP_LINE", VarKind::Str(line.to_string()), VarFlags::NONE))?;
|
|
write_vars(|v| {
|
|
v.set_var(
|
|
"COMP_POINT",
|
|
VarKind::Str(cursor_pos.to_string()),
|
|
VarFlags::NONE,
|
|
)
|
|
})?;
|
|
|
|
let cmd_name = words.first().map(|s| s.to_string()).unwrap_or_default();
|
|
|
|
let cword_str = words.get(*cword).map(|s| s.to_string()).unwrap_or_default();
|
|
|
|
let pword_str = if *cword > 0 {
|
|
words
|
|
.get(cword - 1)
|
|
.map(|s| s.to_string())
|
|
.unwrap_or_default()
|
|
} else {
|
|
String::new()
|
|
};
|
|
|
|
let input = format!(
|
|
"{} {cmd_name} {cword_str} {pword_str}",
|
|
self.function.as_ref().unwrap()
|
|
);
|
|
exec_input(input, None, false)?;
|
|
|
|
Ok(read_vars(|v| v.get_arr_elems("COMPREPLY")).unwrap_or_default())
|
|
}
|
|
}
|
|
|
|
impl CompSpec for BashCompSpec {
|
|
fn complete(&self, ctx: &CompContext) -> ShResult<Vec<String>> {
|
|
let mut candidates = vec![];
|
|
let prefix = &ctx.words[ctx.cword];
|
|
|
|
let expanded = prefix.clone().expand()?.get_words().join(" ");
|
|
if self.files {
|
|
candidates.extend(complete_filename(&expanded));
|
|
}
|
|
if self.dirs {
|
|
candidates.extend(complete_dirs(&expanded));
|
|
}
|
|
if self.commands {
|
|
candidates.extend(complete_commands(&expanded));
|
|
}
|
|
if self.vars {
|
|
candidates.extend(complete_vars(&expanded));
|
|
}
|
|
if self.users {
|
|
candidates.extend(complete_users(&expanded));
|
|
}
|
|
if self.jobs {
|
|
candidates.extend(complete_jobs(&expanded));
|
|
}
|
|
if self.aliases {
|
|
candidates.extend(complete_aliases(&expanded));
|
|
}
|
|
if self.signals {
|
|
candidates.extend(complete_signals(&expanded));
|
|
}
|
|
if let Some(words) = &self.wordlist {
|
|
candidates.extend(words.iter().filter(|w| w.starts_with(&expanded)).cloned());
|
|
}
|
|
if self.function.is_some() {
|
|
candidates.extend(self.exec_comp_func(ctx)?);
|
|
}
|
|
candidates.sort_by_key(|c| c.len()); // sort by length to prioritize shorter completions, ties are then sorted alphabetically
|
|
|
|
Ok(candidates)
|
|
}
|
|
|
|
fn source(&self) -> &str {
|
|
&self.source
|
|
}
|
|
|
|
fn get_flags(&self) -> CompOptFlags {
|
|
self.flags
|
|
}
|
|
}
|
|
|
|
pub trait CompSpec: Debug + CloneCompSpec {
|
|
fn complete(&self, ctx: &CompContext) -> ShResult<Vec<String>>;
|
|
fn source(&self) -> &str;
|
|
fn get_flags(&self) -> CompOptFlags {
|
|
CompOptFlags::empty()
|
|
}
|
|
}
|
|
|
|
pub trait CloneCompSpec {
|
|
fn clone_box(&self) -> Box<dyn CompSpec>;
|
|
}
|
|
|
|
impl<T: CompSpec + Clone + 'static> CloneCompSpec for T {
|
|
fn clone_box(&self) -> Box<dyn CompSpec> {
|
|
Box::new(self.clone())
|
|
}
|
|
}
|
|
|
|
impl Clone for Box<dyn CompSpec> {
|
|
fn clone(&self) -> Self {
|
|
self.clone_box()
|
|
}
|
|
}
|
|
|
|
pub struct CompContext {
|
|
pub words: Vec<Tk>,
|
|
pub cword: usize,
|
|
pub line: String,
|
|
pub cursor_pos: usize,
|
|
}
|
|
|
|
impl CompContext {
|
|
pub fn cmd(&self) -> Option<&str> {
|
|
self.words.first().map(|s| s.as_str())
|
|
}
|
|
}
|
|
|
|
pub enum CompResult {
|
|
NoMatch,
|
|
Single { result: String },
|
|
Many { candidates: Vec<String> },
|
|
}
|
|
|
|
impl CompResult {
|
|
pub fn from_candidates(candidates: Vec<String>) -> Self {
|
|
if candidates.is_empty() {
|
|
Self::NoMatch
|
|
} else if candidates.len() == 1 {
|
|
Self::Single {
|
|
result: candidates[0].clone(),
|
|
}
|
|
} else {
|
|
Self::Many { candidates }
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Debug, Clone)]
|
|
pub struct Completer {
|
|
pub candidates: Vec<String>,
|
|
pub selected_idx: usize,
|
|
pub original_input: String,
|
|
pub token_span: (usize, usize),
|
|
pub active: bool,
|
|
pub dirs_only: bool,
|
|
pub add_space: bool,
|
|
}
|
|
|
|
impl Completer {
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
pub fn slice_line(line: &str, cursor_pos: usize) -> (&str, &str) {
|
|
let (before_cursor, after_cursor) = line.split_at(cursor_pos);
|
|
(before_cursor, after_cursor)
|
|
}
|
|
|
|
pub fn get_completion_context(&self, line: &str, cursor_pos: usize) -> (Vec<Marker>, usize) {
|
|
let annotated = annotate_input_recursive(line);
|
|
let mut ctx = vec![markers::NULL];
|
|
let mut last_priority = 0;
|
|
let mut ctx_start = 0;
|
|
let mut pos = 0;
|
|
|
|
for ch in annotated.chars() {
|
|
match ch {
|
|
_ if is_marker(ch) => match ch {
|
|
markers::COMMAND | markers::BUILTIN => {
|
|
if last_priority < 2 {
|
|
if last_priority > 0 {
|
|
ctx.pop();
|
|
}
|
|
ctx_start = pos;
|
|
last_priority = 2;
|
|
ctx.push(markers::COMMAND);
|
|
}
|
|
}
|
|
markers::VAR_SUB => {
|
|
if last_priority < 3 {
|
|
if last_priority > 0 {
|
|
ctx.pop();
|
|
}
|
|
ctx_start = pos;
|
|
last_priority = 3;
|
|
ctx.push(markers::VAR_SUB);
|
|
}
|
|
}
|
|
markers::ARG | markers::ASSIGNMENT => {
|
|
if last_priority < 1 {
|
|
ctx_start = pos;
|
|
ctx.push(markers::ARG);
|
|
}
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {
|
|
last_priority = 0; // reset priority on normal characters
|
|
pos += 1; // we hit a normal character, advance our position
|
|
if pos >= cursor_pos {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
(ctx, ctx_start)
|
|
}
|
|
|
|
pub fn reset(&mut self) {
|
|
self.candidates.clear();
|
|
self.selected_idx = 0;
|
|
self.original_input.clear();
|
|
self.token_span = (0, 0);
|
|
self.active = false;
|
|
}
|
|
|
|
pub fn complete(
|
|
&mut self,
|
|
line: String,
|
|
cursor_pos: usize,
|
|
direction: i32,
|
|
) -> ShResult<Option<String>> {
|
|
if self.active {
|
|
Ok(Some(self.cycle_completion(direction)))
|
|
} else {
|
|
self.start_completion(line, cursor_pos)
|
|
}
|
|
}
|
|
|
|
pub fn selected_candidate(&self) -> Option<String> {
|
|
self.candidates.get(self.selected_idx).cloned()
|
|
}
|
|
|
|
pub fn cycle_completion(&mut self, direction: i32) -> String {
|
|
if self.candidates.is_empty() {
|
|
return self.original_input.clone();
|
|
}
|
|
|
|
let len = self.candidates.len();
|
|
self.selected_idx = (self.selected_idx as i32 + direction).rem_euclid(len as i32) as usize;
|
|
|
|
self.get_completed_line()
|
|
}
|
|
|
|
pub fn add_spaces(&mut self) {
|
|
if self.add_space {
|
|
self.candidates = std::mem::take(&mut self.candidates)
|
|
.into_iter()
|
|
.map(|c| {
|
|
if !ends_with_unescaped(&c, "/") // directory
|
|
&& !ends_with_unescaped(&c, "=") // '='-type arg
|
|
&& !ends_with_unescaped(&c, " ")
|
|
{
|
|
// already has a space
|
|
format!("{} ", c)
|
|
} else {
|
|
c
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
pub fn start_completion(&mut self, line: String, cursor_pos: usize) -> ShResult<Option<String>> {
|
|
let result = self.get_candidates(line.clone(), cursor_pos)?;
|
|
match result {
|
|
CompResult::Many { candidates } => {
|
|
self.candidates = candidates.clone();
|
|
self.add_spaces();
|
|
self.selected_idx = 0;
|
|
self.original_input = line;
|
|
self.active = true;
|
|
|
|
Ok(Some(self.get_completed_line()))
|
|
}
|
|
CompResult::Single { result } => {
|
|
self.candidates = vec![result.clone()];
|
|
self.add_spaces();
|
|
self.selected_idx = 0;
|
|
self.original_input = line;
|
|
self.active = false;
|
|
|
|
Ok(Some(self.get_completed_line()))
|
|
}
|
|
CompResult::NoMatch => Ok(None),
|
|
}
|
|
}
|
|
|
|
pub fn get_completed_line(&self) -> String {
|
|
if self.candidates.is_empty() {
|
|
return self.original_input.clone();
|
|
}
|
|
|
|
let selected = &self.candidates[self.selected_idx];
|
|
let (start, end) = self.token_span;
|
|
format!(
|
|
"{}{}{}",
|
|
&self.original_input[..start],
|
|
selected,
|
|
&self.original_input[end..]
|
|
)
|
|
}
|
|
|
|
pub fn build_comp_ctx(&self, tks: &[Tk], line: &str, cursor_pos: usize) -> ShResult<CompContext> {
|
|
let mut ctx = CompContext {
|
|
words: vec![],
|
|
cword: 0,
|
|
line: line.to_string(),
|
|
cursor_pos,
|
|
};
|
|
|
|
let segments = tks
|
|
.iter()
|
|
.filter(|&tk| !matches!(tk.class, TkRule::SOI | TkRule::EOI))
|
|
.cloned()
|
|
.collect::<Vec<_>>()
|
|
.split_at_separators();
|
|
|
|
if segments.is_empty() {
|
|
return Ok(ctx);
|
|
}
|
|
|
|
let relevant_pos = segments
|
|
.iter()
|
|
.position(|tks| {
|
|
tks
|
|
.iter()
|
|
.next()
|
|
.is_some_and(|tk| tk.span.range().start > cursor_pos)
|
|
})
|
|
.map(|i| i.saturating_sub(1))
|
|
.unwrap_or(segments.len().saturating_sub(1));
|
|
|
|
let mut relevant = segments[relevant_pos].to_vec();
|
|
|
|
let cword = if let Some(pos) = relevant
|
|
.iter()
|
|
.position(|tk| cursor_pos >= tk.span.range().start && cursor_pos <= tk.span.range().end)
|
|
{
|
|
pos
|
|
} else {
|
|
let insert_pos = relevant
|
|
.iter()
|
|
.position(|tk| tk.span.range().start > cursor_pos)
|
|
.unwrap_or(relevant.len());
|
|
|
|
let mut new_tk = Tk::default();
|
|
if let Some(tk) = relevant.last() {
|
|
let mut span = tk.span.clone();
|
|
span.set_range(cursor_pos..cursor_pos);
|
|
new_tk.span = span;
|
|
}
|
|
relevant.insert(insert_pos, new_tk);
|
|
insert_pos
|
|
};
|
|
|
|
ctx.words = relevant;
|
|
ctx.cword = cword;
|
|
|
|
Ok(ctx)
|
|
}
|
|
|
|
pub fn try_comp_spec(&self, ctx: &CompContext) -> ShResult<CompSpecResult> {
|
|
let Some(cmd) = ctx.cmd() else {
|
|
return Ok(CompSpecResult::NoSpec);
|
|
};
|
|
|
|
let Some(spec) = read_meta(|m| m.get_comp_spec(cmd)) else {
|
|
return Ok(CompSpecResult::NoSpec);
|
|
};
|
|
|
|
let candidates = spec.complete(ctx)?;
|
|
if candidates.is_empty() {
|
|
Ok(CompSpecResult::NoMatch {
|
|
flags: spec.get_flags(),
|
|
})
|
|
} else {
|
|
Ok(CompSpecResult::Match {
|
|
result: CompResult::from_candidates(candidates),
|
|
flags: spec.get_flags(),
|
|
})
|
|
}
|
|
}
|
|
|
|
pub fn get_candidates(&mut self, line: String, cursor_pos: usize) -> ShResult<CompResult> {
|
|
let source = Arc::new(line.clone());
|
|
let tokens =
|
|
lex::LexStream::new(source, LexFlags::LEX_UNFINISHED).collect::<ShResult<Vec<Tk>>>()?;
|
|
|
|
let ctx = self.build_comp_ctx(&tokens, &line, cursor_pos)?;
|
|
|
|
// Set token_span from CompContext's current word
|
|
if let Some(cur) = ctx.words.get(ctx.cword) {
|
|
self.token_span = (cur.span.range().start, cur.span.range().end);
|
|
} else {
|
|
self.token_span = (cursor_pos, cursor_pos);
|
|
}
|
|
|
|
// Try programmable completion first
|
|
|
|
match self.try_comp_spec(&ctx)? {
|
|
CompSpecResult::NoMatch { flags } => {
|
|
if flags.contains(CompOptFlags::DIRNAMES) {
|
|
self.dirs_only = true;
|
|
} else if flags.contains(CompOptFlags::DEFAULT) {
|
|
/* fall through */
|
|
} else {
|
|
return Ok(CompResult::NoMatch);
|
|
}
|
|
|
|
if flags.contains(CompOptFlags::SPACE) {
|
|
self.add_space = true;
|
|
}
|
|
}
|
|
CompSpecResult::Match { result, flags } => {
|
|
if flags.contains(CompOptFlags::SPACE) {
|
|
self.add_space = true;
|
|
}
|
|
return Ok(result);
|
|
}
|
|
CompSpecResult::NoSpec => { /* carry on */ }
|
|
}
|
|
|
|
// Get the current token from CompContext
|
|
let Some(mut cur_token) = ctx.words.get(ctx.cword).cloned() else {
|
|
let candidates = complete_filename("./");
|
|
let end_pos = line.len();
|
|
self.token_span = (end_pos, end_pos);
|
|
return Ok(CompResult::from_candidates(candidates));
|
|
};
|
|
|
|
self.token_span = (cur_token.span.range().start, cur_token.span.range().end);
|
|
|
|
// Use marker-based context detection for sub-token awareness (e.g. VAR_SUB
|
|
// inside a token)
|
|
let (mut marker_ctx, token_start) = self.get_completion_context(&line, cursor_pos);
|
|
self.token_span.0 = token_start;
|
|
cur_token
|
|
.span
|
|
.set_range(self.token_span.0..self.token_span.1);
|
|
|
|
// If token contains '=', only complete after the '='
|
|
let token_str = cur_token.span.as_str();
|
|
if let Some(eq_pos) = token_str.rfind('=') {
|
|
self.token_span.0 = cur_token.span.range().start + eq_pos + 1;
|
|
cur_token
|
|
.span
|
|
.set_range(self.token_span.0..self.token_span.1);
|
|
}
|
|
|
|
let raw_tk = cur_token.as_str().to_string();
|
|
let expanded_tk = cur_token.expand()?;
|
|
let expanded_words = expanded_tk.get_words().into_iter().collect::<Vec<_>>();
|
|
let expanded = expanded_words.join("\\ ");
|
|
|
|
let last_marker = marker_ctx.last().copied();
|
|
let mut candidates = match marker_ctx.pop() {
|
|
_ if self.dirs_only => complete_dirs(&expanded),
|
|
Some(markers::COMMAND) => complete_commands(&expanded),
|
|
Some(markers::VAR_SUB) => {
|
|
let var_candidates = complete_vars(&raw_tk);
|
|
if var_candidates.is_empty() {
|
|
complete_filename(&expanded)
|
|
} else {
|
|
var_candidates
|
|
}
|
|
}
|
|
Some(markers::ARG) => complete_filename(&expanded),
|
|
_ => complete_filename(&expanded),
|
|
};
|
|
|
|
// Graft unexpanded prefix onto candidates to preserve things like
|
|
// $SOME_PATH/file.txt Skip for var completions — complete_vars already
|
|
// returns the full $VAR form
|
|
let is_var_completion = last_marker == Some(markers::VAR_SUB)
|
|
&& !candidates.is_empty()
|
|
&& candidates.iter().any(|c| c.starts_with('$'));
|
|
if !is_var_completion {
|
|
candidates = candidates
|
|
.into_iter()
|
|
.map(|c| match c.strip_prefix(&expanded) {
|
|
Some(suffix) => format!("{raw_tk}{suffix}"),
|
|
None => c,
|
|
})
|
|
.collect();
|
|
}
|
|
|
|
let limit = crate::state::read_shopts(|s| s.prompt.comp_limit);
|
|
candidates.truncate(limit);
|
|
|
|
Ok(CompResult::from_candidates(candidates))
|
|
}
|
|
}
|