Struct nu_plugin::EvaluatedCall

pub struct EvaluatedCall {
    pub head: Span,
    pub positional: Vec<Value>,
    pub named: Vec<(Spanned<String>, Option<Value>)>,
}

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

Fields

head: Span

Span of the command invocation

positional: Vec<Value>

Values of positional arguments

named: Vec<(Spanned<String>, Option<Value>)>

Names and values of named arguments

Implementations

impl EvaluatedCall

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<EvaluatedCall, ShellError>

Try to create an EvaluatedCall from a command Call.

pub fn has_flag(&self, flag_name: &str) -> Result<bool, ShellError>

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:

assert!(call.has_flag("foo").unwrap());

Invoked as my_command --bar:

assert!(!call.has_flag("foo").unwrap());

Invoked as my_command --foo=true:

assert!(call.has_flag("foo").unwrap());

Invoked as my_command --foo=false:

assert!(!call.has_flag("foo").unwrap());

Invoked with wrong type as my_command --foo=1:

assert!(call.has_flag("foo").is_err());

pub fn get_flag_value(&self, flag_name: &str) -> Option<Value>

Returns the Value of an optional named argument

Examples

Invoked as my_command --foo 123:

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:

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 nth(&self, pos: usize) -> Option<Value>

Returns the Value of a given (zero indexed) positional argument, if present

Examples: Invoked as my_command a b c:

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 get_flag<T>(&self, name: &str) -> Result<Option<T>, ShellError>

where T: FromValue,

Returns the value of a named argument interpreted as type T

Examples

Invoked as my_command --foo 123:

let foo = call.get_flag::<i64>("foo");
assert_eq!(foo.unwrap(), Some(123));

Invoked as my_command --bar 123:

let foo = call.get_flag::<i64>("foo");
assert_eq!(foo.unwrap(), None);

Invoked as my_command --foo abc:

let foo = call.get_flag::<i64>("foo");
assert!(foo.is_err());

pub fn rest<T>(&self, starting_pos: usize) -> Result<Vec<T>, ShellError>

where T: FromValue,

Retrieve the Nth and all following positional arguments as type T

Example

Invoked as my_command zero one two three:

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 opt<T>(&self, pos: usize) -> Result<Option<T>, ShellError>

where T: FromValue,

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 req<T>(&self, pos: usize) -> Result<T, ShellError>

where T: FromValue,

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.

Trait Implementations

impl Clone for EvaluatedCall

fn clone(&self) -> EvaluatedCall

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EvaluatedCall

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EvaluatedCall

fn deserialize<__D>( __deserializer: __D ) -> Result<EvaluatedCall, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EvaluatedCall

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.