forked from extern/nushell
6cdfee3573
# Description As part of the refactor to split spans off of Value, this moves to using helper functions to create values, and using `.span()` instead of matching span out of Value directly. Hoping to get a few more helping hands to finish this, as there are a lot of commands to update :) # 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 std testing; testing run-tests --path crates/nu-std"` 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. --> --------- Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <windsoilder@outlook.com>
93 lines
3.0 KiB
Rust
93 lines
3.0 KiB
Rust
use nu_plugin::{EvaluatedCall, LabeledError};
|
|
use nu_protocol::{Record, Value};
|
|
pub struct Example;
|
|
|
|
impl Example {
|
|
fn print_values(
|
|
&self,
|
|
index: u32,
|
|
call: &EvaluatedCall,
|
|
input: &Value,
|
|
) -> Result<(), LabeledError> {
|
|
// Note. When debugging your plugin, you may want to print something to the console
|
|
// Use the eprintln macro to print your messages. Trying to print to stdout will
|
|
// cause a decoding error for your message
|
|
eprintln!("Calling test {index} signature");
|
|
eprintln!("value received {input:?}");
|
|
|
|
// To extract the arguments from the Call object you can use the functions req, has_flag,
|
|
// opt, rest, and get_flag
|
|
//
|
|
// Note that plugin calls only accept simple arguments, this means that you can
|
|
// pass to the plug in Int and String. This should be improved when the plugin has
|
|
// the ability to call back to NuShell to extract more information
|
|
// Keep this in mind when designing your plugin signatures
|
|
let a: i64 = call.req(0)?;
|
|
let b: String = call.req(1)?;
|
|
let flag = call.has_flag("flag");
|
|
let opt: Option<i64> = call.opt(2)?;
|
|
let named: Option<String> = call.get_flag("named")?;
|
|
let rest: Vec<String> = call.rest(3)?;
|
|
|
|
eprintln!("Required values");
|
|
eprintln!("a: {a:}");
|
|
eprintln!("b: {b:}");
|
|
eprintln!("flag: {flag:}");
|
|
eprintln!("rest: {rest:?}");
|
|
|
|
if let Some(v) = opt {
|
|
eprintln!("Found optional value opt: {v:}")
|
|
} else {
|
|
eprintln!("No optional value found")
|
|
}
|
|
|
|
if let Some(v) = named {
|
|
eprintln!("Named value: {v:?}")
|
|
} else {
|
|
eprintln!("No named value found")
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn test1(&self, call: &EvaluatedCall, input: &Value) -> Result<Value, LabeledError> {
|
|
self.print_values(1, call, input)?;
|
|
|
|
Ok(Value::nothing(call.head))
|
|
}
|
|
|
|
pub fn test2(&self, call: &EvaluatedCall, input: &Value) -> Result<Value, LabeledError> {
|
|
self.print_values(2, call, input)?;
|
|
|
|
let cols = vec!["one".to_string(), "two".to_string(), "three".to_string()];
|
|
|
|
let vals = (0..10i64)
|
|
.map(|i| {
|
|
let vals = (0..3)
|
|
.map(|v| Value::int(v * i, call.head))
|
|
.collect::<Vec<Value>>();
|
|
|
|
Value::record(
|
|
Record {
|
|
cols: cols.clone(),
|
|
vals,
|
|
},
|
|
call.head,
|
|
)
|
|
})
|
|
.collect::<Vec<Value>>();
|
|
|
|
Ok(Value::list(vals, call.head))
|
|
}
|
|
|
|
pub fn test3(&self, call: &EvaluatedCall, input: &Value) -> Result<Value, LabeledError> {
|
|
self.print_values(3, call, input)?;
|
|
|
|
Err(LabeledError {
|
|
label: "ERROR from plugin".into(),
|
|
msg: "error message pointing to call head span".into(),
|
|
span: Some(call.head),
|
|
})
|
|
}
|
|
}
|