mirror of
https://github.com/nushell/nushell.git
synced 2025-05-20 06:33:21 +00:00
c747ec75c9
# Description
When implementing a `Command`, one must also import all the types
present in the function signatures for `Command`. This makes it so that
we often import the same set of types in each command implementation
file. E.g., something like this:
```rust
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EngineState, Stack};
use nu_protocol::{
record, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
ShellError, Signature, Span, Type, Value,
};
```
This PR adds the `nu_engine::command_prelude` module which contains the
necessary and commonly used types to implement a `Command`:
```rust
// command_prelude.rs
pub use crate::CallExt;
pub use nu_protocol::{
ast::{Call, CellPath},
engine::{Command, EngineState, Stack},
record, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, IntoSpanned,
PipelineData, Record, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
};
```
This should reduce the boilerplate needed to implement a command and
also gives us a place to track the breadth of the `Command` API. I tried
to be conservative with what went into the prelude modules, since it
might be hard/annoying to remove items from the prelude in the future.
Let me know if something should be included or excluded.
109 lines
3.5 KiB
Rust
109 lines
3.5 KiB
Rust
use nu_engine::command_prelude::*;
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub struct BytesCollect;
|
|
|
|
impl Command for BytesCollect {
|
|
fn name(&self) -> &str {
|
|
"bytes collect"
|
|
}
|
|
|
|
fn signature(&self) -> Signature {
|
|
Signature::build("bytes collect")
|
|
.input_output_types(vec![(Type::List(Box::new(Type::Binary)), Type::Binary)])
|
|
.optional(
|
|
"separator",
|
|
SyntaxShape::Binary,
|
|
"Optional separator to use when creating binary.",
|
|
)
|
|
.category(Category::Bytes)
|
|
}
|
|
|
|
fn usage(&self) -> &str {
|
|
"Concatenate multiple binary into a single binary, with an optional separator between each."
|
|
}
|
|
|
|
fn search_terms(&self) -> Vec<&str> {
|
|
vec!["join", "concatenate"]
|
|
}
|
|
|
|
fn run(
|
|
&self,
|
|
engine_state: &EngineState,
|
|
stack: &mut Stack,
|
|
call: &Call,
|
|
input: PipelineData,
|
|
) -> Result<PipelineData, ShellError> {
|
|
let separator: Option<Vec<u8>> = call.opt(engine_state, stack, 0)?;
|
|
// input should be a list of binary data.
|
|
let mut output_binary = vec![];
|
|
for value in input {
|
|
match value {
|
|
Value::Binary { mut val, .. } => {
|
|
output_binary.append(&mut val);
|
|
// manually concat
|
|
// TODO: make use of std::slice::Join when it's available in stable.
|
|
if let Some(sep) = &separator {
|
|
let mut work_sep = sep.clone();
|
|
output_binary.append(&mut work_sep)
|
|
}
|
|
}
|
|
// Explicitly propagate errors instead of dropping them.
|
|
Value::Error { error, .. } => return Err(*error),
|
|
other => {
|
|
return Err(ShellError::OnlySupportsThisInputType {
|
|
exp_input_type: "binary".into(),
|
|
wrong_type: other.get_type().to_string(),
|
|
dst_span: call.head,
|
|
src_span: other.span(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
match separator {
|
|
None => Ok(Value::binary(output_binary, call.head).into_pipeline_data()),
|
|
Some(sep) => {
|
|
if output_binary.is_empty() {
|
|
Ok(Value::binary(output_binary, call.head).into_pipeline_data())
|
|
} else {
|
|
// have push one extra separator in previous step, pop them out.
|
|
for _ in sep {
|
|
let _ = output_binary.pop();
|
|
}
|
|
Ok(Value::binary(output_binary, call.head).into_pipeline_data())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn examples(&self) -> Vec<Example> {
|
|
vec![
|
|
Example {
|
|
description: "Create a byte array from input",
|
|
example: "[0x[11] 0x[13 15]] | bytes collect",
|
|
result: Some(Value::binary(vec![0x11, 0x13, 0x15], Span::test_data())),
|
|
},
|
|
Example {
|
|
description: "Create a byte array from input with a separator",
|
|
example: "[0x[11] 0x[33] 0x[44]] | bytes collect 0x[01]",
|
|
result: Some(Value::binary(
|
|
vec![0x11, 0x01, 0x33, 0x01, 0x44],
|
|
Span::test_data(),
|
|
)),
|
|
},
|
|
]
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn test_examples() {
|
|
use crate::test_examples;
|
|
|
|
test_examples(BytesCollect {})
|
|
}
|
|
}
|