mirror of
https://github.com/nushell/nushell.git
synced 2025-04-12 23:38:20 +02:00
672 lines
30 KiB
Rust
672 lines
30 KiB
Rust
use nu_engine::eval_call;
|
|
use nu_parser::{flatten_expression, parse, trim_quotes, FlatShape};
|
|
use nu_protocol::{
|
|
ast::{Call, Expr},
|
|
engine::{EngineState, Stack, StateWorkingSet},
|
|
levenshtein_distance, PipelineData, Span, Value, CONFIG_VARIABLE_ID,
|
|
};
|
|
use reedline::{Completer, Suggestion};
|
|
|
|
const SEP: char = std::path::MAIN_SEPARATOR;
|
|
|
|
pub struct CompletionOptions {
|
|
case_sensitive: bool,
|
|
positional: bool,
|
|
sort: bool,
|
|
}
|
|
|
|
impl Default for CompletionOptions {
|
|
fn default() -> Self {
|
|
Self {
|
|
case_sensitive: true,
|
|
positional: true,
|
|
sort: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct NuCompleter {
|
|
engine_state: EngineState,
|
|
stack: Stack,
|
|
config: Option<Value>,
|
|
}
|
|
|
|
impl NuCompleter {
|
|
pub fn new(engine_state: EngineState, stack: Stack, config: Option<Value>) -> Self {
|
|
Self {
|
|
engine_state,
|
|
stack,
|
|
config,
|
|
}
|
|
}
|
|
|
|
fn external_command_completion(&self, prefix: &str) -> Vec<String> {
|
|
let mut executables = vec![];
|
|
|
|
let paths = self.engine_state.env_vars.get("PATH");
|
|
|
|
if let Some(paths) = paths {
|
|
if let Ok(paths) = paths.as_list() {
|
|
for path in paths {
|
|
let path = path.as_string().unwrap_or_default();
|
|
|
|
if let Ok(mut contents) = std::fs::read_dir(path) {
|
|
while let Some(Ok(item)) = contents.next() {
|
|
if !executables.contains(
|
|
&item
|
|
.path()
|
|
.file_name()
|
|
.map(|x| x.to_string_lossy().to_string())
|
|
.unwrap_or_default(),
|
|
) && matches!(
|
|
item.path()
|
|
.file_name()
|
|
.map(|x| x.to_string_lossy().starts_with(prefix)),
|
|
Some(true)
|
|
) && is_executable::is_executable(&item.path())
|
|
{
|
|
if let Ok(name) = item.file_name().into_string() {
|
|
executables.push(name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
executables
|
|
}
|
|
|
|
fn complete_variables(
|
|
&self,
|
|
working_set: &StateWorkingSet,
|
|
prefix: &[u8],
|
|
span: Span,
|
|
offset: usize,
|
|
) -> Vec<Suggestion> {
|
|
let mut output = vec![];
|
|
|
|
let builtins = ["$nu", "$in", "$config", "$env", "$nothing"];
|
|
|
|
for builtin in builtins {
|
|
if builtin.as_bytes().starts_with(prefix) {
|
|
output.push(Suggestion {
|
|
value: builtin.to_string(),
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: span.start - offset,
|
|
end: span.end - offset,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
for scope in &working_set.delta.scope {
|
|
for v in &scope.vars {
|
|
if v.0.starts_with(prefix) {
|
|
output.push(Suggestion {
|
|
value: String::from_utf8_lossy(v.0).to_string(),
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: span.start - offset,
|
|
end: span.end - offset,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
}
|
|
for scope in &self.engine_state.scope {
|
|
for v in &scope.vars {
|
|
if v.0.starts_with(prefix) {
|
|
output.push(Suggestion {
|
|
value: String::from_utf8_lossy(v.0).to_string(),
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: span.start - offset,
|
|
end: span.end - offset,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
output.dedup();
|
|
|
|
output
|
|
}
|
|
|
|
fn complete_commands(
|
|
&self,
|
|
working_set: &StateWorkingSet,
|
|
span: Span,
|
|
offset: usize,
|
|
find_externals: bool,
|
|
) -> Vec<Suggestion> {
|
|
let prefix = working_set.get_span_contents(span);
|
|
|
|
let results = working_set
|
|
.find_commands_by_prefix(prefix)
|
|
.into_iter()
|
|
.map(move |x| Suggestion {
|
|
value: String::from_utf8_lossy(&x).to_string(),
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: span.start - offset,
|
|
end: span.end - offset,
|
|
},
|
|
});
|
|
|
|
let results_aliases =
|
|
working_set
|
|
.find_aliases_by_prefix(prefix)
|
|
.into_iter()
|
|
.map(move |x| Suggestion {
|
|
value: String::from_utf8_lossy(&x).to_string(),
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: span.start - offset,
|
|
end: span.end - offset,
|
|
},
|
|
});
|
|
|
|
let mut results = results.chain(results_aliases).collect::<Vec<_>>();
|
|
|
|
let prefix = working_set.get_span_contents(span);
|
|
let prefix = String::from_utf8_lossy(prefix).to_string();
|
|
let mut results = if find_externals {
|
|
let results_external =
|
|
self.external_command_completion(&prefix)
|
|
.into_iter()
|
|
.map(move |x| Suggestion {
|
|
value: x,
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: span.start - offset,
|
|
end: span.end - offset,
|
|
},
|
|
});
|
|
|
|
for external in results_external {
|
|
if results.contains(&external) {
|
|
results.push(Suggestion {
|
|
value: format!("^{}", external.value),
|
|
description: None,
|
|
span: external.span,
|
|
})
|
|
} else {
|
|
results.push(external)
|
|
}
|
|
}
|
|
|
|
results
|
|
} else {
|
|
results
|
|
};
|
|
|
|
results.sort_by(|a, b| {
|
|
let a_distance = levenshtein_distance(&prefix, &a.value);
|
|
let b_distance = levenshtein_distance(&prefix, &b.value);
|
|
a_distance.cmp(&b_distance)
|
|
});
|
|
|
|
results
|
|
}
|
|
|
|
fn completion_helper(&self, line: &str, pos: usize) -> Vec<Suggestion> {
|
|
let mut working_set = StateWorkingSet::new(&self.engine_state);
|
|
let offset = working_set.next_span_start();
|
|
let mut line = line.to_string();
|
|
line.insert(pos, 'a');
|
|
let pos = offset + pos;
|
|
let (output, _err) = parse(
|
|
&mut working_set,
|
|
Some("completer"),
|
|
line.as_bytes(),
|
|
false,
|
|
&[],
|
|
);
|
|
|
|
for pipeline in output.pipelines.into_iter() {
|
|
for expr in pipeline.expressions {
|
|
let flattened: Vec<_> = flatten_expression(&working_set, &expr);
|
|
|
|
for (flat_idx, flat) in flattened.iter().enumerate() {
|
|
if pos >= flat.0.start && pos < flat.0.end {
|
|
let new_span = Span {
|
|
start: flat.0.start,
|
|
end: flat.0.end - 1,
|
|
};
|
|
|
|
let mut prefix = working_set.get_span_contents(flat.0).to_vec();
|
|
prefix.remove(pos - flat.0.start);
|
|
|
|
if prefix.starts_with(b"$") {
|
|
let mut output =
|
|
self.complete_variables(&working_set, &prefix, new_span, offset);
|
|
output.sort_by(|a, b| a.value.cmp(&b.value));
|
|
return output;
|
|
}
|
|
if prefix.starts_with(b"-") {
|
|
// this might be a flag, let's see
|
|
if let Expr::Call(call) = &expr.expr {
|
|
let decl = working_set.get_decl(call.decl_id);
|
|
let sig = decl.signature();
|
|
|
|
let mut output = vec![];
|
|
|
|
for named in &sig.named {
|
|
if let Some(short) = named.short {
|
|
let mut named = vec![0; short.len_utf8()];
|
|
short.encode_utf8(&mut named);
|
|
named.insert(0, b'-');
|
|
if named.starts_with(&prefix) {
|
|
output.push(Suggestion {
|
|
value: String::from_utf8_lossy(&named).to_string(),
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: new_span.start - offset,
|
|
end: new_span.end - offset,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
if named.long.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
let mut named = named.long.as_bytes().to_vec();
|
|
named.insert(0, b'-');
|
|
named.insert(0, b'-');
|
|
if named.starts_with(&prefix) {
|
|
output.push(Suggestion {
|
|
value: String::from_utf8_lossy(&named).to_string(),
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: new_span.start - offset,
|
|
end: new_span.end - offset,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
output.sort_by(|a, b| a.value.cmp(&b.value));
|
|
return output;
|
|
}
|
|
}
|
|
|
|
match &flat.1 {
|
|
FlatShape::Custom(decl_id) => {
|
|
let mut stack = self.stack.clone();
|
|
|
|
// Set up our initial config to start from
|
|
if let Some(conf) = &self.config {
|
|
stack.vars.insert(CONFIG_VARIABLE_ID, conf.clone());
|
|
} else {
|
|
stack.vars.insert(
|
|
CONFIG_VARIABLE_ID,
|
|
Value::Record {
|
|
cols: vec![],
|
|
vals: vec![],
|
|
span: Span { start: 0, end: 0 },
|
|
},
|
|
);
|
|
}
|
|
|
|
let result = eval_call(
|
|
&self.engine_state,
|
|
&mut stack,
|
|
&Call {
|
|
decl_id: *decl_id,
|
|
head: new_span,
|
|
positional: vec![],
|
|
named: vec![],
|
|
redirect_stdout: true,
|
|
redirect_stderr: true,
|
|
},
|
|
PipelineData::new(new_span),
|
|
);
|
|
|
|
fn map_completions<'a>(
|
|
list: impl Iterator<Item = &'a Value>,
|
|
new_span: Span,
|
|
offset: usize,
|
|
) -> Vec<Suggestion> {
|
|
list.filter_map(move |x| {
|
|
let s = x.as_string();
|
|
|
|
match s {
|
|
Ok(s) => Some(Suggestion {
|
|
value: s,
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: new_span.start - offset,
|
|
end: new_span.end - offset,
|
|
},
|
|
}),
|
|
Err(_) => None,
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
let (completions, options) = match result {
|
|
Ok(pd) => {
|
|
let value = pd.into_value(new_span);
|
|
match &value {
|
|
Value::Record { .. } => {
|
|
let completions = value
|
|
.get_data_by_key("completions")
|
|
.and_then(|val| {
|
|
val.as_list().ok().map(|it| {
|
|
map_completions(
|
|
it.iter(),
|
|
new_span,
|
|
offset,
|
|
)
|
|
})
|
|
})
|
|
.unwrap_or_default();
|
|
let options = value.get_data_by_key("options");
|
|
|
|
let options =
|
|
if let Some(Value::Record { .. }) = &options {
|
|
let options = options.unwrap_or_default();
|
|
CompletionOptions {
|
|
case_sensitive: options
|
|
.get_data_by_key("case_sensitive")
|
|
.and_then(|val| val.as_bool().ok())
|
|
.unwrap_or(true),
|
|
positional: options
|
|
.get_data_by_key("positional")
|
|
.and_then(|val| val.as_bool().ok())
|
|
.unwrap_or(true),
|
|
sort: options
|
|
.get_data_by_key("sort")
|
|
.and_then(|val| val.as_bool().ok())
|
|
.unwrap_or(true),
|
|
}
|
|
} else {
|
|
CompletionOptions::default()
|
|
};
|
|
|
|
(completions, options)
|
|
}
|
|
Value::List { vals, .. } => {
|
|
let completions =
|
|
map_completions(vals.iter(), new_span, offset);
|
|
(completions, CompletionOptions::default())
|
|
}
|
|
_ => (vec![], CompletionOptions::default()),
|
|
}
|
|
}
|
|
_ => (vec![], CompletionOptions::default()),
|
|
};
|
|
|
|
let mut completions: Vec<Suggestion> = completions
|
|
.into_iter()
|
|
.filter(|it| {
|
|
// Minimise clones for new functionality
|
|
match (options.case_sensitive, options.positional) {
|
|
(true, true) => {
|
|
it.value.as_bytes().starts_with(&prefix)
|
|
}
|
|
(true, false) => it.value.contains(
|
|
std::str::from_utf8(&prefix).unwrap_or(""),
|
|
),
|
|
(false, positional) => {
|
|
let value = it.value.to_lowercase();
|
|
let prefix = std::str::from_utf8(&prefix)
|
|
.unwrap_or("")
|
|
.to_lowercase();
|
|
if positional {
|
|
value.starts_with(&prefix)
|
|
} else {
|
|
value.contains(&prefix)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
if options.sort {
|
|
completions.sort_by(|a, b| a.value.cmp(&b.value));
|
|
}
|
|
|
|
return completions;
|
|
}
|
|
FlatShape::Filepath | FlatShape::GlobPattern => {
|
|
let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
|
|
match d.as_string() {
|
|
Ok(s) => s,
|
|
Err(_) => "".to_string(),
|
|
}
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
let prefix = String::from_utf8_lossy(&prefix).to_string();
|
|
let mut output: Vec<_> =
|
|
file_path_completion(new_span, &prefix, &cwd)
|
|
.into_iter()
|
|
.map(move |x| Suggestion {
|
|
value: x.1,
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: x.0.start - offset,
|
|
end: x.0.end - offset,
|
|
},
|
|
})
|
|
.collect();
|
|
// output.sort_by(|a, b| a.value.cmp(&b.value));
|
|
output.sort_by(|a, b| {
|
|
let a_distance = levenshtein_distance(&prefix, &a.value);
|
|
let b_distance = levenshtein_distance(&prefix, &b.value);
|
|
a_distance.cmp(&b_distance)
|
|
});
|
|
|
|
return output;
|
|
}
|
|
flat_shape => {
|
|
let last = flattened
|
|
.iter()
|
|
.rev()
|
|
.skip_while(|x| x.0.end > pos)
|
|
.take_while(|x| {
|
|
matches!(
|
|
x.1,
|
|
FlatShape::InternalCall
|
|
| FlatShape::External
|
|
| FlatShape::ExternalArg
|
|
| FlatShape::Literal
|
|
| FlatShape::String
|
|
)
|
|
})
|
|
.last();
|
|
|
|
// The last item here would be the earliest shape that could possible by part of this subcommand
|
|
let subcommands = if let Some(last) = last {
|
|
self.complete_commands(
|
|
&working_set,
|
|
Span {
|
|
start: last.0.start,
|
|
end: pos,
|
|
},
|
|
offset,
|
|
false,
|
|
)
|
|
} else {
|
|
vec![]
|
|
};
|
|
|
|
if !subcommands.is_empty() {
|
|
return subcommands;
|
|
}
|
|
|
|
let commands =
|
|
if matches!(flat_shape, nu_parser::FlatShape::External)
|
|
|| matches!(flat_shape, nu_parser::FlatShape::InternalCall)
|
|
|| ((new_span.end - new_span.start) == 0)
|
|
{
|
|
// we're in a gap or at a command
|
|
self.complete_commands(&working_set, new_span, offset, true)
|
|
} else {
|
|
vec![]
|
|
};
|
|
|
|
let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
|
|
match d.as_string() {
|
|
Ok(s) => s,
|
|
Err(_) => "".to_string(),
|
|
}
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
|
|
let preceding_byte = if new_span.start > offset {
|
|
working_set
|
|
.get_span_contents(Span {
|
|
start: new_span.start - 1,
|
|
end: new_span.start,
|
|
})
|
|
.to_vec()
|
|
} else {
|
|
vec![]
|
|
};
|
|
// let prefix = working_set.get_span_contents(flat.0);
|
|
let prefix = String::from_utf8_lossy(&prefix).to_string();
|
|
let mut output = file_path_completion(new_span, &prefix, &cwd)
|
|
.into_iter()
|
|
.map(move |x| {
|
|
if flat_idx == 0 {
|
|
// We're in the command position
|
|
if x.1.starts_with('"')
|
|
&& !matches!(preceding_byte.get(0), Some(b'^'))
|
|
{
|
|
let trimmed = trim_quotes(x.1.as_bytes());
|
|
let trimmed =
|
|
String::from_utf8_lossy(trimmed).to_string();
|
|
let expanded =
|
|
nu_path::canonicalize_with(trimmed, &cwd);
|
|
|
|
if let Ok(expanded) = expanded {
|
|
if is_executable::is_executable(expanded) {
|
|
(x.0, format!("^{}", x.1))
|
|
} else {
|
|
(x.0, x.1)
|
|
}
|
|
} else {
|
|
(x.0, x.1)
|
|
}
|
|
} else {
|
|
(x.0, x.1)
|
|
}
|
|
} else {
|
|
(x.0, x.1)
|
|
}
|
|
})
|
|
.map(move |x| Suggestion {
|
|
value: x.1,
|
|
description: None,
|
|
span: reedline::Span {
|
|
start: x.0.start - offset,
|
|
end: x.0.end - offset,
|
|
},
|
|
})
|
|
.chain(subcommands.into_iter())
|
|
.chain(commands.into_iter())
|
|
.collect::<Vec<_>>();
|
|
//output.dedup_by(|a, b| a.1 == b.1);
|
|
//output.sort_by(|a, b| a.value.cmp(&b.value));
|
|
output.sort_by(|a, b| {
|
|
let a_distance = levenshtein_distance(&prefix, &a.value);
|
|
let b_distance = levenshtein_distance(&prefix, &b.value);
|
|
a_distance.cmp(&b_distance)
|
|
});
|
|
|
|
return output;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
vec![]
|
|
}
|
|
}
|
|
|
|
impl Completer for NuCompleter {
|
|
fn complete(&self, line: &str, pos: usize) -> Vec<Suggestion> {
|
|
self.completion_helper(line, pos)
|
|
}
|
|
}
|
|
|
|
fn file_path_completion(
|
|
span: nu_protocol::Span,
|
|
partial: &str,
|
|
cwd: &str,
|
|
) -> Vec<(nu_protocol::Span, String)> {
|
|
use std::path::{is_separator, Path};
|
|
|
|
let partial = partial.replace('\'', "");
|
|
|
|
let (base_dir_name, partial) = {
|
|
// If partial is only a word we want to search in the current dir
|
|
let (base, rest) = partial.rsplit_once(is_separator).unwrap_or((".", &partial));
|
|
// On windows, this standardizes paths to use \
|
|
let mut base = base.replace(is_separator, &SEP.to_string());
|
|
|
|
// rsplit_once removes the separator
|
|
base.push(SEP);
|
|
(base, rest)
|
|
};
|
|
|
|
let base_dir = nu_path::expand_path_with(&base_dir_name, cwd);
|
|
// This check is here as base_dir.read_dir() with base_dir == "" will open the current dir
|
|
// which we don't want in this case (if we did, base_dir would already be ".")
|
|
if base_dir == Path::new("") {
|
|
return Vec::new();
|
|
}
|
|
|
|
let mut results = if let Ok(result) = base_dir.read_dir() {
|
|
result
|
|
.filter_map(|entry| {
|
|
entry.ok().and_then(|entry| {
|
|
let mut file_name = entry.file_name().to_string_lossy().into_owned();
|
|
if matches(partial, &file_name) {
|
|
let mut path = format!("{}{}", base_dir_name, file_name);
|
|
if entry.path().is_dir() {
|
|
path.push(SEP);
|
|
file_name.push(SEP);
|
|
}
|
|
|
|
if path.contains(' ') {
|
|
path = format!("\'{}\'", path);
|
|
}
|
|
|
|
Some((span, path))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
})
|
|
.collect()
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
|
|
results.sort_by(|a, b| {
|
|
let a_distance = levenshtein_distance(partial, &a.1);
|
|
let b_distance = levenshtein_distance(partial, &b.1);
|
|
a_distance.cmp(&b_distance)
|
|
});
|
|
|
|
results
|
|
}
|
|
|
|
fn matches(partial: &str, from: &str) -> bool {
|
|
from.to_ascii_lowercase()
|
|
.starts_with(&partial.to_ascii_lowercase())
|
|
}
|