forked from extern/nushell
8da27a1a09
# Description
This PR creates a new `Record` type to reduce duplicate code and
possibly bugs as well. (This is an edited version of #9648.)
- `Record` implements `FromIterator` and `IntoIterator` and so can be
iterated over or collected into. For example, this helps with
conversions to and from (hash)maps. (Also, no more
`cols.iter().zip(vals)`!)
- `Record` has a `push(col, val)` function to help insure that the
number of columns is equal to the number of values. I caught a few
potential bugs thanks to this (e.g. in the `ls` command).
- Finally, this PR also adds a `record!` macro that helps simplify
record creation. It is used like so:
```rust
record! {
"key1" => some_value,
"key2" => Value::string("text", span),
"key3" => Value::int(optional_int.unwrap_or(0), span),
"key4" => Value::bool(config.setting, span),
}
```
Since macros hinder formatting, etc., the right hand side values should
be relatively short and sweet like the examples above.
Where possible, prefer `record!` or `.collect()` on an iterator instead
of multiple `Record::push`s, since the first two automatically set the
record capacity and do less work overall.
# User-Facing Changes
Besides the changes in `nu-protocol` the only other breaking changes are
to `nu-table::{ExpandedTable::build_map, JustTable::kv_table}`.
369 lines
13 KiB
Rust
369 lines
13 KiB
Rust
use alphanumeric_sort::compare_str;
|
|
use nu_engine::column::nonexistent_column;
|
|
use nu_protocol::{ShellError, Span, Value};
|
|
use std::cmp::Ordering;
|
|
|
|
// This module includes sorting functionality that is useful in sort-by and elsewhere.
|
|
// Eventually it would be nice to find a better home for it; sorting logic is only coupled
|
|
// to commands for historical reasons.
|
|
|
|
/// Sort a value. This only makes sense for lists and list-like things,
|
|
/// so for everything else we just return the value as-is.
|
|
/// CustomValues are converted to their base value and then sorted.
|
|
pub fn sort_value(
|
|
val: &Value,
|
|
sort_columns: Vec<String>,
|
|
ascending: bool,
|
|
insensitive: bool,
|
|
natural: bool,
|
|
) -> Result<Value, ShellError> {
|
|
match val {
|
|
Value::List { vals, span } => {
|
|
let mut vals = vals.clone();
|
|
sort(&mut vals, sort_columns, *span, insensitive, natural)?;
|
|
|
|
if !ascending {
|
|
vals.reverse();
|
|
}
|
|
|
|
Ok(Value::List { vals, span: *span })
|
|
}
|
|
Value::CustomValue { val, span } => {
|
|
let base_val = val.to_base_value(*span)?;
|
|
sort_value(&base_val, sort_columns, ascending, insensitive, natural)
|
|
}
|
|
_ => Ok(val.to_owned()),
|
|
}
|
|
}
|
|
|
|
/// Sort a value in-place. This is more efficient than sort_value() because it
|
|
/// avoids cloning, but it does not work for CustomValues; they are returned as-is.
|
|
pub fn sort_value_in_place(
|
|
val: &mut Value,
|
|
sort_columns: Vec<String>,
|
|
ascending: bool,
|
|
insensitive: bool,
|
|
natural: bool,
|
|
) -> Result<(), ShellError> {
|
|
if let Value::List { vals, span } = val {
|
|
sort(vals, sort_columns, *span, insensitive, natural)?;
|
|
if !ascending {
|
|
vals.reverse();
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn sort(
|
|
vec: &mut [Value],
|
|
sort_columns: Vec<String>,
|
|
span: Span,
|
|
insensitive: bool,
|
|
natural: bool,
|
|
) -> Result<(), ShellError> {
|
|
match vec.first() {
|
|
Some(Value::Record {
|
|
val: record,
|
|
span: val_span,
|
|
}) => {
|
|
if sort_columns.is_empty() {
|
|
// This uses the same format as the 'requires a column name' error in split_by.rs
|
|
return Err(ShellError::GenericError(
|
|
"expected name".into(),
|
|
"requires a column name to sort table data".into(),
|
|
Some(span),
|
|
None,
|
|
Vec::new(),
|
|
));
|
|
}
|
|
|
|
if let Some(nonexistent) = nonexistent_column(sort_columns.clone(), record.cols.clone())
|
|
{
|
|
return Err(ShellError::CantFindColumn {
|
|
col_name: nonexistent,
|
|
span,
|
|
src_span: *val_span,
|
|
});
|
|
}
|
|
|
|
// check to make sure each value in each column in the record
|
|
// that we asked for is a string. So, first collect all the columns
|
|
// that we asked for into vals, then later make sure they're all
|
|
// strings.
|
|
let mut vals = vec![];
|
|
for item in vec.iter() {
|
|
for col in &sort_columns {
|
|
let val = item
|
|
.get_data_by_key(col)
|
|
.unwrap_or_else(|| Value::nothing(Span::unknown()));
|
|
vals.push(val);
|
|
}
|
|
}
|
|
|
|
let should_sort_case_insensitively = insensitive
|
|
&& vals
|
|
.iter()
|
|
.all(|x| matches!(x.get_type(), nu_protocol::Type::String));
|
|
|
|
let should_sort_case_naturally = natural
|
|
&& vals
|
|
.iter()
|
|
.all(|x| matches!(x.get_type(), nu_protocol::Type::String));
|
|
|
|
vec.sort_by(|a, b| {
|
|
compare(
|
|
a,
|
|
b,
|
|
&sort_columns,
|
|
span,
|
|
should_sort_case_insensitively,
|
|
should_sort_case_naturally,
|
|
)
|
|
});
|
|
}
|
|
_ => {
|
|
vec.sort_by(|a, b| {
|
|
if insensitive {
|
|
let lowercase_left = match a {
|
|
Value::String { val, span } => Value::String {
|
|
val: val.to_ascii_lowercase(),
|
|
span: *span,
|
|
},
|
|
_ => a.clone(),
|
|
};
|
|
|
|
let lowercase_right = match b {
|
|
Value::String { val, span } => Value::String {
|
|
val: val.to_ascii_lowercase(),
|
|
span: *span,
|
|
},
|
|
_ => b.clone(),
|
|
};
|
|
|
|
if natural {
|
|
match (lowercase_left.as_string(), lowercase_right.as_string()) {
|
|
(Ok(left), Ok(right)) => compare_str(left, right),
|
|
_ => Ordering::Equal,
|
|
}
|
|
} else {
|
|
lowercase_left
|
|
.partial_cmp(&lowercase_right)
|
|
.unwrap_or(Ordering::Equal)
|
|
}
|
|
} else if natural {
|
|
match (a.as_string(), b.as_string()) {
|
|
(Ok(left), Ok(right)) => compare_str(left, right),
|
|
_ => Ordering::Equal,
|
|
}
|
|
} else {
|
|
a.partial_cmp(b).unwrap_or(Ordering::Equal)
|
|
}
|
|
});
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn compare(
|
|
left: &Value,
|
|
right: &Value,
|
|
columns: &[String],
|
|
span: Span,
|
|
insensitive: bool,
|
|
natural: bool,
|
|
) -> Ordering {
|
|
for column in columns {
|
|
let left_value = left.get_data_by_key(column);
|
|
|
|
let left_res = match left_value {
|
|
Some(left_res) => left_res,
|
|
None => Value::Nothing { span },
|
|
};
|
|
|
|
let right_value = right.get_data_by_key(column);
|
|
|
|
let right_res = match right_value {
|
|
Some(right_res) => right_res,
|
|
None => Value::Nothing { span },
|
|
};
|
|
|
|
let result = if insensitive {
|
|
let lowercase_left = match left_res {
|
|
Value::String { val, span } => Value::String {
|
|
val: val.to_ascii_lowercase(),
|
|
span,
|
|
},
|
|
_ => left_res,
|
|
};
|
|
|
|
let lowercase_right = match right_res {
|
|
Value::String { val, span } => Value::String {
|
|
val: val.to_ascii_lowercase(),
|
|
span,
|
|
},
|
|
_ => right_res,
|
|
};
|
|
if natural {
|
|
match (lowercase_left.as_string(), lowercase_right.as_string()) {
|
|
(Ok(left), Ok(right)) => compare_str(left, right),
|
|
_ => Ordering::Equal,
|
|
}
|
|
} else {
|
|
lowercase_left
|
|
.partial_cmp(&lowercase_right)
|
|
.unwrap_or(Ordering::Equal)
|
|
}
|
|
} else if natural {
|
|
match (left_res.as_string(), right_res.as_string()) {
|
|
(Ok(left), Ok(right)) => compare_str(left, right),
|
|
_ => Ordering::Equal,
|
|
}
|
|
} else {
|
|
left_res.partial_cmp(&right_res).unwrap_or(Ordering::Equal)
|
|
};
|
|
if result != Ordering::Equal {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Ordering::Equal
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use nu_protocol::{Record, Span, Value};
|
|
|
|
#[test]
|
|
fn test_sort_value() {
|
|
let val = Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("pear"), Value::test_int(3)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("orange"), Value::test_int(7)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("apple"), Value::test_int(9)],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
};
|
|
|
|
let sorted_alphabetically =
|
|
sort_value(&val, vec!["fruit".to_string()], true, false, false).unwrap();
|
|
assert_eq!(
|
|
sorted_alphabetically,
|
|
Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("apple"), Value::test_int(9)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("orange"), Value::test_int(7)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("pear"), Value::test_int(3)],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
}
|
|
);
|
|
|
|
let sorted_by_count_desc =
|
|
sort_value(&val, vec!["count".to_string()], false, false, false).unwrap();
|
|
assert_eq!(
|
|
sorted_by_count_desc,
|
|
Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("apple"), Value::test_int(9)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("orange"), Value::test_int(7)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("pear"), Value::test_int(3)],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_sort_value_in_place() {
|
|
let mut val = Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("pear"), Value::test_int(3)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("orange"), Value::test_int(7)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("apple"), Value::test_int(9)],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
};
|
|
|
|
sort_value_in_place(&mut val, vec!["fruit".to_string()], true, false, false).unwrap();
|
|
assert_eq!(
|
|
val,
|
|
Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("apple"), Value::test_int(9)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("orange"), Value::test_int(7)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("pear"), Value::test_int(3)],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
}
|
|
);
|
|
|
|
sort_value_in_place(&mut val, vec!["count".to_string()], false, false, false).unwrap();
|
|
assert_eq!(
|
|
val,
|
|
Value::List {
|
|
vals: vec![
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("apple"), Value::test_int(9)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("orange"), Value::test_int(7)],
|
|
}),
|
|
Value::test_record(Record {
|
|
cols: vec!["fruit".to_string(), "count".to_string()],
|
|
vals: vec![Value::test_string("pear"), Value::test_int(3)],
|
|
}),
|
|
],
|
|
span: Span::test_data(),
|
|
}
|
|
);
|
|
}
|
|
}
|