forked from extern/nushell
3fae77209a
This reverts commit 0cfd5fbece.
The original PR messed up syntax higlighting of aliases and causes
panics of completion in the presence of alias.
<!--
if this PR closes one or more issues, you can automatically link the PR
with
them by using one of the [*linking
keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword),
e.g.
- this PR should close #xxxx
- fixes #xxxx
you can also mention related issues, PRs or discussions!
-->
# Description
<!--
Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.
Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.
-->
# User-Facing Changes
<!-- List of all changes that impact the user experience here. This
helps us keep track of breaking changes. -->
# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.
Make sure you've run and fixed any issues with these commands:
- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to
check that you're using the standard code style
- `cargo test --workspace` to check that all tests pass (on Windows make
sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- `cargo run -- -c "use toolkit.nu; toolkit test stdlib"` to run the
tests for the standard library
> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->
# After Submitting
<!-- If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->
413 lines
14 KiB
Rust
413 lines
14 KiB
Rust
use nu_protocol::{
|
|
ast::{Call, Expression},
|
|
engine::{EngineState, Stack},
|
|
FromValue, ShellError, Span, Spanned, Value,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// A representation of the plugin's invocation command including command line args
|
|
///
|
|
/// The `EvaluatedCall` contains information about the way a `Plugin` was invoked representing the
|
|
/// [`Span`] corresponding to the invocation as well as the arguments it was invoked with. It is
|
|
/// one of the items passed to `PluginCommand::run()`, along with the plugin reference, the engine
|
|
/// interface, and a [`Value`] that represents the input.
|
|
///
|
|
/// The evaluated call is used with the Plugins because the plugin doesn't have
|
|
/// access to the Stack and the EngineState the way a built in command might. For that
|
|
/// reason, before encoding the message to the plugin all the arguments to the original
|
|
/// call (which are expressions) are evaluated and passed to Values
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct EvaluatedCall {
|
|
/// Span of the command invocation
|
|
pub head: Span,
|
|
/// Values of positional arguments
|
|
pub positional: Vec<Value>,
|
|
/// Names and values of named arguments
|
|
pub named: Vec<(Spanned<String>, Option<Value>)>,
|
|
}
|
|
|
|
impl EvaluatedCall {
|
|
/// Try to create an [`EvaluatedCall`] from a command `Call`.
|
|
pub fn try_from_call(
|
|
call: &Call,
|
|
engine_state: &EngineState,
|
|
stack: &mut Stack,
|
|
eval_expression_fn: fn(&EngineState, &mut Stack, &Expression) -> Result<Value, ShellError>,
|
|
) -> Result<Self, ShellError> {
|
|
let positional =
|
|
call.rest_iter_flattened(0, |expr| eval_expression_fn(engine_state, stack, expr))?;
|
|
|
|
let mut named = Vec::with_capacity(call.named_len());
|
|
for (string, _, expr) in call.named_iter() {
|
|
let value = match expr {
|
|
None => None,
|
|
Some(expr) => Some(eval_expression_fn(engine_state, stack, expr)?),
|
|
};
|
|
|
|
named.push((string.clone(), value))
|
|
}
|
|
|
|
Ok(Self {
|
|
head: call.head,
|
|
positional,
|
|
named,
|
|
})
|
|
}
|
|
|
|
/// Check if a flag (named parameter that does not take a value) is set
|
|
/// Returns Ok(true) if flag is set or passed true value
|
|
/// Returns Ok(false) if flag is not set or passed false value
|
|
/// Returns Err if passed value is not a boolean
|
|
///
|
|
/// # Examples
|
|
/// Invoked as `my_command --foo`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # None
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --bar`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "bar".to_owned(), span: null_span},
|
|
/// # None
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(!call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --foo=true`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::bool(true, Span::unknown()))
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --foo=false`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::bool(false, Span::unknown()))
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(!call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked with wrong type as `my_command --foo=1`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::int(1, Span::unknown()))
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(call.has_flag("foo").is_err());
|
|
/// ```
|
|
pub fn has_flag(&self, flag_name: &str) -> Result<bool, ShellError> {
|
|
for name in &self.named {
|
|
if flag_name == name.0.item {
|
|
return match &name.1 {
|
|
Some(Value::Bool { val, .. }) => Ok(*val),
|
|
None => Ok(true),
|
|
Some(result) => Err(ShellError::CantConvert {
|
|
to_type: "bool".into(),
|
|
from_type: result.get_type().to_string(),
|
|
span: result.span(),
|
|
help: Some("".into()),
|
|
}),
|
|
};
|
|
}
|
|
}
|
|
|
|
Ok(false)
|
|
}
|
|
|
|
/// Returns the [`Value`] of an optional named argument
|
|
///
|
|
/// # Examples
|
|
/// Invoked as `my_command --foo 123`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::int(123, null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let opt_foo = match call.get_flag_value("foo") {
|
|
/// Some(Value::Int { val, .. }) => Some(val),
|
|
/// None => None,
|
|
/// _ => panic!(),
|
|
/// };
|
|
/// assert_eq!(opt_foo, Some(123));
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![],
|
|
/// # };
|
|
/// let opt_foo = match call.get_flag_value("foo") {
|
|
/// Some(Value::Int { val, .. }) => Some(val),
|
|
/// None => None,
|
|
/// _ => panic!(),
|
|
/// };
|
|
/// assert_eq!(opt_foo, None);
|
|
/// ```
|
|
pub fn get_flag_value(&self, flag_name: &str) -> Option<Value> {
|
|
for name in &self.named {
|
|
if flag_name == name.0.item {
|
|
return name.1.clone();
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
/// Returns the [`Value`] of a given (zero indexed) positional argument, if present
|
|
///
|
|
/// Examples:
|
|
/// Invoked as `my_command a b c`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: vec![
|
|
/// # Value::string("a".to_owned(), null_span),
|
|
/// # Value::string("b".to_owned(), null_span),
|
|
/// # Value::string("c".to_owned(), null_span),
|
|
/// # ],
|
|
/// # named: vec![],
|
|
/// # };
|
|
/// let arg = match call.nth(1) {
|
|
/// Some(Value::String { val, .. }) => val,
|
|
/// _ => panic!(),
|
|
/// };
|
|
/// assert_eq!(arg, "b".to_owned());
|
|
///
|
|
/// let arg = call.nth(7);
|
|
/// assert!(arg.is_none());
|
|
/// ```
|
|
pub fn nth(&self, pos: usize) -> Option<Value> {
|
|
self.positional.get(pos).cloned()
|
|
}
|
|
|
|
/// Returns the value of a named argument interpreted as type `T`
|
|
///
|
|
/// # Examples
|
|
/// Invoked as `my_command --foo 123`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::int(123, null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let foo = call.get_flag::<i64>("foo");
|
|
/// assert_eq!(foo.unwrap(), Some(123));
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --bar 123`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "bar".to_owned(), span: null_span},
|
|
/// # Some(Value::int(123, null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let foo = call.get_flag::<i64>("foo");
|
|
/// assert_eq!(foo.unwrap(), None);
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --foo abc`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::string("abc".to_owned(), null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let foo = call.get_flag::<i64>("foo");
|
|
/// assert!(foo.is_err());
|
|
/// ```
|
|
pub fn get_flag<T: FromValue>(&self, name: &str) -> Result<Option<T>, ShellError> {
|
|
if let Some(value) = self.get_flag_value(name) {
|
|
FromValue::from_value(value).map(Some)
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
/// Retrieve the Nth and all following positional arguments as type `T`
|
|
///
|
|
/// # Example
|
|
/// Invoked as `my_command zero one two three`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: vec![
|
|
/// # Value::string("zero".to_owned(), null_span),
|
|
/// # Value::string("one".to_owned(), null_span),
|
|
/// # Value::string("two".to_owned(), null_span),
|
|
/// # Value::string("three".to_owned(), null_span),
|
|
/// # ],
|
|
/// # named: Vec::new(),
|
|
/// # };
|
|
/// let args = call.rest::<String>(0);
|
|
/// assert_eq!(args.unwrap(), vec!["zero", "one", "two", "three"]);
|
|
///
|
|
/// let args = call.rest::<String>(2);
|
|
/// assert_eq!(args.unwrap(), vec!["two", "three"]);
|
|
/// ```
|
|
pub fn rest<T: FromValue>(&self, starting_pos: usize) -> Result<Vec<T>, ShellError> {
|
|
self.positional
|
|
.iter()
|
|
.skip(starting_pos)
|
|
.map(|value| FromValue::from_value(value.clone()))
|
|
.collect()
|
|
}
|
|
|
|
/// Retrieve the value of an optional positional argument interpreted as type `T`
|
|
///
|
|
/// Returns the value of a (zero indexed) positional argument of type `T`.
|
|
/// Alternatively returns [`None`] if the positional argument does not exist
|
|
/// or an error that can be passed back to the shell on error.
|
|
pub fn opt<T: FromValue>(&self, pos: usize) -> Result<Option<T>, ShellError> {
|
|
if let Some(value) = self.nth(pos) {
|
|
FromValue::from_value(value).map(Some)
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
/// Retrieve the value of a mandatory positional argument as type `T`
|
|
///
|
|
/// Expect a positional argument of type `T` and return its value or, if the
|
|
/// argument does not exist or is of the wrong type, return an error that can
|
|
/// be passed back to the shell.
|
|
pub fn req<T: FromValue>(&self, pos: usize) -> Result<T, ShellError> {
|
|
if let Some(value) = self.nth(pos) {
|
|
FromValue::from_value(value)
|
|
} else if self.positional.is_empty() {
|
|
Err(ShellError::AccessEmptyContent { span: self.head })
|
|
} else {
|
|
Err(ShellError::AccessBeyondEnd {
|
|
max_idx: self.positional.len() - 1,
|
|
span: self.head,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use nu_protocol::{Span, Spanned, Value};
|
|
|
|
#[test]
|
|
fn call_to_value() {
|
|
let call = EvaluatedCall {
|
|
head: Span::new(0, 10),
|
|
positional: vec![
|
|
Value::float(1.0, Span::new(0, 10)),
|
|
Value::string("something", Span::new(0, 10)),
|
|
],
|
|
named: vec![
|
|
(
|
|
Spanned {
|
|
item: "name".to_string(),
|
|
span: Span::new(0, 10),
|
|
},
|
|
Some(Value::float(1.0, Span::new(0, 10))),
|
|
),
|
|
(
|
|
Spanned {
|
|
item: "flag".to_string(),
|
|
span: Span::new(0, 10),
|
|
},
|
|
None,
|
|
),
|
|
],
|
|
};
|
|
|
|
let name: Option<f64> = call.get_flag("name").unwrap();
|
|
assert_eq!(name, Some(1.0));
|
|
|
|
assert!(call.has_flag("flag").unwrap());
|
|
|
|
let required: f64 = call.req(0).unwrap();
|
|
assert!((required - 1.0).abs() < f64::EPSILON);
|
|
|
|
let optional: Option<String> = call.opt(1).unwrap();
|
|
assert_eq!(optional, Some("something".to_string()));
|
|
|
|
let rest: Vec<String> = call.rest(1).unwrap();
|
|
assert_eq!(rest, vec!["something".to_string()]);
|
|
}
|
|
}
|