# Description This doesn't really do much that the user could see, but it helps get us ready to do the steps of the refactor to split the span off of Value, so that values can be spanless. This allows us to have top-level values that can hold both a Value and a Span, without requiring that all values have them. We expect to see significant memory reduction by removing so many unnecessary spans from values. For example, a table of 100,000 rows and 5 columns would have a savings of ~8megs in just spans that are almost always duplicated. # User-Facing Changes Nothing yet # 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 -A clippy::needless_collect -A clippy::result_large_err` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass - `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. -->
237 lines
7.8 KiB
Rust
237 lines
7.8 KiB
Rust
use nu_engine::CallExt;
|
|
use nu_protocol::{
|
|
ast::Call,
|
|
engine::{Command, EngineState, Stack},
|
|
Category, Example, PipelineData, Record, ShellError, Signature, Span, Spanned, SyntaxShape,
|
|
Type, Value,
|
|
};
|
|
use regex::Regex;
|
|
|
|
#[derive(Clone)]
|
|
pub struct SubCommand;
|
|
|
|
impl Command for SubCommand {
|
|
fn name(&self) -> &str {
|
|
"split column"
|
|
}
|
|
|
|
fn signature(&self) -> Signature {
|
|
Signature::build("split column")
|
|
.input_output_types(vec![
|
|
(Type::String, Type::Table(vec![])),
|
|
(
|
|
// TODO: no test coverage (is this behavior a bug or a feature?)
|
|
Type::List(Box::new(Type::String)),
|
|
Type::Table(vec![]),
|
|
),
|
|
])
|
|
.required(
|
|
"separator",
|
|
SyntaxShape::String,
|
|
"the character or string that denotes what separates columns",
|
|
)
|
|
.switch("collapse-empty", "remove empty columns", Some('c'))
|
|
.switch("regex", "separator is a regular expression", Some('r'))
|
|
.rest(
|
|
"rest",
|
|
SyntaxShape::String,
|
|
"column names to give the new columns",
|
|
)
|
|
.category(Category::Strings)
|
|
}
|
|
|
|
fn usage(&self) -> &str {
|
|
"Split a string into multiple columns using a separator."
|
|
}
|
|
|
|
fn search_terms(&self) -> Vec<&str> {
|
|
vec!["separate", "divide", "regex"]
|
|
}
|
|
|
|
fn run(
|
|
&self,
|
|
engine_state: &EngineState,
|
|
stack: &mut Stack,
|
|
call: &Call,
|
|
input: PipelineData,
|
|
) -> Result<PipelineData, ShellError> {
|
|
split_column(engine_state, stack, call, input)
|
|
}
|
|
|
|
fn examples(&self) -> Vec<Example> {
|
|
vec![
|
|
Example {
|
|
description: "Split a string into columns by the specified separator",
|
|
example: "'a--b--c' | split column '--'",
|
|
result: Some(Value::List {
|
|
vals: vec![Value::test_record(Record {
|
|
cols: vec![
|
|
"column1".to_string(),
|
|
"column2".to_string(),
|
|
"column3".to_string(),
|
|
],
|
|
vals: vec![
|
|
Value::test_string("a"),
|
|
Value::test_string("b"),
|
|
Value::test_string("c"),
|
|
],
|
|
})],
|
|
span: Span::test_data(),
|
|
}),
|
|
},
|
|
Example {
|
|
description: "Split a string into columns of char and remove the empty columns",
|
|
example: "'abc' | split column -c ''",
|
|
result: Some(Value::List {
|
|
vals: vec![Value::test_record(Record {
|
|
cols: vec![
|
|
"column1".to_string(),
|
|
"column2".to_string(),
|
|
"column3".to_string(),
|
|
],
|
|
vals: vec![
|
|
Value::test_string("a"),
|
|
Value::test_string("b"),
|
|
Value::test_string("c"),
|
|
],
|
|
})],
|
|
span: Span::test_data(),
|
|
}),
|
|
},
|
|
Example {
|
|
description: "Split a list of strings into a table",
|
|
example: "['a-b' 'c-d'] | split column -",
|
|
result: Some(Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["column1".to_string(), "column2".to_string()],
|
|
vals: vec![Value::test_string("a"), Value::test_string("b")],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["column1".to_string(), "column2".to_string()],
|
|
vals: vec![Value::test_string("c"), Value::test_string("d")],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
}),
|
|
},
|
|
Example {
|
|
description: "Split a list of strings into a table, ignoring padding",
|
|
example: r"['a - b' 'c - d'] | split column -r '\s*-\s*'",
|
|
result: Some(Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["column1".to_string(), "column2".to_string()],
|
|
vals: vec![Value::test_string("a"), Value::test_string("b")],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["column1".to_string(), "column2".to_string()],
|
|
vals: vec![Value::test_string("c"), Value::test_string("d")],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
}),
|
|
},
|
|
]
|
|
}
|
|
}
|
|
|
|
fn split_column(
|
|
engine_state: &EngineState,
|
|
stack: &mut Stack,
|
|
call: &Call,
|
|
input: PipelineData,
|
|
) -> Result<PipelineData, ShellError> {
|
|
let name_span = call.head;
|
|
let separator: Spanned<String> = call.req(engine_state, stack, 0)?;
|
|
let rest: Vec<Spanned<String>> = call.rest(engine_state, stack, 1)?;
|
|
let collapse_empty = call.has_flag("collapse-empty");
|
|
|
|
let regex = if call.has_flag("regex") {
|
|
Regex::new(&separator.item)
|
|
} else {
|
|
let escaped = regex::escape(&separator.item);
|
|
Regex::new(&escaped)
|
|
}
|
|
.map_err(|err| {
|
|
ShellError::GenericError(
|
|
"Error with regular expression".into(),
|
|
err.to_string(),
|
|
Some(separator.span),
|
|
None,
|
|
Vec::new(),
|
|
)
|
|
})?;
|
|
|
|
input.flat_map(
|
|
move |x| split_column_helper(&x, ®ex, &rest, collapse_empty, name_span),
|
|
engine_state.ctrlc.clone(),
|
|
)
|
|
}
|
|
|
|
fn split_column_helper(
|
|
v: &Value,
|
|
separator: &Regex,
|
|
rest: &[Spanned<String>],
|
|
collapse_empty: bool,
|
|
head: Span,
|
|
) -> Vec<Value> {
|
|
if let Ok(s) = v.as_string() {
|
|
let split_result: Vec<_> = separator
|
|
.split(&s)
|
|
.filter(|x| !(collapse_empty && x.is_empty()))
|
|
.collect();
|
|
let positional: Vec<_> = rest.iter().map(|f| f.item.clone()).collect();
|
|
|
|
// If they didn't provide column names, make up our own
|
|
let mut record = Record::new();
|
|
if positional.is_empty() {
|
|
let mut gen_columns = vec![];
|
|
for i in 0..split_result.len() {
|
|
gen_columns.push(format!("column{}", i + 1));
|
|
}
|
|
|
|
for (&k, v) in split_result.iter().zip(&gen_columns) {
|
|
record.push(v, Value::string(k, head));
|
|
}
|
|
} else {
|
|
for (&k, v) in split_result.iter().zip(&positional) {
|
|
record.push(v, Value::string(k, head));
|
|
}
|
|
}
|
|
vec![Value::record(record, head)]
|
|
} else {
|
|
match v {
|
|
Value::Error { error, .. } => {
|
|
vec![Value::Error {
|
|
error: Box::new(*error.clone()),
|
|
span: head,
|
|
}]
|
|
}
|
|
v => {
|
|
let span = v.span();
|
|
vec![Value::Error {
|
|
error: Box::new(ShellError::PipelineMismatch {
|
|
exp_input_type: "string".into(),
|
|
dst_span: head,
|
|
src_span: span,
|
|
}),
|
|
span,
|
|
}]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_examples() {
|
|
use crate::test_examples;
|
|
|
|
test_examples(SubCommand {})
|
|
}
|
|
}
|