holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Standardise the use of ShellError::UnsupportedInput and ShellError::TypeMismatch and add spans to every instance of the former (#7217)

Browse Source 
# Description

* I was dismayed to discover recently that UnsupportedInput and
TypeMismatch are used *extremely* inconsistently across the codebase.
UnsupportedInput is sometimes used for input type-checks (as per the
name!!), but *also* used for argument type-checks. TypeMismatch is also
used for both.
I thus devised the following standard: input type-checking *only* uses
UnsupportedInput, and argument type-checking *only* uses TypeMismatch.
Moreover, to differentiate them, UnsupportedInput now has *two* error
arrows (spans), one pointing at the command and the other at the input
origin, while TypeMismatch only has the one (because the command should
always be nearby)
* In order to apply that standard, a very large number of
UnsupportedInput uses were changed so that the input's span could be
retrieved and delivered to it.
* Additionally, I noticed many places where **errors are not propagated
correctly**: there are lots of `match` sites which take a Value::Error,
then throw it away and replace it with a new Value::Error with
less/misleading information (such as reporting the error as an
"incorrect type"). I believe that the earliest errors are the most
important, and should always be propagated where possible.
* Also, to standardise one broad subset of UnsupportedInput error
messages, who all used slightly different wordings of "expected
`<type>`, got `<type>`", I created OnlySupportsThisInputType as a
variant of it.
* Finally, a bunch of error sites that had "repeated spans" - i.e. where
an error expected two spans, but `call.head` was given for both - were
fixed to use different spans.

# Example
BEFORE
```
〉20b | str starts-with 'a'
Error: nu:🐚:unsupported_input (link)

  × Unsupported input
   ╭─[entry #31:1:1]
 1 │ 20b | str starts-with 'a'
   ·   ┬
   ·   ╰── Input's type is filesize. This command only works with strings.
   ╰────

〉'a' | math cos
Error: nu:🐚:unsupported_input (link)

  × Unsupported input
   ╭─[entry #33:1:1]
 1 │ 'a' | math cos
   · ─┬─
   ·  ╰── Only numerical values are supported, input type: String
   ╰────

〉0x[12] | encode utf8
Error: nu:🐚:unsupported_input (link)

  × Unsupported input
   ╭─[entry #38:1:1]
 1 │ 0x[12] | encode utf8
   ·          ───┬──
   ·             ╰── non-string input
   ╰────
```
AFTER
```
〉20b | str starts-with 'a'
Error: nu:🐚:pipeline_mismatch (link)

  × Pipeline mismatch.
   ╭─[entry #1:1:1]
 1 │ 20b | str starts-with 'a'
   ·   ┬   ───────┬───────
   ·   │          ╰── only string input data is supported
   ·   ╰── input type: filesize
   ╰────

〉'a' | math cos
Error: nu:🐚:pipeline_mismatch (link)

  × Pipeline mismatch.
   ╭─[entry #2:1:1]
 1 │ 'a' | math cos
   · ─┬─   ────┬───
   ·  │        ╰── only numeric input data is supported
   ·  ╰── input type: string
   ╰────

〉0x[12] | encode utf8
Error: nu:🐚:pipeline_mismatch (link)

  × Pipeline mismatch.
   ╭─[entry #3:1:1]
 1 │ 0x[12] | encode utf8
   · ───┬──   ───┬──
   ·    │        ╰── only string input data is supported
   ·    ╰── input type: binary
   ╰────
```

# User-Facing Changes

Various error messages suddenly make more sense (i.e. have two arrows
instead of one).

# 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` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass

# 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.
This commit is contained in:
Leon
2022-12-23 16:48:53 +10:00
committed by GitHub
parent 9364bad625
commit dd7b7311b3
154 changed files with 1617 additions and 1025 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
crates/nu-command/src/strings/char_.rs
View File

@ -288,7 +288,7 @@ impl Command for Char {
if let Some(output) = special_character {
Ok(Value::string(output, call_span).into_pipeline_data())
} else {
Err(ShellError::UnsupportedInput(
Err(ShellError::TypeMismatch(
"error finding named character".into(),
call.positional_nth(0)
.expect("Unexpected missing argument")
@ -305,7 +305,7 @@ fn integer_to_unicode_char(value: i64, t: &Span) -> Result<char, ShellError> {
if let Some(ch) = decoded_char {
Ok(ch)
} else {
Err(ShellError::UnsupportedInput(
Err(ShellError::TypeMismatch(
"not a valid Unicode codepoint".into(),
*t,
))
@ -320,7 +320,7 @@ fn string_to_unicode_char(s: &str, t: &Span) -> Result<char, ShellError> {
if let Some(ch) = decoded_char {
Ok(ch)
} else {
Err(ShellError::UnsupportedInput(
Err(ShellError::TypeMismatch(
"error decoding Unicode character".into(),
*t,
))

7
crates/nu-command/src/strings/encode_decode/base64.rs
View File

@ -98,14 +98,19 @@ fn action(
)}
};
match input {
// Propagate existing errors.
Value::Error { .. } => input.clone(),
Value::Binary { val, .. } => match base64_config.action_type {
ActionType::Encode => {
Value::string(encode_config(val, base64_config_enum), command_span)
}
ActionType::Decode => Value::Error {
error: ShellError::UnsupportedInput(
"Binary data can only support encoding".to_string(),
"Binary data can only be encoded".to_string(),
"value originates from here".into(),
command_span,
// This line requires the Value::Error {} match above.
input.expect_span(),
),
},
},

18
crates/nu-command/src/strings/encode_decode/decode.rs
View File

@ -74,12 +74,24 @@ documentation link at https://docs.rs/encoding_rs/0.8.28/encoding_rs/#statics"#
let bytes: Vec<u8> = stream.into_bytes()?.item;
super::encoding::decode(head, encoding, &bytes).map(|val| val.into_pipeline_data())
}
PipelineData::Value(Value::Binary { val: bytes, .. }, ..) => {
super::encoding::decode(head, encoding, &bytes).map(|val| val.into_pipeline_data())
}
PipelineData::Value(v, ..) => match v {
Value::Binary { val: bytes, .. } => super::encoding::decode(head, encoding, &bytes)
.map(|val| val.into_pipeline_data()),
Value::Error { error } => Err(error),
_ => Err(ShellError::OnlySupportsThisInputType(
"binary".into(),
v.get_type().to_string(),
head,
v.expect_span(),
)),
},
// This should be more precise, but due to difficulties in getting spans
// from PipelineData::ListData, this is as it is.
_ => Err(ShellError::UnsupportedInput(
"non-binary input".into(),
"value originates from here".into(),
head,
input.span().unwrap_or(head),
)),
}
}

19
crates/nu-command/src/strings/encode_decode/encode.rs
View File

@ -74,12 +74,25 @@ documentation link at https://docs.rs/encoding_rs/0.8.28/encoding_rs/#statics"#
let s = stream.into_string()?.item;
super::encoding::encode(head, encoding, &s).map(|val| val.into_pipeline_data())
}
PipelineData::Value(Value::String { val: s, .. }, ..) => {
super::encoding::encode(head, encoding, &s).map(|val| val.into_pipeline_data())
}
PipelineData::Value(v, ..) => match v {
Value::String { val: s, .. } => {
super::encoding::encode(head, encoding, &s).map(|val| val.into_pipeline_data())
}
Value::Error { error } => Err(error),
_ => Err(ShellError::OnlySupportsThisInputType(
"string".into(),
v.get_type().to_string(),
head,
v.expect_span(),
)),
},
// This should be more precise, but due to difficulties in getting spans
// from PipelineData::ListData, this is as it is.
_ => Err(ShellError::UnsupportedInput(
"non-string input".into(),
"value originates from here".into(),
head,
input.span().unwrap_or(head),
)),
}
}

20
crates/nu-command/src/strings/format/command.rs
View File

@ -230,11 +230,13 @@ fn format(
}
}
}
Value::Error { error } => return Err(error.clone()),
_ => {
return Err(ShellError::UnsupportedInput(
"Input data is not supported by this command.".to_string(),
return Err(ShellError::OnlySupportsThisInputType(
"record".to_string(),
val.get_type().to_string(),
head_span,
val.expect_span(),
))
}
}
@ -245,9 +247,15 @@ fn format(
None,
))
}
_ => Err(ShellError::UnsupportedInput(
"Input data is not supported by this command.".to_string(),
// Unwrapping this ShellError is a bit unfortunate.
// Ideally, its Span would be preserved.
Value::Error { error } => Err(error),
_ => Err(ShellError::OnlySupportsThisInputType(
"record".to_string(),
data_as_value.get_type().to_string(),
head_span,
// This line requires the Value::Error match above.
data_as_value.expect_span(),
)),
}
}
@ -291,7 +299,7 @@ fn format_record(
}
}
Some(err) => {
return Err(ShellError::UnsupportedInput(
return Err(ShellError::TypeMismatch(
format!("expression is invalid, detail message: {:?}", err),
*span,
))

12
crates/nu-command/src/strings/format/filesize.rs
View File

@ -104,13 +104,13 @@ fn format_value_impl(val: &Value, arg: &Arguments, span: Span) -> Value {
val: format_filesize(*val, &arg.format_value, None),
span: *span,
},
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is not supported, support type: <filesize>, current_type: {}",
other.get_type()
),
Value::Error { .. } => val.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"filesize".into(),
val.get_type().to_string(),
span,
val.expect_span(),
),
},
}

4
crates/nu-command/src/strings/size.rs
View File

@ -116,6 +116,10 @@ fn size(
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let span = call.head;
// This doesn't match explicit nulls
if matches!(input, PipelineData::Empty) {
return Err(ShellError::PipelineEmpty(span));
}
input.map(
move |v| {
// First, obtain the span. If this fails, propagate the error that results.

12
crates/nu-command/src/strings/str_/case/capitalize.rs
View File

@ -108,13 +108,13 @@ fn action(input: &Value, head: Span) -> Value {
val: uppercase_helper(val),
span: head,
},
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

12
crates/nu-command/src/strings/str_/case/downcase.rs
View File

@ -123,13 +123,13 @@ fn action(input: &Value, head: Span) -> Value {
val: val.to_ascii_lowercase(),
span: head,
},
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

12
crates/nu-command/src/strings/str_/case/mod.rs
View File

@ -67,13 +67,13 @@ where
val: case_operation(val),
span: head,
},
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

15
crates/nu-command/src/strings/str_/case/upcase.rs
View File

@ -84,12 +84,15 @@ fn action(input: &Value, head: Span) -> Value {
val: s.to_uppercase(),
span: head,
},
other => {
let got = format!("Expected string but got {}", other.get_type());
Value::Error {
error: ShellError::UnsupportedInput(got, head),
}
}
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}
}

12
crates/nu-command/src/strings/str_/contains.rs
View File

@ -190,13 +190,13 @@ fn action(
},
head,
),
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

14
crates/nu-command/src/strings/str_/distance.rs
View File

@ -92,18 +92,18 @@ impl Command for SubCommand {
fn action(input: &Value, args: &Arguments, head: Span) -> Value {
let compare_string = &args.compare_string;
match &input {
match input {
Value::String { val, .. } => {
let distance = levenshtein_distance(val, compare_string);
Value::int(distance as i64, head)
}
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

12
crates/nu-command/src/strings/str_/ends_with.rs
View File

@ -81,13 +81,13 @@ impl Command for SubCommand {
fn action(input: &Value, args: &Arguments, head: Span) -> Value {
match input {
Value::String { val, .. } => Value::boolean(val.ends_with(&args.substring), head),
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

36
crates/nu-command/src/strings/str_/index_of.rs
View File

@ -150,13 +150,13 @@ fn action(
Value::int(-1, head)
}
}
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}
@ -185,8 +185,8 @@ fn process_range(
}
Value::List { vals, .. } => {
if vals.len() > 2 {
Err(ShellError::UnsupportedInput(
String::from("there shouldn't be more than two indexes. too many indexes"),
Err(ShellError::TypeMismatch(
String::from("there shouldn't be more than two indexes"),
head,
))
} else {
@ -201,12 +201,12 @@ fn process_range(
Ok((start_index, end_index))
}
}
other => Err(ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { error } => Err(error.clone()),
_ => Err(ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
)),
}?;
@ -214,18 +214,16 @@ fn process_range(
let end_index = r.1.parse::<i32>().unwrap_or(input_len as i32);
if start_index < 0 || start_index > end_index {
return Err(ShellError::UnsupportedInput(
String::from(
"start index can't be negative or greater than end index. Invalid start index",
),
return Err(ShellError::TypeMismatch(
String::from("start index can't be negative or greater than end index"),
head,
));
}
if end_index < 0 || end_index < start_index || end_index > input_len as i32 {
return Err(ShellError::UnsupportedInput(
return Err(ShellError::TypeMismatch(
String::from(
"end index can't be negative, smaller than start index or greater than input length. Invalid end index"),
"end index can't be negative, smaller than start index or greater than input length"),
head,
));
}

12
crates/nu-command/src/strings/str_/length.rs
View File

@ -67,13 +67,13 @@ impl Command for SubCommand {
fn action(input: &Value, _arg: &CellPathOnlyArgs, head: Span) -> Value {
match input {
Value::String { val, .. } => Value::int(val.len() as i64, head),
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

19
crates/nu-command/src/strings/str_/lpad.rs
View File

@ -69,7 +69,7 @@ impl Command for SubCommand {
};
if args.length.expect("this exists") < 0 {
return Err(ShellError::UnsupportedInput(
return Err(ShellError::TypeMismatch(
String::from("The length of the string cannot be negative"),
call.head,
));
@ -137,19 +137,16 @@ fn action(
}
}
None => Value::Error {
error: ShellError::UnsupportedInput(
String::from("Length argument is missing"),
head,
),
error: ShellError::TypeMismatch(String::from("Length argument is missing"), head),
},
},
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

19
crates/nu-command/src/strings/str_/replace.rs
View File

@ -209,18 +209,23 @@ fn action(
}
}
Err(e) => Value::Error {
error: ShellError::UnsupportedInput(format!("{e}"), find.span),
error: ShellError::UnsupportedInput(
format!("{e}"),
"value originates from here".into(),
head,
find.span,
),
},
}
}
}
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

13
crates/nu-command/src/strings/str_/reverse.rs
View File

@ -75,14 +75,13 @@ fn action(input: &Value, _arg: &CellPathOnlyArgs, head: Span) -> Value {
val: val.chars().rev().collect::<String>(),
span: head,
},
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

19
crates/nu-command/src/strings/str_/rpad.rs
View File

@ -69,7 +69,7 @@ impl Command for SubCommand {
};
if args.length.expect("this exists") < 0 {
return Err(ShellError::UnsupportedInput(
return Err(ShellError::TypeMismatch(
String::from("The length of the string cannot be negative"),
call.head,
));
@ -129,19 +129,16 @@ fn action(
}
}
None => Value::Error {
error: ShellError::UnsupportedInput(
String::from("Length argument is missing"),
head,
),
error: ShellError::TypeMismatch(String::from("Length argument is missing"), head),
},
},
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

12
crates/nu-command/src/strings/str_/starts_with.rs
View File

@ -92,13 +92,13 @@ fn action(input: &Value, Arguments { substring, .. }: &Arguments, head: Span) ->
let starts_with = s.starts_with(substring);
Value::boolean(starts_with, head)
}
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}

36
crates/nu-command/src/strings/str_/substring.rs
View File

@ -136,7 +136,7 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
match start.cmp(&end) {
Ordering::Equal => Value::string("", head),
Ordering::Greater => Value::Error {
error: ShellError::UnsupportedInput(
error: ShellError::TypeMismatch(
"End must be greater than or equal to Start".to_string(),
head,
),
@ -165,13 +165,15 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
Value::string("", head)
}
}
// Propagate errors by explicitly matching them before the final case.
Value::Error { .. } => input.clone(),
other => Value::Error {
error: ShellError::UnsupportedInput(
format!(
"Input's type is {}. This command only works with strings.",
other.get_type()
),
"Only string values are supported".into(),
format!("input type: {:?}", other.get_type()),
head,
// This line requires the Value::Error match above.
other.expect_span(),
),
},
}
@ -186,7 +188,7 @@ fn process_arguments(range: &Value, head: Span) -> Result<(isize, isize), ShellE
}
Value::List { vals, .. } => {
if vals.len() > 2 {
Err(ShellError::UnsupportedInput(
Err(ShellError::TypeMismatch(
"More than two indices given".to_string(),
head,
))
@ -197,7 +199,7 @@ fn process_arguments(range: &Value, head: Span) -> Result<(isize, isize), ShellE
match v {
Value::Int { val, .. } => Ok(val.to_string()),
Value::String { val, .. } => Ok(val.to_string()),
_ => Err(ShellError::UnsupportedInput(
_ => Err(ShellError::TypeMismatch(
"could not perform substring. Expecting a string or int"
.to_string(),
head,
@ -210,19 +212,13 @@ fn process_arguments(range: &Value, head: Span) -> Result<(isize, isize), ShellE
let start = idx
.get(0)
.ok_or_else(|| {
ShellError::UnsupportedInput(
"could not perform substring".to_string(),
head,
)
ShellError::TypeMismatch("could not perform substring".to_string(), head)
})?
.to_string();
let end = idx
.get(1)
.ok_or_else(|| {
ShellError::UnsupportedInput(
"could not perform substring".to_string(),
head,
)
ShellError::TypeMismatch("could not perform substring".to_string(), head)
})?
.to_string();
Ok(SubstringText(start, end))
@ -234,19 +230,19 @@ fn process_arguments(range: &Value, head: Span) -> Result<(isize, isize), ShellE
let start = idx
.first()
.ok_or_else(|| {
ShellError::UnsupportedInput("could not perform substring".to_string(), head)
ShellError::TypeMismatch("could not perform substring".to_string(), head)
})?
.to_string();
let end = idx
.get(1)
.ok_or_else(|| {
ShellError::UnsupportedInput("could not perform substring".to_string(), head)
ShellError::TypeMismatch("could not perform substring".to_string(), head)
})?
.to_string();
Ok(SubstringText(start, end))
}
_ => Err(ShellError::UnsupportedInput(
_ => Err(ShellError::TypeMismatch(
"could not perform substring".to_string(),
head,
)),
@ -254,14 +250,14 @@ fn process_arguments(range: &Value, head: Span) -> Result<(isize, isize), ShellE
let start = match &search {
SubstringText(start, _) if start.is_empty() || start == "_" => 0,
SubstringText(start, _) => start.trim().parse().map_err(|_| {
ShellError::UnsupportedInput("could not perform substring".to_string(), head)
ShellError::TypeMismatch("could not perform substring".to_string(), head)
})?,
};
let end = match &search {
SubstringText(_, end) if end.is_empty() || end == "_" => isize::max_value(),
SubstringText(_, end) => end.trim().parse().map_err(|_| {
ShellError::UnsupportedInput("could not perform substring".to_string(), head)
ShellError::TypeMismatch("could not perform substring".to_string(), head)
})?,
};

11
crates/nu-command/src/strings/str_/trim/trim_.rs
View File

@ -181,6 +181,8 @@ fn action(input: &Value, arg: &Arguments, head: Span) -> Value {
val: trim(s, char_, closure_flags),
span: head,
},
// Propagate errors by explicitly matching them before the final case.
Value::Error { .. } => input.clone(),
other => match mode {
ActionMode::Global => match other {
Value::Record { cols, vals, span } => {
@ -203,9 +205,14 @@ fn action(input: &Value, arg: &Arguments, head: Span) -> Value {
_ => input.clone(),
},
ActionMode::Local => {
let got = format!("Input must be a string. Found {}", other.get_type());
Value::Error {
error: ShellError::UnsupportedInput(got, head),
error: ShellError::UnsupportedInput(
"Only string values are supported".into(),
format!("input type: {:?}", other.get_type()),
head,
// This line requires the Value::Error match above.
other.expect_span(),
),
}
}
},