1630 lines
43 KiB
Rust
1630 lines
43 KiB
Rust
use std::{
|
|
collections::HashSet,
|
|
fmt::{Debug, Write},
|
|
path::PathBuf,
|
|
sync::Arc,
|
|
};
|
|
|
|
use nix::sys::signal::Signal;
|
|
|
|
use crate::{
|
|
builtin::complete::{CompFlags, CompOptFlags, CompOpts},
|
|
libsh::{error::ShResult, guards::var_ctx_guard, sys::TTY_FILENO, utils::TkVecUtils},
|
|
parse::{
|
|
execute::exec_input,
|
|
lex::{self, LexFlags, Tk, TkRule, ends_with_unescaped},
|
|
},
|
|
readline::{
|
|
Marker, annotate_input_recursive,
|
|
keys::{KeyCode as C, KeyEvent as K, ModKeys as M},
|
|
linebuf::{ClampedUsize, LineBuf},
|
|
markers::{self, is_marker},
|
|
term::{LineWriter, TermWriter, calc_str_width, get_win_size},
|
|
vimode::{ViInsert, ViMode},
|
|
},
|
|
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 = var_ctx_guard(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, Some("comp_function".into()))?;
|
|
|
|
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 = candidates
|
|
.into_iter()
|
|
.map(|c| {
|
|
let stripped = c.strip_prefix(&expanded).unwrap_or_default();
|
|
format!("{prefix}{stripped}")
|
|
})
|
|
.collect();
|
|
|
|
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 }
|
|
}
|
|
}
|
|
}
|
|
|
|
pub enum CompResponse {
|
|
Passthrough, // key falls through
|
|
Accept(String), // user accepted completion
|
|
Dismiss, // user canceled completion
|
|
Consumed, // key was handled, but completion remains active
|
|
}
|
|
|
|
pub enum SelectorResponse {
|
|
Accept(String),
|
|
Dismiss,
|
|
Consumed,
|
|
}
|
|
|
|
pub trait Completer {
|
|
fn complete(
|
|
&mut self,
|
|
line: String,
|
|
cursor_pos: usize,
|
|
direction: i32,
|
|
) -> ShResult<Option<String>>;
|
|
fn reset(&mut self);
|
|
fn reset_stay_active(&mut self);
|
|
fn is_active(&self) -> bool;
|
|
fn all_candidates(&self) -> Vec<String> { vec![] }
|
|
fn selected_candidate(&self) -> Option<String>;
|
|
fn token_span(&self) -> (usize, usize);
|
|
fn original_input(&self) -> &str;
|
|
fn token(&self) -> &str {
|
|
let orig = self.original_input();
|
|
let (s,e) = self.token_span();
|
|
orig.get(s..e).unwrap_or(orig)
|
|
}
|
|
fn draw(&mut self, writer: &mut TermWriter) -> ShResult<()>;
|
|
fn clear(&mut self, _writer: &mut TermWriter) -> ShResult<()> {
|
|
Ok(())
|
|
}
|
|
fn set_prompt_line_context(&mut self, _line_width: u16, _cursor_col: u16) {}
|
|
fn handle_key(&mut self, key: K) -> ShResult<CompResponse>;
|
|
fn get_completed_line(&self, candidate: &str) -> String;
|
|
}
|
|
|
|
#[derive(Default, Debug, Clone)]
|
|
pub struct ScoredCandidate {
|
|
pub content: String,
|
|
pub score: Option<i32>,
|
|
}
|
|
|
|
impl ScoredCandidate {
|
|
const BONUS_BOUNDARY: i32 = 10;
|
|
const BONUS_CONSECUTIVE: i32 = 8;
|
|
const BONUS_FIRST_CHAR: i32 = 5;
|
|
const PENALTY_GAP_START: i32 = 3;
|
|
const PENALTY_GAP_EXTEND: i32 = 1;
|
|
|
|
pub fn new(content: String) -> Self {
|
|
Self {
|
|
content,
|
|
score: None,
|
|
}
|
|
}
|
|
fn is_word_bound(prev: char, curr: char) -> bool {
|
|
match prev {
|
|
'/' | '_' | '-' | '.' | ' ' => true,
|
|
c if c.is_lowercase() && curr.is_uppercase() => true, // camelCase boundary
|
|
_ => false,
|
|
}
|
|
}
|
|
pub fn fuzzy_score(&mut self, other: &str) -> i32 {
|
|
if other.is_empty() {
|
|
self.score = Some(0);
|
|
return 0;
|
|
}
|
|
|
|
let query_chars: Vec<char> = other.chars().collect();
|
|
let content_chars: Vec<char> = self.content.chars().collect();
|
|
let mut indices = vec![];
|
|
let mut qi = 0;
|
|
for (ci, c_ch) in self.content.chars().enumerate() {
|
|
if qi < query_chars.len() && c_ch.eq_ignore_ascii_case(&query_chars[qi]) {
|
|
indices.push(ci);
|
|
qi += 1;
|
|
}
|
|
}
|
|
|
|
if indices.len() != query_chars.len() {
|
|
self.score = Some(i32::MIN);
|
|
return i32::MIN;
|
|
}
|
|
|
|
let mut score: i32 = 0;
|
|
|
|
for (i, &idx) in indices.iter().enumerate() {
|
|
if idx == 0 {
|
|
score += Self::BONUS_FIRST_CHAR;
|
|
}
|
|
|
|
if idx == 0 || Self::is_word_bound(content_chars[idx - 1], content_chars[idx]) {
|
|
score += Self::BONUS_BOUNDARY;
|
|
}
|
|
|
|
if i > 0 {
|
|
let gap = idx - indices[i - 1] - 1;
|
|
if gap == 0 {
|
|
score += Self::BONUS_CONSECUTIVE;
|
|
} else {
|
|
score -= Self::PENALTY_GAP_START + (gap as i32 - 1) * Self::PENALTY_GAP_EXTEND;
|
|
}
|
|
}
|
|
}
|
|
|
|
self.score = Some(score);
|
|
score
|
|
}
|
|
}
|
|
|
|
impl From<String> for ScoredCandidate {
|
|
fn from(content: String) -> Self {
|
|
Self {
|
|
content,
|
|
score: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct FuzzyLayout {
|
|
rows: u16,
|
|
cols: u16,
|
|
cursor_col: u16,
|
|
/// Width of the prompt line above the `\n` that starts the fuzzy window.
|
|
/// If PSR was drawn, this is `t_cols`; otherwise the content width.
|
|
preceding_line_width: u16,
|
|
/// Cursor column on the prompt line before the fuzzy window was drawn.
|
|
preceding_cursor_col: u16,
|
|
}
|
|
|
|
#[derive(Default, Debug, Clone)]
|
|
pub struct QueryEditor {
|
|
mode: ViInsert,
|
|
scroll_offset: usize,
|
|
available_width: usize,
|
|
linebuf: LineBuf,
|
|
}
|
|
|
|
impl QueryEditor {
|
|
pub fn clear(&mut self) {
|
|
self.linebuf = LineBuf::new();
|
|
self.mode = ViInsert::default();
|
|
self.scroll_offset = 0;
|
|
}
|
|
pub fn set_available_width(&mut self, width: usize) {
|
|
self.available_width = width;
|
|
}
|
|
pub fn update_scroll_offset(&mut self) {
|
|
self.linebuf.update_graphemes();
|
|
let cursor_pos = self.linebuf.cursor.get();
|
|
if cursor_pos < self.scroll_offset + 1 {
|
|
self.scroll_offset = self.linebuf.cursor.ret_sub(1);
|
|
}
|
|
if cursor_pos >= self.scroll_offset + self.available_width.saturating_sub(1) {
|
|
self.scroll_offset = self
|
|
.linebuf
|
|
.cursor
|
|
.ret_sub(self.available_width.saturating_sub(1));
|
|
}
|
|
let max_offset = self
|
|
.linebuf
|
|
.grapheme_indices()
|
|
.len()
|
|
.saturating_sub(self.available_width);
|
|
self.scroll_offset = self.scroll_offset.min(max_offset);
|
|
}
|
|
pub fn get_window(&mut self) -> String {
|
|
self.linebuf.update_graphemes();
|
|
let buf_len = self.linebuf.grapheme_indices().len();
|
|
if buf_len <= self.available_width {
|
|
return self.linebuf.as_str().to_string();
|
|
}
|
|
let start = self
|
|
.scroll_offset
|
|
.min(buf_len.saturating_sub(self.available_width));
|
|
let end = (start + self.available_width).min(buf_len);
|
|
self.linebuf.slice(start..end).unwrap_or("").to_string()
|
|
}
|
|
pub fn handle_key(&mut self, key: K) -> ShResult<()> {
|
|
let Some(cmd) = self.mode.handle_key(key) else {
|
|
return Ok(());
|
|
};
|
|
self.linebuf.exec_cmd(cmd)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct FuzzySelector {
|
|
query: QueryEditor,
|
|
filtered: Vec<ScoredCandidate>,
|
|
candidates: Vec<String>,
|
|
cursor: ClampedUsize,
|
|
number_candidates: bool,
|
|
old_layout: Option<FuzzyLayout>,
|
|
max_height: usize,
|
|
scroll_offset: usize,
|
|
active: bool,
|
|
prompt_line_width: u16,
|
|
prompt_cursor_col: u16,
|
|
title: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct FuzzyCompleter {
|
|
completer: SimpleCompleter,
|
|
pub selector: FuzzySelector,
|
|
}
|
|
|
|
impl FuzzySelector {
|
|
const BOT_LEFT: &str = "\x1b[90m╰\x1b[0m";
|
|
const BOT_RIGHT: &str = "\x1b[90m╯\x1b[0m";
|
|
const TOP_LEFT: &str = "\x1b[90m╭\x1b[0m";
|
|
const TOP_RIGHT: &str = "\x1b[90m╮\x1b[0m";
|
|
const HOR_LINE: &str = "\x1b[90m─\x1b[0m";
|
|
const VERT_LINE: &str = "\x1b[90m│\x1b[0m";
|
|
const SELECTOR_GRAY: &str = "\x1b[90m▌\x1b[0m";
|
|
const SELECTOR_HL: &str = "\x1b[38;2;200;0;120m▌\x1b[1;39;48;5;237m";
|
|
const PROMPT_ARROW: &str = "\x1b[1;36m>\x1b[0m";
|
|
const TREE_LEFT: &str = "\x1b[90m├\x1b[0m";
|
|
const TREE_RIGHT: &str = "\x1b[90m┤\x1b[0m";
|
|
|
|
pub fn new(title: impl Into<String>) -> Self {
|
|
Self {
|
|
max_height: 8,
|
|
query: QueryEditor::default(),
|
|
filtered: vec![],
|
|
candidates: vec![],
|
|
cursor: ClampedUsize::new(0, 0, true),
|
|
number_candidates: false,
|
|
old_layout: None,
|
|
scroll_offset: 0,
|
|
active: false,
|
|
prompt_line_width: 0,
|
|
prompt_cursor_col: 0,
|
|
title: title.into(),
|
|
}
|
|
}
|
|
|
|
pub fn number_candidates(self, enable: bool) -> Self {
|
|
Self {
|
|
number_candidates: enable,
|
|
..self
|
|
}
|
|
}
|
|
|
|
pub fn candidates(&self) -> &[String] {
|
|
&self.candidates
|
|
}
|
|
|
|
pub fn filtered(&self) -> &[ScoredCandidate] {
|
|
&self.filtered
|
|
}
|
|
|
|
pub fn filtered_len(&self) -> usize {
|
|
self.filtered.len()
|
|
}
|
|
|
|
pub fn candidates_len(&self) -> usize {
|
|
self.candidates.len()
|
|
}
|
|
|
|
pub fn activate(&mut self, candidates: Vec<String>) {
|
|
self.active = true;
|
|
self.candidates = candidates;
|
|
self.score_candidates();
|
|
}
|
|
|
|
pub fn set_query(&mut self, query: String) {
|
|
self.query.linebuf = LineBuf::new().with_initial(&query, query.len());
|
|
self.query.update_scroll_offset();
|
|
self.score_candidates();
|
|
}
|
|
|
|
pub fn reset(&mut self) {
|
|
self.query.clear();
|
|
self.filtered.clear();
|
|
self.candidates.clear();
|
|
self.cursor = ClampedUsize::new(0, 0, true);
|
|
self.old_layout = None;
|
|
self.scroll_offset = 0;
|
|
self.active = false;
|
|
}
|
|
|
|
pub fn reset_stay_active(&mut self) {
|
|
if self.active {
|
|
self.query.clear();
|
|
self.score_candidates();
|
|
}
|
|
}
|
|
|
|
pub fn is_active(&self) -> bool {
|
|
self.active
|
|
}
|
|
|
|
pub fn selected_candidate(&self) -> Option<String> {
|
|
self
|
|
.filtered
|
|
.get(self.cursor.get())
|
|
.map(|c| c.content.clone())
|
|
}
|
|
|
|
pub fn set_prompt_line_context(&mut self, line_width: u16, cursor_col: u16) {
|
|
self.prompt_line_width = line_width;
|
|
self.prompt_cursor_col = cursor_col;
|
|
}
|
|
|
|
fn candidate_height(&self, idx: usize) -> usize {
|
|
self
|
|
.filtered
|
|
.get(idx)
|
|
.map(|c| c.content.trim_end().lines().count().max(1))
|
|
.unwrap_or(1)
|
|
}
|
|
|
|
fn get_window(&mut self) -> &[ScoredCandidate] {
|
|
self.update_scroll_offset();
|
|
|
|
let mut lines = 0;
|
|
let mut end = self.scroll_offset;
|
|
while end < self.filtered.len() {
|
|
if lines >= self.max_height {
|
|
break;
|
|
}
|
|
lines += self.candidate_height(end);
|
|
end += 1;
|
|
}
|
|
|
|
&self.filtered[self.scroll_offset..end]
|
|
}
|
|
|
|
pub fn update_scroll_offset(&mut self) {
|
|
let cursor = self.cursor.get();
|
|
|
|
// Scroll up: cursor above window
|
|
if cursor < self.scroll_offset {
|
|
self.scroll_offset = cursor;
|
|
return;
|
|
}
|
|
|
|
// Scroll down: ensure all candidates from scroll_offset through cursor
|
|
// fit within max_height rendered lines
|
|
loop {
|
|
let mut lines = 0;
|
|
let last = cursor.min(self.filtered.len().saturating_sub(1));
|
|
for idx in self.scroll_offset..=last {
|
|
lines += self.candidate_height(idx);
|
|
}
|
|
if lines <= self.max_height || self.scroll_offset >= cursor {
|
|
break;
|
|
}
|
|
self.scroll_offset += 1;
|
|
}
|
|
}
|
|
|
|
pub fn score_candidates(&mut self) {
|
|
let mut scored: Vec<_> = self
|
|
.candidates
|
|
.clone()
|
|
.into_iter()
|
|
.filter_map(|c| {
|
|
let mut sc = ScoredCandidate::new(c);
|
|
let score = sc.fuzzy_score(self.query.linebuf.as_str());
|
|
if score > i32::MIN { Some(sc) } else { None }
|
|
})
|
|
.collect();
|
|
scored.sort_by_key(|sc| sc.score.unwrap_or(i32::MIN));
|
|
scored.reverse();
|
|
self.cursor.set_max(scored.len());
|
|
self.filtered = scored;
|
|
}
|
|
|
|
pub fn handle_key(&mut self, key: K) -> ShResult<SelectorResponse> {
|
|
match key {
|
|
K(C::Char('D'), M::CTRL) | K(C::Esc, M::NONE) => {
|
|
self.active = false;
|
|
self.filtered.clear();
|
|
Ok(SelectorResponse::Dismiss)
|
|
}
|
|
K(C::Enter, M::NONE) => {
|
|
self.active = false;
|
|
if let Some(selected) = self
|
|
.filtered
|
|
.get(self.cursor.get())
|
|
.map(|c| c.content.clone())
|
|
{
|
|
Ok(SelectorResponse::Accept(selected))
|
|
} else {
|
|
Ok(SelectorResponse::Dismiss)
|
|
}
|
|
}
|
|
K(C::Tab, M::SHIFT) | K(C::Up, M::NONE) => {
|
|
self.cursor.wrap_sub(1);
|
|
self.update_scroll_offset();
|
|
Ok(SelectorResponse::Consumed)
|
|
}
|
|
K(C::Tab, M::NONE) | K(C::Down, M::NONE) => {
|
|
self.cursor.wrap_add(1);
|
|
self.update_scroll_offset();
|
|
Ok(SelectorResponse::Consumed)
|
|
}
|
|
_ => {
|
|
self.query.handle_key(key)?;
|
|
self.score_candidates();
|
|
Ok(SelectorResponse::Consumed)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn draw(&mut self, writer: &mut TermWriter) -> ShResult<()> {
|
|
if !self.active {
|
|
return Ok(());
|
|
}
|
|
let (cols, _) = get_win_size(*TTY_FILENO);
|
|
|
|
let mut buf = String::new();
|
|
let cursor_pos = self.cursor.get();
|
|
let offset = self.scroll_offset;
|
|
self
|
|
.query
|
|
.set_available_width(cols.saturating_sub(6) as usize);
|
|
self.query.update_scroll_offset();
|
|
let query = self.query.get_window();
|
|
let num_filtered = format!("\x1b[33m{}\x1b[0m", self.filtered.len());
|
|
let num_candidates = format!("\x1b[33m{}\x1b[0m", self.candidates.len());
|
|
let title = self.title.clone();
|
|
let title_width = title.len() as u16;
|
|
let number_candidates = self.number_candidates;
|
|
let min_pad = self
|
|
.candidates
|
|
.len()
|
|
.to_string()
|
|
.len()
|
|
.saturating_add(1)
|
|
.max(6);
|
|
let max_height = self.max_height;
|
|
let visible = self.get_window();
|
|
let mut rows: u16 = 0;
|
|
let top_bar = format!(
|
|
"\n{}{} \x1b[1m{}\x1b[0m {}{}",
|
|
Self::TOP_LEFT,
|
|
Self::HOR_LINE,
|
|
title,
|
|
Self::HOR_LINE.repeat(cols.saturating_sub(title_width + 5) as usize),
|
|
Self::TOP_RIGHT
|
|
);
|
|
buf.push_str(&top_bar);
|
|
rows += 1;
|
|
for _ in 0..rows {}
|
|
|
|
let prompt = format!("{} {} {}", Self::VERT_LINE, Self::PROMPT_ARROW, &query);
|
|
let cols_used = calc_str_width(&prompt);
|
|
let right_pad = " ".repeat(cols.saturating_sub(cols_used + 1) as usize);
|
|
let prompt_line_final = format!("{}{}{}", prompt, right_pad, Self::VERT_LINE);
|
|
buf.push_str(&prompt_line_final);
|
|
rows += 1;
|
|
|
|
let sep_line_left = format!(
|
|
"{}{}{}/{}",
|
|
Self::TREE_LEFT,
|
|
Self::HOR_LINE.repeat(2),
|
|
&num_filtered,
|
|
&num_candidates
|
|
);
|
|
let cols_used = calc_str_width(&sep_line_left);
|
|
let right_pad = Self::HOR_LINE.repeat(cols.saturating_sub(cols_used + 1) as usize);
|
|
let sep_line_final = format!("{}{}{}", sep_line_left, right_pad, Self::TREE_RIGHT);
|
|
buf.push_str(&sep_line_final);
|
|
rows += 1;
|
|
|
|
let mut lines_drawn = 0;
|
|
for (i, candidate) in visible.iter().enumerate() {
|
|
if lines_drawn >= max_height {
|
|
break;
|
|
}
|
|
let selector = if i + offset == cursor_pos {
|
|
Self::SELECTOR_HL
|
|
} else {
|
|
Self::SELECTOR_GRAY
|
|
};
|
|
let mut drew_number = false;
|
|
for line in candidate.content.trim_end().lines() {
|
|
if lines_drawn >= max_height {
|
|
break;
|
|
}
|
|
let mut line = line.trim_end().replace('\t', " ");
|
|
let col_lim = if number_candidates {
|
|
cols.saturating_sub(3 + min_pad as u16)
|
|
} else {
|
|
cols.saturating_sub(3)
|
|
};
|
|
if calc_str_width(&line) > col_lim {
|
|
line.truncate(col_lim.saturating_sub(6) as usize);
|
|
line.push_str("...");
|
|
}
|
|
let left = if number_candidates {
|
|
if !drew_number {
|
|
let this_num = i + offset + 1;
|
|
let right_pad = " ".repeat(min_pad.saturating_sub(this_num.to_string().len()));
|
|
format!(
|
|
"{} {}\x1b[33m{}\x1b[39m{right_pad}{}\x1b[0m",
|
|
Self::VERT_LINE,
|
|
&selector,
|
|
i + offset + 1,
|
|
&line
|
|
)
|
|
} else {
|
|
let right_pad = " ".repeat(min_pad);
|
|
format!(
|
|
"{} {}{}{}\x1b[0m",
|
|
Self::VERT_LINE,
|
|
&selector,
|
|
right_pad,
|
|
&line
|
|
)
|
|
}
|
|
} else {
|
|
format!("{} {}{}\x1b[0m", Self::VERT_LINE, &selector, &line)
|
|
};
|
|
let cols_used = calc_str_width(&left);
|
|
let right_pad = " ".repeat(cols.saturating_sub(cols_used + 1) as usize);
|
|
let hl_cand_line = format!("{}{}{}", left, right_pad, Self::VERT_LINE);
|
|
buf.push_str(&hl_cand_line);
|
|
rows += 1;
|
|
drew_number = true;
|
|
lines_drawn += 1;
|
|
}
|
|
}
|
|
|
|
let bot_bar = format!(
|
|
"{}{}{}",
|
|
Self::BOT_LEFT,
|
|
Self::HOR_LINE
|
|
.to_string()
|
|
.repeat(cols.saturating_sub(2) as usize),
|
|
Self::BOT_RIGHT
|
|
);
|
|
buf.push_str(&bot_bar);
|
|
rows += 1;
|
|
|
|
let lines_below_prompt = rows.saturating_sub(2);
|
|
let cursor_in_window = self
|
|
.query
|
|
.linebuf
|
|
.cursor
|
|
.get()
|
|
.saturating_sub(self.query.scroll_offset);
|
|
let cursor_col = (cursor_in_window + 4) as u16;
|
|
write!(buf, "\x1b[{}A\r\x1b[{}C", lines_below_prompt, cursor_col).unwrap();
|
|
|
|
let new_layout = FuzzyLayout {
|
|
rows,
|
|
cols,
|
|
cursor_col,
|
|
preceding_line_width: self.prompt_line_width,
|
|
preceding_cursor_col: self.prompt_cursor_col,
|
|
};
|
|
writer.flush_write(&buf)?;
|
|
self.old_layout = Some(new_layout);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn clear(&mut self, writer: &mut TermWriter) -> ShResult<()> {
|
|
if let Some(layout) = self.old_layout.take() {
|
|
let (new_cols, _) = get_win_size(*TTY_FILENO);
|
|
let total_cells = layout.rows as u32 * layout.cols as u32;
|
|
let physical_rows = if new_cols > 0 {
|
|
total_cells.div_ceil(new_cols as u32) as u16
|
|
} else {
|
|
layout.rows
|
|
};
|
|
let cursor_offset = layout.cols as u32 + layout.cursor_col as u32;
|
|
let cursor_phys_row = if new_cols > 0 {
|
|
(cursor_offset / new_cols as u32) as u16
|
|
} else {
|
|
1
|
|
};
|
|
let lines_below = physical_rows.saturating_sub(cursor_phys_row + 1);
|
|
|
|
let gap_extra = if new_cols > 0 && layout.preceding_line_width > new_cols {
|
|
let wrap_rows = (layout.preceding_line_width as u32).div_ceil(new_cols as u32) as u16;
|
|
let cursor_wrap_row = layout.preceding_cursor_col / new_cols;
|
|
wrap_rows.saturating_sub(cursor_wrap_row + 1)
|
|
} else {
|
|
0
|
|
};
|
|
|
|
let mut buf = String::new();
|
|
if lines_below > 0 {
|
|
write!(buf, "\x1b[{}B", lines_below).unwrap();
|
|
}
|
|
for _ in 0..physical_rows {
|
|
buf.push_str("\x1b[2K\x1b[A");
|
|
}
|
|
buf.push_str("\x1b[2K");
|
|
for _ in 0..gap_extra {
|
|
buf.push_str("\x1b[A\x1b[2K");
|
|
}
|
|
writer.flush_write(&buf)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Default for FuzzyCompleter {
|
|
fn default() -> Self {
|
|
Self {
|
|
completer: SimpleCompleter::default(),
|
|
selector: FuzzySelector::new("Complete"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Completer for FuzzyCompleter {
|
|
fn all_candidates(&self) -> Vec<String> {
|
|
self.selector.candidates.clone()
|
|
}
|
|
fn set_prompt_line_context(&mut self, line_width: u16, cursor_col: u16) {
|
|
self
|
|
.selector
|
|
.set_prompt_line_context(line_width, cursor_col);
|
|
}
|
|
fn reset_stay_active(&mut self) {
|
|
self.selector.reset_stay_active();
|
|
}
|
|
fn get_completed_line(&self, _candidate: &str) -> String {
|
|
log::debug!("Getting completed line for candidate: {}", _candidate);
|
|
|
|
let selected = self.selector.selected_candidate().unwrap_or_default();
|
|
log::debug!("Selected candidate: {}", selected);
|
|
let (start, end) = self.completer.token_span;
|
|
log::debug!("Token span: ({}, {})", start, end);
|
|
let ret = format!(
|
|
"{}{}{}",
|
|
&self.completer.original_input[..start],
|
|
selected,
|
|
&self.completer.original_input[end..]
|
|
);
|
|
log::debug!("Completed line: {}", ret);
|
|
ret
|
|
}
|
|
fn complete(
|
|
&mut self,
|
|
line: String,
|
|
cursor_pos: usize,
|
|
direction: i32,
|
|
) -> ShResult<Option<String>> {
|
|
self.completer.complete(line, cursor_pos, direction)?;
|
|
let candidates: Vec<_> = self.completer.candidates.clone();
|
|
if candidates.is_empty() {
|
|
self.completer.reset();
|
|
self.selector.active = false;
|
|
return Ok(None);
|
|
} else if candidates.len() == 1 {
|
|
self.selector.filtered = candidates.into_iter().map(ScoredCandidate::from).collect();
|
|
let selected = self.selector.filtered[0].content.clone();
|
|
let completed = self.get_completed_line(&selected);
|
|
self.selector.active = false;
|
|
return Ok(Some(completed));
|
|
}
|
|
self.selector.activate(candidates);
|
|
Ok(None)
|
|
}
|
|
|
|
fn handle_key(&mut self, key: K) -> ShResult<CompResponse> {
|
|
match self.selector.handle_key(key)? {
|
|
SelectorResponse::Accept(s) => Ok(CompResponse::Accept(s)),
|
|
SelectorResponse::Dismiss => Ok(CompResponse::Dismiss),
|
|
SelectorResponse::Consumed => Ok(CompResponse::Consumed),
|
|
}
|
|
}
|
|
fn clear(&mut self, writer: &mut TermWriter) -> ShResult<()> {
|
|
self.selector.clear(writer)
|
|
}
|
|
fn draw(&mut self, writer: &mut TermWriter) -> ShResult<()> {
|
|
self.selector.draw(writer)
|
|
}
|
|
fn reset(&mut self) {
|
|
self.completer.reset();
|
|
self.selector.reset();
|
|
}
|
|
fn token_span(&self) -> (usize, usize) {
|
|
self.completer.token_span()
|
|
}
|
|
fn is_active(&self) -> bool {
|
|
self.selector.is_active()
|
|
}
|
|
fn selected_candidate(&self) -> Option<String> {
|
|
self.selector.selected_candidate()
|
|
}
|
|
fn original_input(&self) -> &str {
|
|
&self.completer.original_input
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Debug, Clone)]
|
|
pub struct SimpleCompleter {
|
|
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 for SimpleCompleter {
|
|
fn all_candidates(&self) -> Vec<String> {
|
|
self.candidates.clone()
|
|
}
|
|
fn reset_stay_active(&mut self) {
|
|
let active = self.is_active();
|
|
self.reset();
|
|
self.active = active;
|
|
}
|
|
fn get_completed_line(&self, _candidate: &str) -> String {
|
|
self.get_completed_line()
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
|
|
fn reset(&mut self) {
|
|
*self = Self::default();
|
|
}
|
|
|
|
fn is_active(&self) -> bool {
|
|
self.active
|
|
}
|
|
|
|
fn selected_candidate(&self) -> Option<String> {
|
|
self.candidates.get(self.selected_idx).cloned()
|
|
}
|
|
|
|
fn token_span(&self) -> (usize, usize) {
|
|
self.token_span
|
|
}
|
|
|
|
fn draw(&mut self, _writer: &mut TermWriter) -> ShResult<()> {
|
|
Ok(())
|
|
}
|
|
|
|
fn original_input(&self) -> &str {
|
|
&self.original_input
|
|
}
|
|
|
|
fn handle_key(&mut self, _key: K) -> ShResult<CompResponse> {
|
|
Ok(CompResponse::Passthrough)
|
|
}
|
|
}
|
|
|
|
impl SimpleCompleter {
|
|
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_subtoken_completion(&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);
|
|
}
|
|
}
|
|
markers::RESET => {
|
|
if ctx.len() > 1 {
|
|
ctx.pop();
|
|
last_priority = 0;
|
|
}
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {
|
|
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 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);
|
|
}
|
|
|
|
// Use marker-based context detection for sub-token awareness (e.g. VAR_SUB
|
|
// inside a token). Run this before comp specs so variable completions take
|
|
// priority over programmable completion.
|
|
let (mut marker_ctx, token_start) = self.get_subtoken_completion(&line, cursor_pos);
|
|
|
|
if marker_ctx.last() == Some(&markers::VAR_SUB)
|
|
&& let Some(cur) = ctx.words.get(ctx.cword)
|
|
{
|
|
self.token_span.0 = token_start;
|
|
let mut span = cur.span.clone();
|
|
span.set_range(token_start..self.token_span.1);
|
|
let raw_tk = span.as_str();
|
|
let candidates = complete_vars(raw_tk);
|
|
if !candidates.is_empty() {
|
|
return Ok(CompResult::from_candidates(candidates));
|
|
}
|
|
}
|
|
|
|
// Try programmable completion
|
|
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);
|
|
|
|
if token_start >= self.token_span.0 && token_start <= self.token_span.1 {
|
|
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) => {
|
|
// Variable completion already tried above and had no matches,
|
|
// fall through to filename completion
|
|
complete_filename(&expanded)
|
|
}
|
|
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))
|
|
}
|
|
}
|