Mirrors/nushell
2
0
Fork 0
mirror of https://github.com/nushell/nushell synced 2024-12-26 04:53:09 +00:00
Code Issues Projects Releases Packages Wiki Activity

Use variable names directly in the format strings (#7906)

Browse source 
# Description

Lint: `clippy::uninlined_format_args`

More readable in most situations.
(May be slightly confusing for modifier format strings
https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters)

Alternative to #7865

# User-Facing Changes

None intended

# Tests + Formatting

(Ran `cargo +stable clippy --fix --workspace -- -A clippy::all -D
clippy::uninlined_format_args` to achieve this. Depends on Rust `1.67`)
This commit is contained in:
Stefan Holderbach 2023-01-30 02:37:54 +01:00 committed by GitHub
parent 6ae497eedc
commit ab480856a5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
134 changed files with 386 additions and 431 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
crates/nu-cli/src/completions/completer.rs
View file

@ -104,7 +104,7 @@ impl NuCompleter {
return Some(result); return Some(result);
} }
} }
Err(err) => println!("failed to eval completer block: {}", err), Err(err) => println!("failed to eval completer block: {err}"),
} }
None None

4
crates/nu-cli/src/completions/directory_completions.rs
View file

@ -119,7 +119,7 @@ pub fn directory_completion(
let mut file_name = entry.file_name().to_string_lossy().into_owned(); let mut file_name = entry.file_name().to_string_lossy().into_owned();
if matches(&partial, &file_name, options) { if matches(&partial, &file_name, options) {
let mut path = if prepend_base_dir(original_input, &base_dir_name) { let mut path = if prepend_base_dir(original_input, &base_dir_name) {
format!("{}{}", base_dir_name, file_name) format!("{base_dir_name}{file_name}")
} else { } else {
file_name.to_string() file_name.to_string()
}; };
@ -135,7 +135,7 @@ pub fn directory_completion(
|| path.contains(' ') || path.contains(' ')
|| path.contains('#') || path.contains('#')
{ {
path = format!("`{}`", path); path = format!("`{path}`");
} }
Some((span, path)) Some((span, path))

2
crates/nu-cli/src/completions/dotnu_completions.rs
View file

@ -58,7 +58,7 @@ impl Completer for DotNuCompletion {
}; };
// Check if the base_dir is a folder // Check if the base_dir is a folder
if base_dir != format!(".{}", SEP) { if base_dir != format!(".{SEP}") {
// Add the base dir into the directories to be searched // Add the base dir into the directories to be searched
search_dirs.push(base_dir.clone()); search_dirs.push(base_dir.clone());

6
crates/nu-cli/src/completions/file_completions.rs
View file

@ -124,7 +124,7 @@ pub fn file_path_completion(
let mut file_name = entry.file_name().to_string_lossy().into_owned(); let mut file_name = entry.file_name().to_string_lossy().into_owned();
if matches(&partial, &file_name, options) { if matches(&partial, &file_name, options) {
let mut path = if prepend_base_dir(original_input, &base_dir_name) { let mut path = if prepend_base_dir(original_input, &base_dir_name) {
format!("{}{}", base_dir_name, file_name) format!("{base_dir_name}{file_name}")
} else { } else {
file_name.to_string() file_name.to_string()
}; };
@ -142,7 +142,7 @@ pub fn file_path_completion(
|| path.contains('(') || path.contains('(')
|| path.contains(')') || path.contains(')')
{ {
path = format!("`{}`", path); path = format!("`{path}`");
} }
Some((span, path)) Some((span, path))
@ -170,7 +170,7 @@ pub fn matches(partial: &str, from: &str, options: &CompletionOptions) -> bool {
/// Returns whether the base_dir should be prepended to the file path /// Returns whether the base_dir should be prepended to the file path
pub fn prepend_base_dir(input: &str, base_dir: &str) -> bool { pub fn prepend_base_dir(input: &str, base_dir: &str) -> bool {
if base_dir == format!(".{}", SEP) { if base_dir == format!(".{SEP}") {
// if the current base_dir path is the local folder we only add a "./" prefix if the user // if the current base_dir path is the local folder we only add a "./" prefix if the user
// input already includes a local folder prefix. // input already includes a local folder prefix.
let manually_entered = { let manually_entered = {

4
crates/nu-cli/src/eval_file.rs
View file

@ -81,7 +81,7 @@ pub fn evaluate_file(
report_error( report_error(
&working_set, &working_set,
&ShellError::FileNotFoundCustom( &ShellError::FileNotFoundCustom(
format!("The file path '{}' does not have a parent", file_path_str), format!("The file path '{file_path_str}' does not have a parent"),
Span::unknown(), Span::unknown(),
), ),
); );
@ -193,6 +193,6 @@ fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, co
} }
let out = item.into_string("\n", config) + "\n"; let out = item.into_string("\n", config) + "\n";
let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err)); let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{err}"));
} }
} }

6
crates/nu-cli/src/menus/description_menu.rs
View file

@ -411,10 +411,10 @@ impl DescriptionMenu {
RESET RESET
) )
} else { } else {
format!(" {}\r\n", example) format!(" {example}\r\n")
} }
} else { } else {
format!(" {}\r\n", example) format!(" {example}\r\n")
} }
}) })
.collect(); .collect();
@ -429,7 +429,7 @@ impl DescriptionMenu {
examples, examples,
) )
} else { } else {
format!("\r\n\r\nExamples:\r\n{}", examples,) format!("\r\n\r\nExamples:\r\n{examples}",)
} }
} }
} }

2
crates/nu-cli/src/menus/menu_completions.rs
View file

@ -154,7 +154,7 @@ fn convert_to_suggestions(
.flat_map(|val| convert_to_suggestions(val, line, pos, only_buffer_difference)) .flat_map(|val| convert_to_suggestions(val, line, pos, only_buffer_difference))
.collect(), .collect(),
_ => vec![Suggestion { _ => vec![Suggestion {
value: format!("Not a record: {:?}", value), value: format!("Not a record: {value:?}"),
description: None, description: None,
extra: None, extra: None,
span: reedline::Span { span: reedline::Span {

2
crates/nu-cli/src/prompt.rs
View file

@ -91,7 +91,7 @@ impl NushellPrompt {
} }
fn default_wrapped_custom_string(&self, str: String) -> String { fn default_wrapped_custom_string(&self, str: String) -> String {
format!("({})", str) format!("({str})")
} }
} }

3
crates/nu-cli/src/prompt_update.rs
View file

@ -106,8 +106,7 @@ pub(crate) fn update_prompt<'prompt>(
let left_prompt_string = if config.shell_integration { let left_prompt_string = if config.shell_integration {
if let Some(prompt_string) = left_prompt_string { if let Some(prompt_string) = left_prompt_string {
Some(format!( Some(format!(
"{}{}{}", "{PRE_PROMPT_MARKER}{prompt_string}{POST_PROMPT_MARKER}"
PRE_PROMPT_MARKER, prompt_string, POST_PROMPT_MARKER
)) ))
} else { } else {
left_prompt_string left_prompt_string

2
crates/nu-cli/src/reedline_config.rs
View file

@ -683,7 +683,7 @@ fn add_parsed_keybinding(
.filter(|num| matches!(num, 1..=20)) .filter(|num| matches!(num, 1..=20))
.ok_or(ShellError::UnsupportedConfigValue( .ok_or(ShellError::UnsupportedConfigValue(
"(f1|f2|...|f20)".to_string(), "(f1|f2|...|f20)".to_string(),
format!("unknown function key: {}", c), format!("unknown function key: {c}"),
keybinding.keycode.span()?, keybinding.keycode.span()?,
))?; ))?;
KeyCode::F(fn_num) KeyCode::F(fn_num)

10
crates/nu-cli/src/repl.rs
View file

@ -125,7 +125,7 @@ pub fn evaluate_repl(
if show_banner { if show_banner {
let banner = get_banner(engine_state, stack); let banner = get_banner(engine_state, stack);
if use_ansi { if use_ansi {
println!("{}", banner); println!("{banner}");
} else { } else {
println!("{}", nu_utils::strip_ansi_string_likely(banner)); println!("{}", nu_utils::strip_ansi_string_likely(banner));
} }
@ -143,7 +143,7 @@ pub fn evaluate_repl(
engine_state, engine_state,
stack, stack,
s.item.as_bytes(), s.item.as_bytes(),
&format!("entry #{}", entry_num), &format!("entry #{entry_num}"),
PipelineData::empty(), PipelineData::empty(),
); );
engine_state.merge_env(stack, get_guaranteed_cwd(engine_state, stack))?; engine_state.merge_env(stack, get_guaranteed_cwd(engine_state, stack))?;
@ -470,7 +470,7 @@ pub fn evaluate_repl(
engine_state, engine_state,
stack, stack,
s.as_bytes(), s.as_bytes(),
&format!("entry #{}", entry_num), &format!("entry #{entry_num}"),
PipelineData::empty(), PipelineData::empty(),
); );
} }
@ -528,7 +528,7 @@ pub fn evaluate_repl(
// ESC]0;stringBEL -- Set icon name and window title to string // ESC]0;stringBEL -- Set icon name and window title to string
// ESC]1;stringBEL -- Set icon name to string // ESC]1;stringBEL -- Set icon name to string
// ESC]2;stringBEL -- Set window title to string // ESC]2;stringBEL -- Set window title to string
run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?; run_ansi_sequence(&format!("\x1b]2;{maybe_abbrev_path}\x07"))?;
} }
run_ansi_sequence(RESET_APPLICATION_MODE)?; run_ansi_sequence(RESET_APPLICATION_MODE)?;
} }
@ -568,7 +568,7 @@ pub fn evaluate_repl(
Err(err) => { Err(err) => {
let message = err.to_string(); let message = err.to_string();
if !message.contains("duration") { if !message.contains("duration") {
eprintln!("Error: {:?}", err); eprintln!("Error: {err:?}");
// TODO: Identify possible error cases where a hard failure is preferable // TODO: Identify possible error cases where a hard failure is preferable
// Ignoring and reporting could hide bigger problems // Ignoring and reporting could hide bigger problems
// e.g. https://github.com/nushell/nushell/issues/6452 // e.g. https://github.com/nushell/nushell/issues/6452

5
crates/nu-cli/src/util.rs
View file

@ -44,7 +44,7 @@ fn gather_env_vars(
report_error( report_error(
&working_set, &working_set,
&ShellError::GenericError( &ShellError::GenericError(
format!("Environment variable was not captured: {}", env_str), format!("Environment variable was not captured: {env_str}"),
"".to_string(), "".to_string(),
None, None,
Some(msg.into()), Some(msg.into()),
@ -80,8 +80,7 @@ fn gather_env_vars(
"".to_string(), "".to_string(),
None, None,
Some(format!( Some(format!(
"Retrieving current directory failed: {:?} not a valid utf-8 path", "Retrieving current directory failed: {init_cwd:?} not a valid utf-8 path"
init_cwd
)), )),
Vec::new(), Vec::new(),
), ),

4
crates/nu-cli/tests/completions.rs
View file

@ -173,7 +173,7 @@ fn file_completions() {
let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack); let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
// Test completions for the current folder // Test completions for the current folder
let target_dir = format!("cp {}", dir_str); let target_dir = format!("cp {dir_str}");
let suggestions = completer.complete(&target_dir, target_dir.len()); let suggestions = completer.complete(&target_dir, target_dir.len());
// Create the expected values // Create the expected values
@ -494,7 +494,7 @@ fn folder_with_directorycompletions() {
let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack); let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
// Test completions for the current folder // Test completions for the current folder
let target_dir = format!("cd {}", dir_str); let target_dir = format!("cd {dir_str}");
let suggestions = completer.complete(&target_dir, target_dir.len()); let suggestions = completer.complete(&target_dir, target_dir.len());
// Create the expected values // Create the expected values

2
crates/nu-color-config/src/nu_style.rs
View file

@ -65,7 +65,7 @@ fn color_to_string(color: Color) -> Option<String> {
Color::White => Some(String::from("white")), Color::White => Some(String::from("white")),
Color::LightGray => Some(String::from("light_gray")), Color::LightGray => Some(String::from("light_gray")),
Color::Default => Some(String::from("default")), Color::Default => Some(String::from("default")),
Color::Rgb(r, g, b) => Some(format!("#{:X}{:X}{:X}", r, g, b)), Color::Rgb(r, g, b) => Some(format!("#{r:X}{g:X}{b:X}")),
Color::Fixed(_) => None, Color::Fixed(_) => None,
} }
} }

2
crates/nu-command/build.rs
View file

@ -4,7 +4,7 @@ fn main() -> shadow_rs::SdResult<()> {
// Look up the current Git commit ourselves instead of relying on shadow_rs, // Look up the current Git commit ourselves instead of relying on shadow_rs,
// because shadow_rs does it in a really slow-to-compile way (it builds libgit2) // because shadow_rs does it in a really slow-to-compile way (it builds libgit2)
let hash = get_git_hash().unwrap_or_default(); let hash = get_git_hash().unwrap_or_default();
println!("cargo:rustc-env=NU_COMMIT_HASH={}", hash); println!("cargo:rustc-env=NU_COMMIT_HASH={hash}");
shadow_rs::new() shadow_rs::new()
} }

3
crates/nu-command/src/bits/rotate_left.rs
View file

@ -106,8 +106,7 @@ where
error: ShellError::GenericError( error: ShellError::GenericError(
"Rotate left result beyond the range of 64 bit signed number".to_string(), "Rotate left result beyond the range of 64 bit signed number".to_string(),
format!( format!(
"{} of the specified number of bytes rotate left {} bits exceed limit", "{val} of the specified number of bytes rotate left {bits} bits exceed limit"
val, bits
), ),
Some(span), Some(span),
None, None,

3
crates/nu-command/src/bits/rotate_right.rs
View file

@ -110,8 +110,7 @@ where
error: ShellError::GenericError( error: ShellError::GenericError(
"Rotate right result beyond the range of 64 bit signed number".to_string(), "Rotate right result beyond the range of 64 bit signed number".to_string(),
format!( format!(
"{} of the specified number of bytes rotate right {} bits exceed limit", "{val} of the specified number of bytes rotate right {bits} bits exceed limit"
val, bits
), ),
Some(span), Some(span),
None, None,

8
crates/nu-command/src/bits/shift_left.rs
View file

@ -118,8 +118,7 @@ where
error: ShellError::GenericError( error: ShellError::GenericError(
"Shift left result beyond the range of 64 bit signed number".to_string(), "Shift left result beyond the range of 64 bit signed number".to_string(),
format!( format!(
"{} of the specified number of bytes shift left {} bits exceed limit", "{val} of the specified number of bytes shift left {bits} bits exceed limit"
val, bits
), ),
Some(span), Some(span),
None, None,
@ -131,10 +130,7 @@ where
None => Value::Error { None => Value::Error {
error: ShellError::GenericError( error: ShellError::GenericError(
"Shift left failed".to_string(), "Shift left failed".to_string(),
format!( format!("{val} shift left {bits} bits failed, you may shift too many bits"),
"{} shift left {} bits failed, you may shift too many bits",
val, bits
),
Some(span), Some(span),
None, None,
Vec::new(), Vec::new(),

8
crates/nu-command/src/bits/shift_right.rs
View file

@ -108,8 +108,7 @@ where
error: ShellError::GenericError( error: ShellError::GenericError(
"Shift right result beyond the range of 64 bit signed number".to_string(), "Shift right result beyond the range of 64 bit signed number".to_string(),
format!( format!(
"{} of the specified number of bytes shift right {} bits exceed limit", "{val} of the specified number of bytes shift right {bits} bits exceed limit"
val, bits
), ),
Some(span), Some(span),
None, None,
@ -121,10 +120,7 @@ where
None => Value::Error { None => Value::Error {
error: ShellError::GenericError( error: ShellError::GenericError(
"Shift right failed".to_string(), "Shift right failed".to_string(),
format!( format!("{val} shift right {bits} bits failed, you may shift too many bits"),
"{} shift right {} bits failed, you may shift too many bits",
val, bits
),
Some(span), Some(span),
None, None,
Vec::new(), Vec::new(),

2
crates/nu-command/src/charting/histogram.rs
View file

@ -166,7 +166,7 @@ fn run_histogram(
ShellError::UnsupportedInput( ShellError::UnsupportedInput(
"Since --column-name was not provided, only lists of hashable values are supported.".to_string(), "Since --column-name was not provided, only lists of hashable values are supported.".to_string(),
format!( format!(
"input type: {:?}", t "input type: {t:?}"
), ),
head_span, head_span,
span, span,

16
crates/nu-command/src/conversions/fmt.rs
View file

@ -103,31 +103,31 @@ fn fmt_it(num: i64, span: Span) -> Value {
let mut vals = vec![]; let mut vals = vec![];
cols.push("binary".into()); cols.push("binary".into());
vals.push(Value::string(format!("{:#b}", num), span)); vals.push(Value::string(format!("{num:#b}"), span));
cols.push("debug".into()); cols.push("debug".into());
vals.push(Value::string(format!("{:#?}", num), span)); vals.push(Value::string(format!("{num:#?}"), span));
cols.push("display".into()); cols.push("display".into());
vals.push(Value::string(format!("{}", num), span)); vals.push(Value::string(format!("{num}"), span));
cols.push("lowerexp".into()); cols.push("lowerexp".into());
vals.push(Value::string(format!("{:#e}", num), span)); vals.push(Value::string(format!("{num:#e}"), span));
cols.push("lowerhex".into()); cols.push("lowerhex".into());
vals.push(Value::string(format!("{:#x}", num), span)); vals.push(Value::string(format!("{num:#x}"), span));
cols.push("octal".into()); cols.push("octal".into());
vals.push(Value::string(format!("{:#o}", num), span)); vals.push(Value::string(format!("{num:#o}"), span));
// cols.push("pointer".into()); // cols.push("pointer".into());
// vals.push(Value::string(format!("{:#p}", &num), span)); // vals.push(Value::string(format!("{:#p}", &num), span));
cols.push("upperexp".into()); cols.push("upperexp".into());
vals.push(Value::string(format!("{:#E}", num), span)); vals.push(Value::string(format!("{num:#E}"), span));
cols.push("upperhex".into()); cols.push("upperhex".into());
vals.push(Value::string(format!("{:#X}", num), span)); vals.push(Value::string(format!("{num:#X}"), span));
Value::Record { cols, vals, span } Value::Record { cols, vals, span }
} }

2
crates/nu-command/src/conversions/into/datetime.rs
View file

@ -232,7 +232,7 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
return Value::Error { return Value::Error {
error: ShellError::UnsupportedInput( error: ShellError::UnsupportedInput(
"timestamp is out of range; it should between -8e+12 and 8e+12".to_string(), "timestamp is out of range; it should between -8e+12 and 8e+12".to_string(),
format!("timestamp is {:?}", ts), format!("timestamp is {ts:?}"),
head, head,
// Again, can safely unwrap this from here on // Again, can safely unwrap this from here on
input.expect_span(), input.expect_span(),

3
crates/nu-command/src/conversions/into/int.rs
View file

@ -367,8 +367,7 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
"string".to_string(), "string".to_string(),
span, span,
Some(format!( Some(format!(
r#"string "{}" does not represent a valid integer"#, r#"string "{trimmed}" does not represent a valid integer"#
trimmed
)), )),
)), )),
}, },

2
crates/nu-command/src/conversions/into/string.rs
View file

@ -206,7 +206,7 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
if decimals { if decimals {
let decimal_value = digits.unwrap_or(2) as usize; let decimal_value = digits.unwrap_or(2) as usize;
Value::String { Value::String {
val: format!("{:.*}", decimal_value, val), val: format!("{val:.decimal_value$}"),
span, span,
} }
} else { } else {

2
crates/nu-command/src/core_commands/ast.rs
View file

@ -41,7 +41,7 @@ impl Command for Ast {
let mut working_set = StateWorkingSet::new(engine_state); let mut working_set = StateWorkingSet::new(engine_state);
let (output, err) = parse(&mut working_set, None, pipeline.item.as_bytes(), false, &[]); let (output, err) = parse(&mut working_set, None, pipeline.item.as_bytes(), false, &[]);
eprintln!("output: {:#?}\nerror: {:#?}", output, err); eprintln!("output: {output:#?}\nerror: {err:#?}");
Ok(PipelineData::empty()) Ok(PipelineData::empty())
} }

2
crates/nu-command/src/core_commands/help.rs
View file

@ -195,7 +195,7 @@ pub fn highlight_search_string(
needle: &str, needle: &str,
string_style: &Style, string_style: &Style,
) -> Result<String, ShellError> { ) -> Result<String, ShellError> {
let regex_string = format!("(?i){}", needle); let regex_string = format!("(?i){needle}");
let regex = match Regex::new(&regex_string) { let regex = match Regex::new(&regex_string) {
Ok(regex) => regex, Ok(regex) => regex,
Err(err) => { Err(err) => {

20
crates/nu-command/src/database/commands/into_sqlite.rs
View file

@ -117,7 +117,7 @@ fn action(
let table_columns_creation = columns let table_columns_creation = columns
.iter() .iter()
.map(|(name, sql_type)| format!("{} {}", name, sql_type)) .map(|(name, sql_type)| format!("{name} {sql_type}"))
.join(","); .join(",");
// get the values // get the values
@ -156,10 +156,8 @@ fn action(
let conn = open_sqlite_db(Path::new(&file.item), file.span)?; let conn = open_sqlite_db(Path::new(&file.item), file.span)?;
// create a string for sql table creation // create a string for sql table creation
let create_statement = format!( let create_statement =
"CREATE TABLE IF NOT EXISTS {} ({})", format!("CREATE TABLE IF NOT EXISTS {table_name} ({table_columns_creation})");
table_name, table_columns_creation
);
// prepare the string as a sqlite statement // prepare the string as a sqlite statement
let mut stmt = conn.prepare(&create_statement).map_err(|e| { let mut stmt = conn.prepare(&create_statement).map_err(|e| {
@ -191,7 +189,7 @@ fn action(
// ('dd', 'ee', 'ff') // ('dd', 'ee', 'ff')
// create the string for inserting data into the table // create the string for inserting data into the table
let insert_statement = format!("INSERT INTO {} VALUES {}", table_name, table_values); let insert_statement = format!("INSERT INTO {table_name} VALUES {table_values}");
// prepare the string as a sqlite statement // prepare the string as a sqlite statement
let mut stmt = conn.prepare(&insert_statement).map_err(|e| { let mut stmt = conn.prepare(&insert_statement).map_err(|e| {
@ -264,13 +262,13 @@ fn nu_value_to_string(value: Value, separator: &str) -> String {
.join(separator), .join(separator),
Value::LazyRecord { val, .. } => match val.collect() { Value::LazyRecord { val, .. } => match val.collect() {
Ok(val) => nu_value_to_string(val, separator), Ok(val) => nu_value_to_string(val, separator),
Err(error) => format!("{:?}", error), Err(error) => format!("{error:?}"),
}, },
Value::Block { val, .. } => format!("<Block {}>", val), Value::Block { val, .. } => format!("<Block {val}>"),
Value::Closure { val, .. } => format!("<Closure {}>", val), Value::Closure { val, .. } => format!("<Closure {val}>"),
Value::Nothing { .. } => String::new(), Value::Nothing { .. } => String::new(),
Value::Error { error } => format!("{:?}", error), Value::Error { error } => format!("{error:?}"),
Value::Binary { val, .. } => format!("{:?}", val), Value::Binary { val, .. } => format!("{val:?}"),
Value::CellPath { val, .. } => val.into_string(), Value::CellPath { val, .. } => val.into_string(),
Value::CustomValue { val, .. } => val.value_string(), Value::CustomValue { val, .. } => val.value_string(),
} }

4
crates/nu-command/src/database/values/sqlite.rs
View file

@ -364,7 +364,7 @@ fn read_single_table(
call_span: Span, call_span: Span,
ctrlc: Option<Arc<AtomicBool>>, ctrlc: Option<Arc<AtomicBool>>,
) -> Result<Value, rusqlite::Error> { ) -> Result<Value, rusqlite::Error> {
let stmt = conn.prepare(&format!("SELECT * FROM {}", table_name))?; let stmt = conn.prepare(&format!("SELECT * FROM {table_name}"))?;
prepared_statement_to_nu_list(stmt, call_span, ctrlc) prepared_statement_to_nu_list(stmt, call_span, ctrlc)
} }
@ -426,7 +426,7 @@ fn read_entire_sqlite_db(
let table_name: String = row?; let table_name: String = row?;
table_names.push(table_name.clone()); table_names.push(table_name.clone());
let table_stmt = conn.prepare(&format!("select * from [{}]", table_name))?; let table_stmt = conn.prepare(&format!("select * from [{table_name}]"))?;
let rows = prepared_statement_to_nu_list(table_stmt, call_span, ctrlc.clone())?; let rows = prepared_statement_to_nu_list(table_stmt, call_span, ctrlc.clone())?;
tables.push(rows); tables.push(rows);
} }

2
crates/nu-command/src/date/format.rs
View file

@ -126,7 +126,7 @@ where
.unwrap_or(Locale::en_US); .unwrap_or(Locale::en_US);
let format = date_time.format_localized(formatter, locale); let format = date_time.format_localized(formatter, locale);
match formatter_buf.write_fmt(format_args!("{}", format)) { match formatter_buf.write_fmt(format_args!("{format}")) {
Ok(_) => Value::String { Ok(_) => Value::String {
val: formatter_buf, val: formatter_buf,
span, span,

2
crates/nu-command/src/default_context.rs
View file

@ -495,7 +495,7 @@ pub fn create_default_context() -> EngineState {
}; };
if let Err(err) = engine_state.merge_delta(delta) { if let Err(err) = engine_state.merge_delta(delta) {
eprintln!("Error creating default context: {:?}", err); eprintln!("Error creating default context: {err:?}");
} }
engine_state engine_state

4
crates/nu-command/src/env/config/config_reset.rs vendored
View file

@ -79,7 +79,7 @@ impl Command for ConfigReset {
} }
} }
if let Ok(mut file) = std::fs::File::create(nu_config) { if let Ok(mut file) = std::fs::File::create(nu_config) {
if writeln!(&mut file, "{}", config_file).is_err() { if writeln!(&mut file, "{config_file}").is_err() {
return Err(ShellError::FileNotFoundCustom( return Err(ShellError::FileNotFoundCustom(
"config.nu could not be written to".into(), "config.nu could not be written to".into(),
span, span,
@ -102,7 +102,7 @@ impl Command for ConfigReset {
} }
} }
if let Ok(mut file) = std::fs::File::create(env_config) { if let Ok(mut file) = std::fs::File::create(env_config) {
if writeln!(&mut file, "{}", config_file).is_err() { if writeln!(&mut file, "{config_file}").is_err() {
return Err(ShellError::FileNotFoundCustom( return Err(ShellError::FileNotFoundCustom(
"env.nu could not be written to".into(), "env.nu could not be written to".into(),
span, span,

2
crates/nu-command/src/env/env_command.rs vendored
View file

@ -54,7 +54,7 @@ impl Command for Env {
vals.push(Value::string(name, span)); vals.push(Value::string(name, span));
cols.push("type".into()); cols.push("type".into());
vals.push(Value::string(format!("{}", val_type), span)); vals.push(Value::string(format!("{val_type}"), span));
cols.push("value".into()); cols.push("value".into());
vals.push(val); vals.push(val);

4
crates/nu-command/src/example_test.rs
View file

@ -251,7 +251,7 @@ mod test_examples {
{:?}", {:?}",
declared_type_transformations declared_type_transformations
.difference(&witnessed_type_transformations) .difference(&witnessed_type_transformations)
.map(|(s1, s2)| format!("{} -> {}", s1, s2)) .map(|(s1, s2)| format!("{s1} -> {s2}"))
.join(", ") .join(", ")
); );
} }
@ -273,7 +273,7 @@ mod test_examples {
nu_parser::parse(&mut working_set, None, contents.as_bytes(), false, &[]); nu_parser::parse(&mut working_set, None, contents.as_bytes(), false, &[]);
if let Some(err) = err { if let Some(err) = err {
panic!("test parse error in `{}`: {:?}", contents, err) panic!("test parse error in `{contents}`: {err:?}")
} }
(output, working_set.render()) (output, working_set.render())

13
crates/nu-command/src/filesystem/cd.rs
View file

@ -93,14 +93,14 @@ impl Command for Cd {
Err(e) => { Err(e) => {
return Err(ShellError::DirectoryNotFound( return Err(ShellError::DirectoryNotFound(
v.span, v.span,
Some(format!("IO Error: {:?}", e)), Some(format!("IO Error: {e:?}")),
)) ))
} }
} }
} else { } else {
return Err(ShellError::DirectoryNotFound( return Err(ShellError::DirectoryNotFound(
v.span, v.span,
Some(format!("IO Error: {:?}", e1)), Some(format!("IO Error: {e1:?}")),
)); ));
} }
} }
@ -123,7 +123,7 @@ impl Command for Cd {
Err(e) => { Err(e) => {
return Err(ShellError::DirectoryNotFound( return Err(ShellError::DirectoryNotFound(
v.span, v.span,
Some(format!("IO Error: {:?}", e)), Some(format!("IO Error: {e:?}")),
)) ))
} }
}; };
@ -142,14 +142,14 @@ impl Command for Cd {
Err(e) => { Err(e) => {
return Err(ShellError::DirectoryNotFound( return Err(ShellError::DirectoryNotFound(
v.span, v.span,
Some(format!("IO Error: {:?}", e)), Some(format!("IO Error: {e:?}")),
)) ))
} }
} }
} else { } else {
return Err(ShellError::DirectoryNotFound( return Err(ShellError::DirectoryNotFound(
v.span, v.span,
Some(format!("IO Error: {:?}", e1)), Some(format!("IO Error: {e1:?}")),
)); ));
} }
} }
@ -197,8 +197,7 @@ impl Command for Cd {
Ok(PipelineData::empty()) Ok(PipelineData::empty())
} }
PermissionResult::PermissionDenied(reason) => Err(ShellError::IOError(format!( PermissionResult::PermissionDenied(reason) => Err(ShellError::IOError(format!(
"Cannot change directory to {}: {}", "Cannot change directory to {path}: {reason}"
path, reason
))), ))),
} }
} }

3
crates/nu-command/src/filesystem/cp.rs
View file

@ -168,8 +168,7 @@ impl Command for Cp {
canonicalize_with(dst.as_path(), &current_dir_path).unwrap_or(dst); canonicalize_with(dst.as_path(), &current_dir_path).unwrap_or(dst);
let res = if src == dst { let res = if src == dst {
let message = format!( let message = format!(
"src {:?} and dst {:?} are identical(not copied)", "src {source:?} and dst {destination:?} are identical(not copied)"
source, destination
); );
return Err(ShellError::GenericError( return Err(ShellError::GenericError(

2
crates/nu-command/src/filesystem/glob.rs
View file

@ -145,7 +145,7 @@ impl Command for Glob {
Err(e) => { Err(e) => {
return Err(ShellError::GenericError( return Err(ShellError::GenericError(
"error with glob pattern".to_string(), "error with glob pattern".to_string(),
format!("{}", e), format!("{e}"),
Some(glob_pattern.span), Some(glob_pattern.span),
None, None,
Vec::new(), Vec::new(),

2
crates/nu-command/src/filesystem/mkdir.rs
View file

@ -70,7 +70,7 @@ impl Command for Mkdir {
if let Err(reason) = dir_res { if let Err(reason) = dir_res {
return Err(ShellError::CreateNotPossible( return Err(ShellError::CreateNotPossible(
format!("failed to create directory: {}", reason), format!("failed to create directory: {reason}"),
call.positional_nth(i) call.positional_nth(i)
.expect("already checked through directories") .expect("already checked through directories")
.span, .span,

11
crates/nu-command/src/filesystem/mv.rs
View file

@ -290,7 +290,7 @@ fn move_file(
); );
if let Err(e) = interaction { if let Err(e) = interaction {
return Err(ShellError::GenericError( return Err(ShellError::GenericError(
format!("Error during interaction: {:}", e), format!("Error during interaction: {e:}"),
"could not move".into(), "could not move".into(),
None, None,
None, None,
@ -325,10 +325,10 @@ fn move_item(from: &Path, from_span: Span, to: &Path) -> Result<(), ShellError>
Err(e) => { Err(e) => {
let error_kind = match e.kind { let error_kind = match e.kind {
fs_extra::error::ErrorKind::Io(io) => { fs_extra::error::ErrorKind::Io(io) => {
format!("I/O error: {}", io) format!("I/O error: {io}")
} }
fs_extra::error::ErrorKind::StripPrefix(sp) => { fs_extra::error::ErrorKind::StripPrefix(sp) => {
format!("Strip prefix error: {}", sp) format!("Strip prefix error: {sp}")
} }
fs_extra::error::ErrorKind::OsString(os) => { fs_extra::error::ErrorKind::OsString(os) => {
format!("OsString error: {:?}", os.to_str()) format!("OsString error: {:?}", os.to_str())
@ -336,10 +336,7 @@ fn move_item(from: &Path, from_span: Span, to: &Path) -> Result<(), ShellError>
_ => e.to_string(), _ => e.to_string(),
}; };
Err(ShellError::GenericError( Err(ShellError::GenericError(
format!( format!("Could not move {from:?} to {to:?}. Error Kind: {error_kind}"),
"Could not move {:?} to {:?}. Error Kind: {}",
from, to, error_kind
),
"could not move".into(), "could not move".into(),
Some(from_span), Some(from_span),
None, None,

4
crates/nu-command/src/filesystem/open.rs
View file

@ -156,7 +156,7 @@ impl Command for Open {
}; };
if let Some(ext) = ext { if let Some(ext) = ext {
match engine_state.find_decl(format!("from {}", ext).as_bytes(), &[]) { match engine_state.find_decl(format!("from {ext}").as_bytes(), &[]) {
Some(converter_id) => { Some(converter_id) => {
let decl = engine_state.get_decl(converter_id); let decl = engine_state.get_decl(converter_id);
if let Some(block_id) = decl.get_block_id() { if let Some(block_id) = decl.get_block_id() {
@ -167,7 +167,7 @@ impl Command for Open {
} }
.map_err(|inner| { .map_err(|inner| {
ShellError::GenericError( ShellError::GenericError(
format!("Error while parsing as {}", ext), format!("Error while parsing as {ext}"),
format!("Could not parse '{}' with `from {}`", path.display(), ext), format!("Could not parse '{}' with `from {}`", path.display(), ext),
Some(arg_span), Some(arg_span),
Some(format!("Check out `help from {}` or `help from` for more options or open raw data with `open --raw '{}'`", ext, path.display())), Some(format!("Check out `help from {}` or `help from` for more options or open raw data with `open --raw '{}'`", ext, path.display())),

6
crates/nu-command/src/filesystem/rm.rs
View file

@ -318,7 +318,7 @@ fn rm(
); );
if let Err(e) = interaction { if let Err(e) = interaction {
return Err(ShellError::GenericError( return Err(ShellError::GenericError(
format!("Error during interaction: {:}", e), format!("Error during interaction: {e:}"),
"could not move".into(), "could not move".into(),
None, None,
None, None,
@ -375,7 +375,7 @@ fn rm(
Ok(()) Ok(())
} else if trash || (rm_always_trash && !permanent) { } else if trash || (rm_always_trash && !permanent) {
trash::delete(&f).map_err(|e: trash::Error| { trash::delete(&f).map_err(|e: trash::Error| {
Error::new(ErrorKind::Other, format!("{:?}\nTry '--trash' flag", e)) Error::new(ErrorKind::Other, format!("{e:?}\nTry '--trash' flag"))
}) })
} else if metadata.is_file() || is_socket || is_fifo { } else if metadata.is_file() || is_socket || is_fifo {
std::fs::remove_file(&f) std::fs::remove_file(&f)
@ -403,7 +403,7 @@ fn rm(
} }
if let Err(e) = result { if let Err(e) = result {
let msg = format!("Could not delete because: {:}", e); let msg = format!("Could not delete because: {e:}");
Value::Error { Value::Error {
error: ShellError::GenericError( error: ShellError::GenericError(
msg, msg,

2
crates/nu-command/src/filesystem/save.rs
View file

@ -215,7 +215,7 @@ fn convert_to_extension(
input: PipelineData, input: PipelineData,
span: Span, span: Span,
) -> Result<Vec<u8>, ShellError> { ) -> Result<Vec<u8>, ShellError> {
let converter = engine_state.find_decl(format!("to {}", extension).as_bytes(), &[]); let converter = engine_state.find_decl(format!("to {extension}").as_bytes(), &[]);
let output = match converter { let output = match converter {
Some(converter_id) => { Some(converter_id) => {

8
crates/nu-command/src/filesystem/touch.rs
View file

@ -137,7 +137,7 @@ impl Command for Touch {
if let Err(err) = OpenOptions::new().write(true).create(true).open(&item) { if let Err(err) = OpenOptions::new().write(true).create(true).open(&item) {
return Err(ShellError::CreateNotPossible( return Err(ShellError::CreateNotPossible(
format!("Failed to create file: {}", err), format!("Failed to create file: {err}"),
call.positional_nth(index) call.positional_nth(index)
.expect("already checked positional") .expect("already checked positional")
.span, .span,
@ -151,7 +151,7 @@ impl Command for Touch {
FileTime::from_system_time(date.expect("should be a valid date").into()), FileTime::from_system_time(date.expect("should be a valid date").into()),
) { ) {
return Err(ShellError::ChangeModifiedTimeNotPossible( return Err(ShellError::ChangeModifiedTimeNotPossible(
format!("Failed to change the modified time: {}", err), format!("Failed to change the modified time: {err}"),
call.positional_nth(index) call.positional_nth(index)
.expect("already checked positional") .expect("already checked positional")
.span, .span,
@ -170,7 +170,7 @@ impl Command for Touch {
), ),
) { ) {
return Err(ShellError::ChangeAccessTimeNotPossible( return Err(ShellError::ChangeAccessTimeNotPossible(
format!("Failed to change the access time: {}", err), format!("Failed to change the access time: {err}"),
call.positional_nth(index) call.positional_nth(index)
.expect("already checked positional") .expect("already checked positional")
.span, .span,
@ -183,7 +183,7 @@ impl Command for Touch {
FileTime::from_system_time(date.expect("should be a valid date").into()), FileTime::from_system_time(date.expect("should be a valid date").into()),
) { ) {
return Err(ShellError::ChangeAccessTimeNotPossible( return Err(ShellError::ChangeAccessTimeNotPossible(
format!("Failed to change the access time: {}", err), format!("Failed to change the access time: {err}"),
call.positional_nth(index) call.positional_nth(index)
.expect("already checked positional") .expect("already checked positional")
.span, .span,

4
crates/nu-command/src/filesystem/watch.rs
View file

@ -79,7 +79,7 @@ impl Command for Watch {
Err(e) => { Err(e) => {
return Err(ShellError::DirectoryNotFound( return Err(ShellError::DirectoryNotFound(
path_arg.span, path_arg.span,
Some(format!("IO Error: {:?}", e)), Some(format!("IO Error: {e:?}")),
)) ))
} }
}; };
@ -227,7 +227,7 @@ impl Command for Watch {
match rx.recv_timeout(CHECK_CTRL_C_FREQUENCY) { match rx.recv_timeout(CHECK_CTRL_C_FREQUENCY) {
Ok(event) => { Ok(event) => {
if verbose { if verbose {
eprintln!("{:?}", event); eprintln!("{event:?}");
} }
let handler_result = match event { let handler_result = match event {
DebouncedEvent::Create(path) => event_handler("Create", path, None), DebouncedEvent::Create(path) => event_handler("Create", path, None),

2
crates/nu-command/src/filters/find.rs
View file

@ -186,7 +186,7 @@ fn find_with_regex(
let regex = flags.to_string() + regex.as_str(); let regex = flags.to_string() + regex.as_str();
let re = Regex::new(regex.as_str()) let re = Regex::new(regex.as_str())
.map_err(|e| ShellError::TypeMismatch(format!("invalid regex: {}", e), span))?; .map_err(|e| ShellError::TypeMismatch(format!("invalid regex: {e}"), span))?;
input.filter( input.filter(
move |value| match value { move |value| match value {

10
crates/nu-command/src/filters/flatten.rs
View file

@ -213,7 +213,7 @@ fn flat_value(columns: &[CellPath], item: &Value, _name_tag: Span, all: bool) ->
cols.iter().enumerate().for_each(|(idx, inner_record_col)| { cols.iter().enumerate().for_each(|(idx, inner_record_col)| {
if out.contains_key(inner_record_col) { if out.contains_key(inner_record_col) {
out.insert( out.insert(
format!("{}_{}", column, inner_record_col), format!("{column}_{inner_record_col}"),
vals[idx].clone(), vals[idx].clone(),
); );
} else { } else {
@ -221,7 +221,7 @@ fn flat_value(columns: &[CellPath], item: &Value, _name_tag: Span, all: bool) ->
} }
}) })
} else if out.contains_key(column) { } else if out.contains_key(column) {
out.insert(format!("{}_{}", column, column), value.clone()); out.insert(format!("{column}_{column}"), value.clone());
} else { } else {
out.insert(column.to_string(), value.clone()); out.insert(column.to_string(), value.clone());
} }
@ -261,7 +261,7 @@ fn flat_value(columns: &[CellPath], item: &Value, _name_tag: Span, all: bool) ->
parent_column_index: column_index, parent_column_index: column_index,
}); });
} else if out.contains_key(column) { } else if out.contains_key(column) {
out.insert(format!("{}_{}", column, column), value.clone()); out.insert(format!("{column}_{column}"), value.clone());
} else { } else {
out.insert(column.to_string(), value.clone()); out.insert(column.to_string(), value.clone());
} }
@ -358,7 +358,7 @@ fn flat_value(columns: &[CellPath], item: &Value, _name_tag: Span, all: bool) ->
if index == parent_column_index { if index == parent_column_index {
for (col, val) in inner_cols.iter().zip(inner_vals.iter()) { for (col, val) in inner_cols.iter().zip(inner_vals.iter()) {
if record_cols.contains(col) { if record_cols.contains(col) {
record_cols.push(format!("{}_{}", parent_column_name, col)); record_cols.push(format!("{parent_column_name}_{col}"));
} else { } else {
record_cols.push(col.to_string()); record_cols.push(col.to_string());
} }
@ -375,7 +375,7 @@ fn flat_value(columns: &[CellPath], item: &Value, _name_tag: Span, all: bool) ->
if index == parent_column_index { if index == parent_column_index {
for (col, val) in inner_cols.iter().zip(inner_vals.iter()) { for (col, val) in inner_cols.iter().zip(inner_vals.iter()) {
if record_cols.contains(col) { if record_cols.contains(col) {
record_cols.push(format!("{}_{}", parent_column_name, col)); record_cols.push(format!("{parent_column_name}_{col}"));
} else { } else {
record_cols.push(col.to_string()); record_cols.push(col.to_string());
} }

2
crates/nu-command/src/filters/headers.rs
View file

@ -151,7 +151,7 @@ fn extract_headers(value: &Value, config: &Config) -> Result<Vec<String>, ShellE
.map(|(idx, value)| { .map(|(idx, value)| {
let col = value.into_string("", config); let col = value.into_string("", config);
if col.is_empty() { if col.is_empty() {
format!("column{}", idx) format!("column{idx}")
} else { } else {
col col
} }

2
crates/nu-command/src/filters/rotate.rs
View file

@ -269,7 +269,7 @@ pub fn rotate(
let mut new_column_names = { let mut new_column_names = {
let mut res = vec![]; let mut res = vec![];
for idx in 0..(*total_rows + 1) { for idx in 0..(*total_rows + 1) {
res.push(format!("column{}", idx)); res.push(format!("column{idx}"));
} }
res.to_vec() res.to_vec()
}; };

2
crates/nu-command/src/filters/skip/skip_.rs
View file

@ -80,7 +80,7 @@ impl Command for Skip {
let n: usize = match n { let n: usize = match n {
Some(Value::Int { val, span }) => val.try_into().map_err(|err| { Some(Value::Int { val, span }) => val.try_into().map_err(|err| {
ShellError::TypeMismatch( ShellError::TypeMismatch(
format!("Could not convert {} to unsigned integer: {}", val, err), format!("Could not convert {val} to unsigned integer: {err}"),
span, span,
) )
})?, })?,

2
crates/nu-command/src/filters/transpose.rs
View file

@ -231,7 +231,7 @@ pub fn transpose(
if let Some(name) = args.rest.get(i) { if let Some(name) = args.rest.get(i) {
headers.push(name.item.clone()) headers.push(name.item.clone())
} else { } else {
headers.push(format!("column{}", i)); headers.push(format!("column{i}"));
} }
} }
} }

2
crates/nu-command/src/formats/from/delimited.rs
View file

@ -17,7 +17,7 @@ fn from_delimited_string_to_value(
let headers = if noheaders { let headers = if noheaders {
(1..=reader.headers()?.len()) (1..=reader.headers()?.len())
.map(|i| format!("column{}", i)) .map(|i| format!("column{i}"))
.collect::<Vec<String>>() .collect::<Vec<String>>()
} else { } else {
reader.headers()?.iter().map(String::from).collect() reader.headers()?.iter().map(String::from).collect()

2
crates/nu-command/src/formats/from/ics.rs
View file

@ -113,7 +113,7 @@ fn from_ics(input: PipelineData, head: Span) -> Result<PipelineData, ShellError>
Ok(c) => output.push(calendar_to_value(c, head)), Ok(c) => output.push(calendar_to_value(c, head)),
Err(e) => output.push(Value::Error { Err(e) => output.push(Value::Error {
error: ShellError::UnsupportedInput( error: ShellError::UnsupportedInput(
format!("input cannot be parsed as .ics ({})", e), format!("input cannot be parsed as .ics ({e})"),
"value originates from here".into(), "value originates from here".into(),
head, head,
span, span,

2
crates/nu-command/src/formats/from/ini.rs
View file

@ -77,7 +77,7 @@ pub fn from_ini_string_to_value(
Ok(Value::Record { cols, vals, span }) Ok(Value::Record { cols, vals, span })
} }
Err(err) => Err(ShellError::UnsupportedInput( Err(err) => Err(ShellError::UnsupportedInput(
format!("Could not load ini: {}", err), format!("Could not load ini: {err}"),
"value originates from here".into(), "value originates from here".into(),
span, span,
val_span, val_span,

2
crates/nu-command/src/formats/from/json.rs
View file

@ -183,7 +183,7 @@ fn convert_string_to_value(string_input: String, span: Span) -> Result<Value, Sh
)) ))
} }
x => Err(ShellError::CantConvert( x => Err(ShellError::CantConvert(
format!("structured json data ({})", x), format!("structured json data ({x})"),
"string".into(), "string".into(),
span, span,
None, None,

2
crates/nu-command/src/formats/from/ods.rs
View file

@ -149,7 +149,7 @@ fn from_ods(
_ => Value::nothing(head), _ => Value::nothing(head),
}; };
row_output.insert(format!("column{}", i), value); row_output.insert(format!("column{i}"), value);
} }
let (cols, vals) = let (cols, vals) =

2
crates/nu-command/src/formats/from/ssv.rs
View file

@ -197,7 +197,7 @@ fn parse_separated_columns<'a>(
let num_columns = ls.iter().map(|r| r.len()).max().unwrap_or(0); let num_columns = ls.iter().map(|r| r.len()).max().unwrap_or(0);
let headers = (1..=num_columns) let headers = (1..=num_columns)
.map(|i| format!("column{}", i)) .map(|i| format!("column{i}"))
.collect::<Vec<String>>(); .collect::<Vec<String>>();
collect(headers, ls.into_iter(), separator) collect(headers, ls.into_iter(), separator)
}; };

2
crates/nu-command/src/formats/from/vcf.rs
View file

@ -123,7 +123,7 @@ fn from_vcf(input: PipelineData, head: Span) -> Result<PipelineData, ShellError>
Ok(c) => contact_to_value(c, head), Ok(c) => contact_to_value(c, head),
Err(e) => Value::Error { Err(e) => Value::Error {
error: ShellError::UnsupportedInput( error: ShellError::UnsupportedInput(
format!("input cannot be parsed as .vcf ({})", e), format!("input cannot be parsed as .vcf ({e})"),
"value originates from here".into(), "value originates from here".into(),
head, head,
span, span,

2
crates/nu-command/src/formats/from/xlsx.rs
View file

@ -148,7 +148,7 @@ fn from_xlsx(
_ => Value::nothing(head), _ => Value::nothing(head),
}; };
row_output.insert(format!("column{}", i), value); row_output.insert(format!("column{i}"), value);
} }
let (cols, vals) = let (cols, vals) =

4
crates/nu-command/src/formats/from/yaml.rs
View file

@ -120,7 +120,7 @@ fn convert_yaml_value_to_nu_value(
for (k, v) in t { for (k, v) in t {
// A ShellError that we re-use multiple times in the Mapping scenario // A ShellError that we re-use multiple times in the Mapping scenario
let err_unexpected_map = ShellError::UnsupportedInput( let err_unexpected_map = ShellError::UnsupportedInput(
format!("Unexpected YAML:\nKey: {:?}\nValue: {:?}", k, v), format!("Unexpected YAML:\nKey: {k:?}\nValue: {v:?}"),
"value originates from here".into(), "value originates from here".into(),
span, span,
val_span, val_span,
@ -189,7 +189,7 @@ pub fn from_yaml_string_to_value(
for document in serde_yaml::Deserializer::from_str(&s) { for document in serde_yaml::Deserializer::from_str(&s) {
let v: serde_yaml::Value = serde_yaml::Value::deserialize(document).map_err(|x| { let v: serde_yaml::Value = serde_yaml::Value::deserialize(document).map_err(|x| {
ShellError::UnsupportedInput( ShellError::UnsupportedInput(
format!("Could not load YAML: {}", x), format!("Could not load YAML: {x}"),
"value originates from here".into(), "value originates from here".into(),
span, span,
val_span, val_span,

6
crates/nu-command/src/formats/to/nuon.rs
View file

@ -55,7 +55,7 @@ pub fn value_to_string(v: &Value, span: Span) -> Result<String, ShellError> {
Value::Binary { val, .. } => { Value::Binary { val, .. } => {
let mut s = String::with_capacity(2 * val.len()); let mut s = String::with_capacity(2 * val.len());
for byte in val { for byte in val {
if write!(s, "{:02X}", byte).is_err() { if write!(s, "{byte:02X}").is_err() {
return Err(ShellError::UnsupportedInput( return Err(ShellError::UnsupportedInput(
"could not convert binary to string".into(), "could not convert binary to string".into(),
"value originates from here".into(), "value originates from here".into(),
@ -64,7 +64,7 @@ pub fn value_to_string(v: &Value, span: Span) -> Result<String, ShellError> {
)); ));
} }
} }
Ok(format!("0x[{}]", s)) Ok(format!("0x[{s}]"))
} }
Value::Block { .. } => Err(ShellError::UnsupportedInput( Value::Block { .. } => Err(ShellError::UnsupportedInput(
"blocks are currently not nuon-compatible".into(), "blocks are currently not nuon-compatible".into(),
@ -125,7 +125,7 @@ pub fn value_to_string(v: &Value, span: Span) -> Result<String, ShellError> {
.iter() .iter()
.map(|string| { .map(|string| {
if needs_quotes(string) { if needs_quotes(string) {
format!("\"{}\"", string) format!("\"{string}\"")
} else { } else {
string.to_string() string.to_string()
} }

10
crates/nu-command/src/formats/to/text.rs
View file

@ -143,13 +143,13 @@ fn local_into_string(value: Value, separator: &str, config: &Config) -> String {
.join(separator), .join(separator),
Value::LazyRecord { val, .. } => match val.collect() { Value::LazyRecord { val, .. } => match val.collect() {
Ok(val) => local_into_string(val, separator, config), Ok(val) => local_into_string(val, separator, config),
Err(error) => format!("{:?}", error), Err(error) => format!("{error:?}"),
}, },
Value::Block { val, .. } => format!("<Block {}>", val), Value::Block { val, .. } => format!("<Block {val}>"),
Value::Closure { val, .. } => format!("<Closure {}>", val), Value::Closure { val, .. } => format!("<Closure {val}>"),
Value::Nothing { .. } => String::new(), Value::Nothing { .. } => String::new(),
Value::Error { error } => format!("{:?}", error), Value::Error { error } => format!("{error:?}"),
Value::Binary { val, .. } => format!("{:?}", val), Value::Binary { val, .. } => format!("{val:?}"),
Value::CellPath { val, .. } => val.into_string(), Value::CellPath { val, .. } => val.into_string(),
Value::CustomValue { val, .. } => val.value_string(), Value::CustomValue { val, .. } => val.value_string(),
} }

2
crates/nu-command/src/hash/generic_digest.rs
View file

@ -131,7 +131,7 @@ where
} }
} else { } else {
Value::String { Value::String {
val: format!("{:x}", digest), val: format!("{digest:x}"),
span, span,
} }
} }

4
crates/nu-command/src/misc/tutor.rs
View file

@ -117,7 +117,7 @@ fn tutor(
let message = format!( let message = format!(
"You can find '{find}' in the following topics:\n\n{}\n\n{notes}", "You can find '{find}' in the following topics:\n\n{}\n\n{notes}",
results.into_iter().map(|x| format!("- {}", x)).join("\n") results.into_iter().map(|x| format!("- {x}")).join("\n")
); );
return Ok(display(&message, engine_state, stack, span)); return Ok(display(&message, engine_state, stack, span));
@ -126,7 +126,7 @@ fn tutor(
let results = search_space.map(|s| s.0[0].to_string()); let results = search_space.map(|s| s.0[0].to_string());
let message = format!( let message = format!(
"This tutorial contains the following topics:\n\n{}\n\n{notes}", "This tutorial contains the following topics:\n\n{}\n\n{notes}",
results.map(|x| format!("- {}", x)).join("\n") results.map(|x| format!("- {x}")).join("\n")
); );
return Ok(display(&message, engine_state, stack, span)); return Ok(display(&message, engine_state, stack, span));
} }

31
crates/nu-command/src/network/http/get.rs
View file

@ -167,17 +167,17 @@ fn helper(
let login = match (user, password) { let login = match (user, password) {
(Some(user), Some(password)) => { (Some(user), Some(password)) => {
let mut enc_str = String::new(); let mut enc_str = String::new();
base64_engine.encode_string(&format!("{}:{}", user, password), &mut enc_str); base64_engine.encode_string(&format!("{user}:{password}"), &mut enc_str);
Some(enc_str) Some(enc_str)
} }
(Some(user), _) => { (Some(user), _) => {
let mut enc_str = String::new(); let mut enc_str = String::new();
base64_engine.encode_string(&format!("{}:", user), &mut enc_str); base64_engine.encode_string(&format!("{user}:"), &mut enc_str);
Some(enc_str) Some(enc_str)
} }
(_, Some(password)) => { (_, Some(password)) => {
let mut enc_str = String::new(); let mut enc_str = String::new();
base64_engine.encode_string(&format!(":{}", password), &mut enc_str); base64_engine.encode_string(&format!(":{password}"), &mut enc_str);
Some(enc_str) Some(enc_str)
} }
_ => None, _ => None,
@ -200,7 +200,7 @@ fn helper(
} }
if let Some(login) = login { if let Some(login) = login {
request = request.header("Authorization", format!("Basic {}", login)); request = request.header("Authorization", format!("Basic {login}"));
} }
if let Some(headers) = headers { if let Some(headers) = headers {
@ -268,7 +268,7 @@ fn helper(
})?; })?;
let content_type = mime::Mime::from_str(content_type).map_err(|_| { let content_type = mime::Mime::from_str(content_type).map_err(|_| {
ShellError::GenericError( ShellError::GenericError(
format!("MIME type unknown: {}", content_type), format!("MIME type unknown: {content_type}"),
"".to_string(), "".to_string(),
None, None,
Some("given unknown MIME type".to_string()), Some("given unknown MIME type".to_string()),
@ -280,7 +280,7 @@ fn helper(
let path_extension = url::Url::parse(&requested_url) let path_extension = url::Url::parse(&requested_url)
.map_err(|_| { .map_err(|_| {
ShellError::GenericError( ShellError::GenericError(
format!("Cannot parse URL: {}", requested_url), format!("Cannot parse URL: {requested_url}"),
"".to_string(), "".to_string(),
None, None,
Some("cannot parse".to_string()), Some("cannot parse".to_string()),
@ -307,7 +307,7 @@ fn helper(
} }
if let Some(ext) = ext { if let Some(ext) = ext {
match engine_state.find_decl(format!("from {}", ext).as_bytes(), &[]) { match engine_state.find_decl(format!("from {ext}").as_bytes(), &[]) {
Some(converter_id) => engine_state.get_decl(converter_id).run( Some(converter_id) => engine_state.get_decl(converter_id).run(
engine_state, engine_state,
stack, stack,
@ -323,28 +323,25 @@ fn helper(
None => Ok(response_to_buffer(resp, engine_state, span)), None => Ok(response_to_buffer(resp, engine_state, span)),
}, },
Err(e) if e.is_timeout() => Err(ShellError::NetworkFailure( Err(e) if e.is_timeout() => Err(ShellError::NetworkFailure(
format!("Request to {} has timed out", requested_url), format!("Request to {requested_url} has timed out"),
span, span,
)), )),
Err(e) if e.is_status() => match e.status() { Err(e) if e.is_status() => match e.status() {
Some(err_code) if err_code == StatusCode::NOT_FOUND => Err(ShellError::NetworkFailure( Some(err_code) if err_code == StatusCode::NOT_FOUND => Err(ShellError::NetworkFailure(
format!("Requested file not found (404): {:?}", requested_url), format!("Requested file not found (404): {requested_url:?}"),
span, span,
)), )),
Some(err_code) if err_code == StatusCode::MOVED_PERMANENTLY => { Some(err_code) if err_code == StatusCode::MOVED_PERMANENTLY => {
Err(ShellError::NetworkFailure( Err(ShellError::NetworkFailure(
format!("Resource moved permanently (301): {:?}", requested_url), format!("Resource moved permanently (301): {requested_url:?}"),
span,
))
}
Some(err_code) if err_code == StatusCode::BAD_REQUEST => {
Err(ShellError::NetworkFailure(
format!("Bad request (400) to {:?}", requested_url),
span, span,
)) ))
} }
Some(err_code) if err_code == StatusCode::BAD_REQUEST => Err(
ShellError::NetworkFailure(format!("Bad request (400) to {requested_url:?}"), span),
),
Some(err_code) if err_code == StatusCode::FORBIDDEN => Err(ShellError::NetworkFailure( Some(err_code) if err_code == StatusCode::FORBIDDEN => Err(ShellError::NetworkFailure(
format!("Access forbidden (403) to {:?}", requested_url), format!("Access forbidden (403) to {requested_url:?}"),
span, span,
)), )),
_ => Err(ShellError::NetworkFailure( _ => Err(ShellError::NetworkFailure(

29
crates/nu-command/src/network/http/post.rs
View file

@ -174,7 +174,7 @@ fn helper(
return Err(ShellError::UnsupportedInput( return Err(ShellError::UnsupportedInput(
"Incomplete or incorrect URL. Expected a full URL, e.g., https://www.example.com" "Incomplete or incorrect URL. Expected a full URL, e.g., https://www.example.com"
.to_string(), .to_string(),
format!("value: '{:?}'", requested_url), format!("value: '{requested_url:?}'"),
call.head, call.head,
span, span,
)); ));
@ -190,12 +190,12 @@ fn helper(
let login = match (user, password) { let login = match (user, password) {
(Some(user), Some(password)) => { (Some(user), Some(password)) => {
let mut enc_str = String::new(); let mut enc_str = String::new();
base64_engine.encode_string(&format!("{}:{}", user, password), &mut enc_str); base64_engine.encode_string(&format!("{user}:{password}"), &mut enc_str);
Some(enc_str) Some(enc_str)
} }
(Some(user), _) => { (Some(user), _) => {
let mut enc_str = String::new(); let mut enc_str = String::new();
base64_engine.encode_string(&format!("{}:", user), &mut enc_str); base64_engine.encode_string(&format!("{user}:"), &mut enc_str);
Some(enc_str) Some(enc_str)
} }
_ => None, _ => None,
@ -249,7 +249,7 @@ fn helper(
request = request.header("Content-Length", val); request = request.header("Content-Length", val);
} }
if let Some(login) = login { if let Some(login) = login {
request = request.header("Authorization", format!("Basic {}", login)); request = request.header("Authorization", format!("Basic {login}"));
} }
if let Some(headers) = headers { if let Some(headers) = headers {
@ -317,7 +317,7 @@ fn helper(
})?; })?;
let content_type = mime::Mime::from_str(content_type).map_err(|_| { let content_type = mime::Mime::from_str(content_type).map_err(|_| {
ShellError::GenericError( ShellError::GenericError(
format!("MIME type unknown: {}", content_type), format!("MIME type unknown: {content_type}"),
"".to_string(), "".to_string(),
None, None,
Some("given unknown MIME type".to_string()), Some("given unknown MIME type".to_string()),
@ -329,7 +329,7 @@ fn helper(
let path_extension = url::Url::parse(&requested_url) let path_extension = url::Url::parse(&requested_url)
.map_err(|_| { .map_err(|_| {
ShellError::GenericError( ShellError::GenericError(
format!("Cannot parse URL: {}", requested_url), format!("Cannot parse URL: {requested_url}"),
"".to_string(), "".to_string(),
None, None,
Some("cannot parse".to_string()), Some("cannot parse".to_string()),
@ -354,7 +354,7 @@ fn helper(
return Ok(output); return Ok(output);
} }
if let Some(ext) = ext { if let Some(ext) = ext {
match engine_state.find_decl(format!("from {}", ext).as_bytes(), &[]) { match engine_state.find_decl(format!("from {ext}").as_bytes(), &[]) {
Some(converter_id) => engine_state.get_decl(converter_id).run( Some(converter_id) => engine_state.get_decl(converter_id).run(
engine_state, engine_state,
stack, stack,
@ -371,23 +371,20 @@ fn helper(
}, },
Err(e) if e.is_status() => match e.status() { Err(e) if e.is_status() => match e.status() {
Some(err_code) if err_code == StatusCode::NOT_FOUND => Err(ShellError::NetworkFailure( Some(err_code) if err_code == StatusCode::NOT_FOUND => Err(ShellError::NetworkFailure(
format!("Requested file not found (404): {:?}", requested_url), format!("Requested file not found (404): {requested_url:?}"),
span, span,
)), )),
Some(err_code) if err_code == StatusCode::MOVED_PERMANENTLY => { Some(err_code) if err_code == StatusCode::MOVED_PERMANENTLY => {
Err(ShellError::NetworkFailure( Err(ShellError::NetworkFailure(
format!("Resource moved permanently (301): {:?}", requested_url), format!("Resource moved permanently (301): {requested_url:?}"),
span,
))
}
Some(err_code) if err_code == StatusCode::BAD_REQUEST => {
Err(ShellError::NetworkFailure(
format!("Bad request (400) to {:?}", requested_url),
span, span,
)) ))
} }
Some(err_code) if err_code == StatusCode::BAD_REQUEST => Err(
ShellError::NetworkFailure(format!("Bad request (400) to {requested_url:?}"), span),
),
Some(err_code) if err_code == StatusCode::FORBIDDEN => Err(ShellError::NetworkFailure( Some(err_code) if err_code == StatusCode::FORBIDDEN => Err(ShellError::NetworkFailure(
format!("Access forbidden (403) to {:?}", requested_url), format!("Access forbidden (403) to {requested_url:?}"),
span, span,
)), )),
_ => Err(ShellError::NetworkFailure( _ => Err(ShellError::NetworkFailure(

22
crates/nu-command/src/network/url/join.rs
View file

@ -180,21 +180,21 @@ impl UrlComponents {
.iter() .iter()
.zip(vals.iter()) .zip(vals.iter())
.map(|(k, v)| match v.as_string() { .map(|(k, v)| match v.as_string() {
Ok(val) => Ok(format!("{}={}", k, val)), Ok(val) => Ok(format!("{k}={val}")),
Err(err) => Err(err), Err(err) => Err(err),
}) })
.collect::<Result<Vec<String>, ShellError>>()? .collect::<Result<Vec<String>, ShellError>>()?
.join("&"); .join("&");
qs = format!("?{}", qs); qs = format!("?{qs}");
if let Some(q) = self.query { if let Some(q) = self.query {
if q != qs { if q != qs {
// if query is present it means that also query_span is set. // if query is present it means that also query_span is set.
return Err(ShellError::IncompatibleParameters { return Err(ShellError::IncompatibleParameters {
left_message: format!("Mismatch, qs from params is: {}", qs), left_message: format!("Mismatch, qs from params is: {qs}"),
left_span: value.expect_span(), left_span: value.expect_span(),
right_message: format!("instead query is: {}", q), right_message: format!("instead query is: {q}"),
right_span: self.query_span.unwrap_or(Span::unknown()), right_span: self.query_span.unwrap_or(Span::unknown()),
}); });
} }
@ -241,7 +241,7 @@ impl UrlComponents {
path: Some(if s.starts_with('/') { path: Some(if s.starts_with('/') {
s s
} else { } else {
format!("/{}", s) format!("/{s}")
}), }),
..self ..self
}), }),
@ -250,16 +250,16 @@ impl UrlComponents {
if q != s { if q != s {
// if query is present it means that also params_span is set. // if query is present it means that also params_span is set.
return Err(ShellError::IncompatibleParameters { return Err(ShellError::IncompatibleParameters {
left_message: format!("Mismatch, query param is: {}", s), left_message: format!("Mismatch, query param is: {s}"),
left_span: value.expect_span(), left_span: value.expect_span(),
right_message: format!("instead qs from params is: {}", q), right_message: format!("instead qs from params is: {q}"),
right_span: self.params_span.unwrap_or(Span::unknown()), right_span: self.params_span.unwrap_or(Span::unknown()),
}); });
} }
} }
Ok(Self { Ok(Self {
query: Some(format!("?{}", s)), query: Some(format!("?{s}")),
query_span: Some(value.expect_span()), query_span: Some(value.expect_span()),
..self ..self
}) })
@ -268,7 +268,7 @@ impl UrlComponents {
fragment: Some(if s.starts_with('#') { fragment: Some(if s.starts_with('#') {
s s
} else { } else {
format!("#{}", s) format!("#{s}")
}), }),
..self ..self
}), }),
@ -285,7 +285,7 @@ impl UrlComponents {
if let Some(usr) = &self.username { if let Some(usr) = &self.username {
if let Some(pwd) = &self.password { if let Some(pwd) = &self.password {
user_and_pwd = format!("{}:{}@", usr, pwd); user_and_pwd = format!("{usr}:{pwd}@");
} }
} }
@ -311,7 +311,7 @@ impl UrlComponents {
user_and_pwd, user_and_pwd,
host_result?, host_result?,
self.port self.port
.map(|p| format!(":{}", p)) .map(|p| format!(":{p}"))
.as_deref() .as_deref()
.unwrap_or_default(), .unwrap_or_default(),
self.path.as_deref().unwrap_or_default(), self.path.as_deref().unwrap_or_default(),

3
crates/nu-command/src/path/join.rs
View file

@ -233,8 +233,7 @@ fn merge_record(
let allowed_cols = super::ALLOWED_COLUMNS.join(", "); let allowed_cols = super::ALLOWED_COLUMNS.join(", ");
return Err(ShellError::UnsupportedInput( return Err(ShellError::UnsupportedInput(
format!( format!(
"Column '{}' is not valid for a structured path. Allowed columns on this platform are: {}", "Column '{key}' is not valid for a structured path. Allowed columns on this platform are: {allowed_cols}"
key, allowed_cols
), ),
"value originates from here".into(), "value originates from here".into(),
head, head,

8
crates/nu-command/src/platform/ansi/ansi_.rs
View file

@ -682,13 +682,13 @@ Format: #
} }
let output = if escape && param_is_valid_string { let output = if escape && param_is_valid_string {
format!("\x1b[{}", code_string) format!("\x1b[{code_string}")
} else if osc && param_is_valid_string { } else if osc && param_is_valid_string {
// Operating system command aka osc ESC ] <- note the right brace, not left brace for osc // Operating system command aka osc ESC ] <- note the right brace, not left brace for osc
// OCS's need to end with either: // OCS's need to end with either:
// bel '\x07' char // bel '\x07' char
// string terminator aka st '\\' char // string terminator aka st '\\' char
format!("\x1b]{}", code_string) format!("\x1b]{code_string}")
} else if param_is_valid_string { } else if param_is_valid_string {
// parse hex colors like #00FF00 // parse hex colors like #00FF00
if code_string.starts_with('#') { if code_string.starts_with('#') {
@ -700,7 +700,7 @@ Format: #
Err(err) => { Err(err) => {
return Err(ShellError::GenericError( return Err(ShellError::GenericError(
"error parsing hex color".to_string(), "error parsing hex color".to_string(),
format!("{}", err), format!("{err}"),
Some(code.span()?), Some(code.span()?),
None, None,
Vec::new(), Vec::new(),
@ -738,7 +738,7 @@ Format: #
"attr" => nu_style.attr = Some(v.as_string()?), "attr" => nu_style.attr = Some(v.as_string()?),
_ => { _ => {
return Err(ShellError::IncompatibleParametersSingle( return Err(ShellError::IncompatibleParametersSingle(
format!("problem with key: {}", k), format!("problem with key: {k}"),
code.expect_span(), code.expect_span(),
)) ))
} }

2
crates/nu-command/src/platform/ansi/link.rs
View file

@ -146,7 +146,7 @@ fn process_value(value: &Value, text: &Option<String>, command_span: &Span) -> V
} }
fn add_osc_link(text: &str, link: &str) -> String { fn add_osc_link(text: &str, link: &str) -> String {
format!("\u{1b}]8;;{}\u{1b}\\{}\u{1b}]8;;\u{1b}\\", link, text) format!("\u{1b}]8;;{link}\u{1b}\\{text}\u{1b}]8;;\u{1b}\\")
} }
#[cfg(test)] #[cfg(test)]

4
crates/nu-command/src/platform/input.rs
View file

@ -57,7 +57,7 @@ impl Command for Input {
let _ = crossterm::terminal::enable_raw_mode(); let _ = crossterm::terminal::enable_raw_mode();
if let Some(prompt) = prompt { if let Some(prompt) = prompt {
print!("{}", prompt); print!("{prompt}");
let _ = std::io::stdout().flush(); let _ = std::io::stdout().flush();
} }
if let Some(c) = bytes_until.bytes().next() { if let Some(c) = bytes_until.bytes().next() {
@ -92,7 +92,7 @@ impl Command for Input {
} }
} else { } else {
if let Some(prompt) = prompt { if let Some(prompt) = prompt {
print!("{}", prompt); print!("{prompt}");
let _ = std::io::stdout().flush(); let _ = std::io::stdout().flush();
} }

14
crates/nu-command/src/platform/reedline_commands/keybindings_listen.rs
View file

@ -113,10 +113,10 @@ fn print_events_helper(event: Event) -> Result<Value, ShellError> {
"flags".into(), "flags".into(),
], ],
vals: vec![ vals: vec![
Value::string(format!("{}", c), Span::unknown()), Value::string(format!("{c}"), Span::unknown()),
Value::string(format!("{:#08x}", u32::from(c)), Span::unknown()), Value::string(format!("{:#08x}", u32::from(c)), Span::unknown()),
Value::string(format!("{:?}", modifiers), Span::unknown()), Value::string(format!("{modifiers:?}"), Span::unknown()),
Value::string(format!("{:#08b}", modifiers), Span::unknown()), Value::string(format!("{modifiers:#08b}"), Span::unknown()),
], ],
span: Span::unknown(), span: Span::unknown(),
}; };
@ -126,9 +126,9 @@ fn print_events_helper(event: Event) -> Result<Value, ShellError> {
let record = Value::Record { let record = Value::Record {
cols: vec!["code".into(), "modifier".into(), "flags".into()], cols: vec!["code".into(), "modifier".into(), "flags".into()],
vals: vec![ vals: vec![
Value::string(format!("{:?}", code), Span::unknown()), Value::string(format!("{code:?}"), Span::unknown()),
Value::string(format!("{:?}", modifiers), Span::unknown()), Value::string(format!("{modifiers:?}"), Span::unknown()),
Value::string(format!("{:#08b}", modifiers), Span::unknown()), Value::string(format!("{modifiers:#08b}"), Span::unknown()),
], ],
span: Span::unknown(), span: Span::unknown(),
}; };
@ -138,7 +138,7 @@ fn print_events_helper(event: Event) -> Result<Value, ShellError> {
} else { } else {
let record = Value::Record { let record = Value::Record {
cols: vec!["event".into()], cols: vec!["event".into()],
vals: vec![Value::string(format!("{:?}", event), Span::unknown())], vals: vec![Value::string(format!("{event:?}"), Span::unknown())],
span: Span::unknown(), span: Span::unknown(),
}; };
Ok(record) Ok(record)

3
crates/nu-command/src/strings/encode_decode/base64.rs
View file

@ -93,8 +93,7 @@ fn action(
not_valid => return Value::Error { error:ShellError::GenericError( not_valid => return Value::Error { error:ShellError::GenericError(
"value is not an accepted character set".to_string(), "value is not an accepted character set".to_string(),
format!( format!(
"{} is not a valid character-set.\nPlease use `help hash base64` to see a list of valid character sets.", "{not_valid} is not a valid character-set.\nPlease use `help hash base64` to see a list of valid character sets."
not_valid
), ),
Some(config_character_set.span), Some(config_character_set.span),
None, None,

3
crates/nu-command/src/strings/encode_decode/encoding.rs
View file

@ -62,8 +62,7 @@ fn parse_encoding(span: Span, label: &str) -> Result<&'static Encoding, ShellErr
match Encoding::for_label_no_replacement(label.as_bytes()) { match Encoding::for_label_no_replacement(label.as_bytes()) {
None => Err(ShellError::GenericError( None => Err(ShellError::GenericError(
format!( format!(
r#"{} is not a valid encoding"#, r#"{label} is not a valid encoding"#
label
), ),
"invalid encoding".into(), "invalid encoding".into(),
Some(span), Some(span),

2
crates/nu-command/src/strings/format/command.rs
View file

@ -303,7 +303,7 @@ fn format_record(
} }
Some(err) => { Some(err) => {
return Err(ShellError::TypeMismatch( return Err(ShellError::TypeMismatch(
format!("expression is invalid, detail message: {:?}", err), format!("expression is invalid, detail message: {err:?}"),
*span, *span,
)) ))
} }

2
crates/nu-command/src/strings/size.rs
View file

@ -298,7 +298,7 @@ impl fmt::Display for Counter {
Counter::CodePoints => "codepoints", Counter::CodePoints => "codepoints",
}; };
write!(f, "{}", s) write!(f, "{s}")
} }
} }

4
crates/nu-command/src/strings/str_/trim/trim_.rs
View file

@ -266,10 +266,10 @@ fn trim(s: &str, char_: Option<char>, closure_flags: &ClosureFlags) -> String {
'\x0B' => r"\v".to_string(), '\x0B' => r"\v".to_string(),
'\x0C' => r"\f".to_string(), '\x0C' => r"\f".to_string(),
'\x0D' => r"\r".to_string(), '\x0D' => r"\r".to_string(),
_ => format!(r"\{}", r), _ => format!(r"\{r}"),
}; };
// create a regex string that looks for 2 or more of each of these characters // create a regex string that looks for 2 or more of each of these characters
let re_str = format!("{}{{2,}}", reg); let re_str = format!("{reg}{{2,}}");
// create the regex // create the regex
let re = Regex::new(&re_str).expect("Error creating regular expression"); let re = Regex::new(&re_str).expect("Error creating regular expression");
// replace all multiple occurrences with single occurrences represented by r // replace all multiple occurrences with single occurrences represented by r

2
crates/nu-command/src/system/run_external.rs
View file

@ -753,7 +753,7 @@ fn shell_arg_escape(arg: &str) -> String {
s if !has_unsafe_shell_characters(s) => String::from(s), s if !has_unsafe_shell_characters(s) => String::from(s),
_ => { _ => {
let single_quotes_escaped = arg.split('\'').join("'\"'\"'"); let single_quotes_escaped = arg.split('\'').join("'\"'\"'");
format!("'{}'", single_quotes_escaped) format!("'{single_quotes_escaped}'")
} }
} }
} }

2
crates/nu-command/src/system/which_.rs
View file

@ -86,7 +86,7 @@ fn get_entry_in_aliases(engine_state: &EngineState, name: &str, span: Span) -> O
Some(entry( Some(entry(
name, name,
format!("Nushell alias: {}", alias_str), format!("Nushell alias: {alias_str}"),
false, false,
span, span,
)) ))

2
crates/nu-command/src/viewers/griddle.rs
View file

@ -239,7 +239,7 @@ fn create_grid_output(
Value::string(grid_display.to_string(), call.head) Value::string(grid_display.to_string(), call.head)
} else { } else {
Value::String { Value::String {
val: format!("Couldn't fit grid into {} columns!", cols), val: format!("Couldn't fit grid into {cols} columns!"),
span: call.head, span: call.head,
} }
} }

6
crates/nu-command/src/viewers/table.rs
View file

@ -320,7 +320,7 @@ fn handle_table_command(
} else { } else {
// assume this failed because the table was too wide // assume this failed because the table was too wide
// TODO: more robust error classification // TODO: more robust error classification
format!("Couldn't fit table into {} columns!", term_width) format!("Couldn't fit table into {term_width} columns!")
} }
}); });
@ -1481,7 +1481,7 @@ fn convert_with_precision(val: &str, precision: usize) -> Result<String, ShellEr
)); ));
} }
}; };
Ok(format!("{:.prec$}", val_float, prec = precision)) Ok(format!("{val_float:.precision$}"))
} }
fn is_cfg_trim_keep_words(config: &Config) -> bool { fn is_cfg_trim_keep_words(config: &Config) -> bool {
@ -1696,7 +1696,7 @@ impl Iterator for PagingTableCreator {
// assume this failed because the table was too wide // assume this failed because the table was too wide
// TODO: more robust error classification // TODO: more robust error classification
let term_width = get_width_param(self.width_param); let term_width = get_width_param(self.width_param);
format!("Couldn't fit table into {} columns!", term_width) format!("Couldn't fit table into {term_width} columns!")
}; };
Some(Ok(msg.as_bytes().to_vec())) Some(Ok(msg.as_bytes().to_vec()))
} }

4
crates/nu-command/tests/commands/math/sum.rs
View file

@ -45,7 +45,7 @@ fn compute_sum_of_individual_row() -> Result<(), String> {
for (column_name, expected_value) in answers_for_columns { for (column_name, expected_value) in answers_for_columns {
let actual = nu!( let actual = nu!(
cwd: "tests/fixtures/formats/", cwd: "tests/fixtures/formats/",
format!("open sample-ps-output.json | select {} | math sum | get {}", column_name, column_name) format!("open sample-ps-output.json | select {column_name} | math sum | get {column_name}")
); );
let result = let result =
f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?; f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?;
@ -66,7 +66,7 @@ fn compute_sum_of_table() -> Result<(), String> {
for (column_name, expected_value) in answers_for_columns { for (column_name, expected_value) in answers_for_columns {
let actual = nu!( let actual = nu!(
cwd: "tests/fixtures/formats/", cwd: "tests/fixtures/formats/",
format!("open sample-ps-output.json | select cpu mem virtual | math sum | get {}", column_name) format!("open sample-ps-output.json | select cpu mem virtual | math sum | get {column_name}")
); );
let result = let result =
f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?; f64::from_str(&actual.out).map_err(|_| String::from("Failed to parse float."))?;

2
crates/nu-command/tests/commands/platform/kill.rs
View file

@ -3,7 +3,7 @@ use nu_test_support::nu;
#[test] #[test]
fn test_kill_invalid_pid() { fn test_kill_invalid_pid() {
let pid = i32::MAX; let pid = i32::MAX;
let actual = nu!(format!("kill {}", pid)); let actual = nu!(format!("kill {pid}"));
assert!(actual.err.contains("process didn't terminate successfully")); assert!(actual.err.contains("process didn't terminate successfully"));
} }

7
crates/nu-command/tests/commands/roll.rs
View file

@ -97,7 +97,7 @@ mod columns {
let actual = nu!( let actual = nu!(
cwd: ".", cwd: ".",
format!("{} | roll right --by 3 --cells-only | columns | str join '-' ", four_bitstring) format!("{four_bitstring} | roll right --by 3 --cells-only | columns | str join '-' ")
); );
assert_eq!(actual.out, expected_value.1); assert_eq!(actual.out, expected_value.1);
@ -142,12 +142,11 @@ mod columns {
"#, "#,
); );
println!( println!(
"{} | roll left --by 3 | {}", "{bitstring_as_nu_row_pipeline} | roll left --by 3 | {nu_row_literal_bitstring_to_decimal_value_pipeline}"
bitstring_as_nu_row_pipeline, nu_row_literal_bitstring_to_decimal_value_pipeline
); );
nu!( nu!(
cwd: ".", cwd: ".",
format!("{} | roll left --by 3 | {}", bitstring_as_nu_row_pipeline, nu_row_literal_bitstring_to_decimal_value_pipeline) format!("{bitstring_as_nu_row_pipeline} | roll left --by 3 | {nu_row_literal_bitstring_to_decimal_value_pipeline}")
).out ).out
} }

6
crates/nu-command/tests/commands/save.rs
View file

@ -16,7 +16,7 @@ fn writes_out_csv() {
); );
let actual = file_contents(expected_file); let actual = file_contents(expected_file);
println!("{}", actual); println!("{actual}");
assert!(actual.contains("nu,0.14,A new type of shell,MIT,2018")); assert!(actual.contains("nu,0.14,A new type of shell,MIT,2018"));
}) })
} }
@ -52,7 +52,7 @@ fn save_append_will_create_file_if_not_exists() {
); );
let actual = file_contents(expected_file); let actual = file_contents(expected_file);
println!("{}", actual); println!("{actual}");
assert_eq!(actual, "hello"); assert_eq!(actual, "hello");
}) })
} }
@ -78,7 +78,7 @@ fn save_append_will_not_overwrite_content() {
); );
let actual = file_contents(expected_file); let actual = file_contents(expected_file);
println!("{}", actual); println!("{actual}");
assert_eq!(actual, "hello world"); assert_eq!(actual, "hello world");
}) })
} }

7
crates/nu-command/tests/commands/source_env.rs
View file

@ -16,10 +16,9 @@ fn sources_also_files_under_custom_lib_dirs_path() {
"config.toml", "config.toml",
&format!( &format!(
r#" r#"
lib_dirs = ["{}"] lib_dirs = ["{library_path}"]
skip_welcome_message = true skip_welcome_message = true
"#, "#
library_path
), ),
)]); )]);
@ -151,7 +150,7 @@ fn can_source_dynamic_path() {
sandbox.with_files(vec![FileWithContent(foo_file, "echo foo")]); sandbox.with_files(vec![FileWithContent(foo_file, "echo foo")]);
let cmd = format!("let file = `{}`; source-env $file", foo_file); let cmd = format!("let file = `{foo_file}`; source-env $file");
let actual = nu!(cwd: dirs.test(), &cmd); let actual = nu!(cwd: dirs.test(), &cmd);
assert_eq!(actual.out, "foo"); assert_eq!(actual.out, "foo");

2
crates/nu-command/tests/commands/zip.rs
View file

@ -19,7 +19,7 @@ fn zips_two_tables() {
Playground::setup("zip_test_1", |dirs, nu| { Playground::setup("zip_test_1", |dirs, nu| {
nu.with_files(vec![FileWithContent( nu.with_files(vec![FileWithContent(
"zip_test.nu", "zip_test.nu",
&format!("{}\n", ZIP_POWERED_TEST_ASSERTION_SCRIPT), &format!("{ZIP_POWERED_TEST_ASSERTION_SCRIPT}\n"),
)]); )]);
let actual = nu!( let actual = nu!(

20
crates/nu-command/tests/format_conversions/nuon.rs
View file

@ -390,11 +390,11 @@ proptest! {
let actual = nu!( let actual = nu!(
cwd: "tests/fixtures/formats", pipeline( cwd: "tests/fixtures/formats", pipeline(
format!(r#" format!(r#"
{{"prop{0}test": "sam"}} | to nuon | from nuon; {{"prop{c}test": "sam"}} | to nuon | from nuon;
[ [ "prop{0}test" ]; [ 'test' ] ] | to nuon | from nuon; [ [ "prop{c}test" ]; [ 'test' ] ] | to nuon | from nuon;
[ [ "{0}" ]; [ 'test' ] ] | to nuon | from nuon; [ [ "{c}" ]; [ 'test' ] ] | to nuon | from nuon;
{{"{0}": "sam"}} | to nuon | from nuon; {{"{c}": "sam"}} | to nuon | from nuon;
"#, c).as_ref() "#).as_ref()
)); ));
assert!(actual.err.is_empty() || actual.err.contains("Unexpected end of code") || actual.err.contains("only strings can be keys") || actual.err.contains("unbalanced { and }")); assert!(actual.err.is_empty() || actual.err.contains("Unexpected end of code") || actual.err.contains("only strings can be keys") || actual.err.contains("unbalanced { and }"));
// The second is for weird escapes due to backslashes // The second is for weird escapes due to backslashes
@ -407,11 +407,11 @@ proptest! {
let actual = nu!( let actual = nu!(
cwd: "tests/fixtures/formats", pipeline( cwd: "tests/fixtures/formats", pipeline(
format!(r#" format!(r#"
{{"prop{0}test": "sam"}} | to nuon | from nuon; {{"prop{s}test": "sam"}} | to nuon | from nuon;
[ [ "prop{0}test" ]; [ 'test' ] ] | to nuon | from nuon; [ [ "prop{s}test" ]; [ 'test' ] ] | to nuon | from nuon;
[ [ "{0}" ]; [ 'test' ] ] | to nuon | from nuon; [ [ "{s}" ]; [ 'test' ] ] | to nuon | from nuon;
{{"{0}": "sam"}} | to nuon | from nuon; {{"{s}": "sam"}} | to nuon | from nuon;
"#, s).as_ref() "#).as_ref()
)); ));
assert!(actual.err.is_empty() || actual.err.contains("only strings can be keys") || actual.err.contains("unknown command")); assert!(actual.err.is_empty() || actual.err.contains("only strings can be keys") || actual.err.contains("unknown command"));
// TODO: fix parser error for "unknown command" when '=$' is the name // TODO: fix parser error for "unknown command" when '=$' is the name

23
crates/nu-engine/src/documentation.rs
View file

@ -69,7 +69,7 @@ fn get_documentation(
if !config.no_subcommands { if !config.no_subcommands {
let signatures = engine_state.get_signatures(true); let signatures = engine_state.get_signatures(true);
for sig in signatures { for sig in signatures {
if sig.name.starts_with(&format!("{} ", cmd_name)) if sig.name.starts_with(&format!("{cmd_name} "))
// Don't display deprecated commands in the Subcommands list // Don't display deprecated commands in the Subcommands list
&& !sig.usage.starts_with("Deprecated command") && !sig.usage.starts_with("Deprecated command")
{ {
@ -84,11 +84,11 @@ fn get_documentation(
sig.search_terms.join(", "), sig.search_terms.join(", "),
RESET RESET
); );
let _ = write!(long_desc, "{}", text); let _ = write!(long_desc, "{text}");
} }
let text = format!("{}Usage{}:\n > {}\n", G, RESET, sig.call_signature()); let text = format!("{}Usage{}:\n > {}\n", G, RESET, sig.call_signature());
let _ = write!(long_desc, "{}", text); let _ = write!(long_desc, "{text}");
if !subcommands.is_empty() { if !subcommands.is_empty() {
let _ = write!(long_desc, "\n{G}Subcommands{RESET}:\n"); let _ = write!(long_desc, "\n{G}Subcommands{RESET}:\n");
@ -105,11 +105,10 @@ fn get_documentation(
if sig.operates_on_cell_paths() { if sig.operates_on_cell_paths() {
let _ = writeln!( let _ = writeln!(
long_desc, long_desc,
"\n{}Signatures(Cell paths are supported){}:\n{}", "\n{G}Signatures(Cell paths are supported){RESET}:\n{sig}"
G, RESET, sig
); );
} else { } else {
let _ = writeln!(long_desc, "\n{}Signatures{}:\n{}", G, RESET, sig); let _ = writeln!(long_desc, "\n{G}Signatures{RESET}:\n{sig}");
} }
} }
@ -137,7 +136,7 @@ fn get_documentation(
) )
} }
}; };
let _ = writeln!(long_desc, "{}", text); let _ = writeln!(long_desc, "{text}");
} }
for positional in &sig.optional_positional { for positional in &sig.optional_positional {
let text = match &positional.shape { let text = match &positional.shape {
@ -158,7 +157,7 @@ fn get_documentation(
) )
} }
}; };
let _ = writeln!(long_desc, "{}", text); let _ = writeln!(long_desc, "{text}");
} }
if let Some(rest_positional) = &sig.rest_positional { if let Some(rest_positional) = &sig.rest_positional {
@ -168,12 +167,12 @@ fn get_documentation(
document_shape(rest_positional.shape.clone()), document_shape(rest_positional.shape.clone()),
rest_positional.desc rest_positional.desc
); );
let _ = writeln!(long_desc, "{}", text); let _ = writeln!(long_desc, "{text}");
} }
} }
if !examples.is_empty() { if !examples.is_empty() {
let _ = write!(long_desc, "\n{}Examples{}:", G, RESET); let _ = write!(long_desc, "\n{G}Examples{RESET}:");
} }
for example in examples { for example in examples {
@ -196,7 +195,7 @@ fn get_documentation(
let result = output.into_value(Span::unknown()); let result = output.into_value(Span::unknown());
match result.as_string() { match result.as_string() {
Ok(s) => { Ok(s) => {
let _ = write!(long_desc, "\n > {}\n", s); let _ = write!(long_desc, "\n > {s}\n");
} }
_ => { _ => {
let _ = write!(long_desc, "\n > {}\n", example.example); let _ = write!(long_desc, "\n > {}\n", example.example);
@ -237,7 +236,7 @@ pub fn get_flags_section(signature: &Signature) -> String {
const D: &str = "\x1b[39m"; // default const D: &str = "\x1b[39m"; // default
let mut long_desc = String::new(); let mut long_desc = String::new();
let _ = write!(long_desc, "\n{}Flags{}:\n", G, RESET); let _ = write!(long_desc, "\n{G}Flags{RESET}:\n");
for flag in &signature.named { for flag in &signature.named {
let msg = if let Some(arg) = &flag.arg { let msg = if let Some(arg) = &flag.arg {
if let Some(short) = flag.short { if let Some(short) = flag.short {

12
crates/nu-engine/src/env.rs
View file

@ -174,7 +174,7 @@ pub fn current_dir_str(engine_state: &EngineState, stack: &Stack) -> Result<Stri
} else { } else {
Err(ShellError::GenericError( Err(ShellError::GenericError(
"Invalid current directory".to_string(), "Invalid current directory".to_string(),
format!("The 'PWD' environment variable must be set to an absolute path. Found: '{}'", cwd), format!("The 'PWD' environment variable must be set to an absolute path. Found: '{cwd}'"),
Some(pwd.span()?), Some(pwd.span()?),
None, None,
Vec::new() Vec::new()
@ -255,7 +255,7 @@ pub fn find_in_dirs_env(
} else { } else {
return Err(ShellError::GenericError( return Err(ShellError::GenericError(
"Invalid current directory".to_string(), "Invalid current directory".to_string(),
format!("The 'FILE_PWD' environment variable must be set to an absolute path. Found: '{}'", cwd), format!("The 'FILE_PWD' environment variable must be set to an absolute path. Found: '{cwd}'"),
Some(pwd.span()?), Some(pwd.span()?),
None, None,
Vec::new() Vec::new()
@ -395,8 +395,8 @@ fn ensure_path(scope: &mut HashMap<String, Value>, env_path_name: &str) -> Optio
if !vals.iter().all(|v| matches!(v, Value::String { .. })) { if !vals.iter().all(|v| matches!(v, Value::String { .. })) {
error = error.or_else(|| { error = error.or_else(|| {
Some(ShellError::GenericError( Some(ShellError::GenericError(
format!("Wrong {} environment variable value", env_path_name), format!("Wrong {env_path_name} environment variable value"),
format!("{} must be a list of strings", env_path_name), format!("{env_path_name} must be a list of strings"),
Some(*span), Some(*span),
None, None,
Vec::new(), Vec::new(),
@ -416,8 +416,8 @@ fn ensure_path(scope: &mut HashMap<String, Value>, env_path_name: &str) -> Optio
error = error.or_else(|| { error = error.or_else(|| {
Some(ShellError::GenericError( Some(ShellError::GenericError(
format!("Wrong {} environment variable value", env_path_name), format!("Wrong {env_path_name} environment variable value"),
format!("{} must be a list of strings", env_path_name), format!("{env_path_name} must be a list of strings"),
Some(span), Some(span),
None, None,
Vec::new(), Vec::new(),

2
crates/nu-engine/src/eval.rs
View file

@ -19,7 +19,7 @@ pub fn eval_operator(op: &Expression) -> Result<Operator, ShellError> {
.. ..
} => Ok(operator.clone()), } => Ok(operator.clone()),
Expression { span, expr, .. } => { Expression { span, expr, .. } => {
Err(ShellError::UnknownOperator(format!("{:?}", expr), *span)) Err(ShellError::UnknownOperator(format!("{expr:?}"), *span))
} }
} }
} }

2
crates/nu-explore/src/commands/config.rs
View file

@ -160,7 +160,7 @@ fn create_default_value() -> Value {
let record = |i: usize| Value::Record { let record = |i: usize| Value::Record {
cols: vec![String::from("key"), String::from("value")], cols: vec![String::from("key"), String::from("value")],
vals: vec![nu_str(format!("key-{}", i)), nu_str(format!("{}", i))], vals: vec![nu_str(format!("key-{i}")), nu_str(format!("{i}"))],
span, span,
}; };

2
crates/nu-explore/src/commands/mod.rs
View file

@ -176,6 +176,6 @@ pub fn default_color_list() -> Vec<HelpExample> {
pub fn default_int_list() -> Vec<HelpExample> { pub fn default_int_list() -> Vec<HelpExample> {
(0..20) (0..20)
.map(|i| HelpExample::new(i.to_string(), format!("A value equal to {}", i))) .map(|i| HelpExample::new(i.to_string(), format!("A value equal to {i}")))
.collect() .collect()
} }

2
crates/nu-explore/src/nu_common/table.rs
View file

@ -882,7 +882,7 @@ fn convert_with_precision(val: &str, precision: usize) -> Result<String, ShellEr
)); ));
} }
}; };
Ok(format!("{:.prec$}", val_float, prec = precision)) Ok(format!("{val_float:.precision$}"))
} }
fn load_theme_from_config(config: &Config) -> TableTheme { fn load_theme_from_config(config: &Config) -> TableTheme {

13
crates/nu-explore/src/pager/mod.rs
View file

@ -393,10 +393,9 @@ fn handle_command(
run_command(engine_state, stack, pager, view, view_stack, command, args) run_command(engine_state, stack, pager, view, view_stack, command, args)
} }
Some(Err(err)) => Err(format!( Some(Err(err)) => Err(format!(
"Error: command {:?} was not provided with correct arguments: {}", "Error: command {args:?} was not provided with correct arguments: {err}"
args, err
)), )),
None => Err(format!("Error: command {:?} was not recognized", args)), None => Err(format!("Error: command {args:?} was not recognized")),
} }
} }
@ -447,7 +446,7 @@ fn run_command(
Transition::Exit => Ok(true), Transition::Exit => Ok(true),
Transition::Cmd { .. } => todo!("not used so far"), Transition::Cmd { .. } => todo!("not used so far"),
}, },
Err(err) => Err(format!("Error: command {:?} failed: {}", args, err)), Err(err) => Err(format!("Error: command {args:?} failed: {err}")),
} }
} }
Command::View { mut cmd, is_light } => { Command::View { mut cmd, is_light } => {
@ -472,7 +471,7 @@ fn run_command(
*view = Some(Page::raw(new_view, is_light)); *view = Some(Page::raw(new_view, is_light));
Ok(false) Ok(false)
} }
Err(err) => Err(format!("Error: command {:?} failed: {}", args, err)), Err(err) => Err(format!("Error: command {args:?} failed: {err}")),
} }
} }
} }
@ -581,7 +580,7 @@ fn render_cmd_bar_search(f: &mut Frame, area: Rect, pager: &Pager<'_>, theme: &S
} else { } else {
let index = pager.search_buf.search_index + 1; let index = pager.search_buf.search_index + 1;
let total = pager.search_buf.search_results.len(); let total = pager.search_buf.search_results.len();
format!("[{}/{}]", index, total) format!("[{index}/{total}]")
}; };
let bar = CommandBar::new(&text, &info, theme.cmd_bar_text, theme.cmd_bar_background); let bar = CommandBar::new(&text, &info, theme.cmd_bar_text, theme.cmd_bar_background);
@ -604,7 +603,7 @@ fn render_cmd_bar_cmd(f: &mut Frame, area: Rect, pager: &Pager, theme: &StyleCon
} }
let prefix = ':'; let prefix = ':';
let text = format!("{}{}", prefix, input); let text = format!("{prefix}{input}");
let bar = CommandBar::new(&text, "", theme.cmd_bar_text, theme.cmd_bar_background); let bar = CommandBar::new(&text, "", theme.cmd_bar_text, theme.cmd_bar_background);
f.render_widget(bar, area); f.render_widget(bar, area);

8
crates/nu-explore/src/views/interactive.rs
View file

@ -195,9 +195,7 @@ impl View for InteractiveView<'_> {
if self.immediate { if self.immediate {
match self.try_run(engine_state, stack) { match self.try_run(engine_state, stack) {
Ok(_) => info.report = Some(Report::default()), Ok(_) => info.report = Some(Report::default()),
Err(err) => { Err(err) => info.report = Some(Report::error(format!("Error: {err}"))),
info.report = Some(Report::error(format!("Error: {}", err)))
}
} }
} }
} }
@ -210,7 +208,7 @@ impl View for InteractiveView<'_> {
if self.immediate { if self.immediate {
match self.try_run(engine_state, stack) { match self.try_run(engine_state, stack) {
Ok(_) => info.report = Some(Report::default()), Ok(_) => info.report = Some(Report::default()),
Err(err) => info.report = Some(Report::error(format!("Error: {}", err))), Err(err) => info.report = Some(Report::error(format!("Error: {err}"))),
} }
} }
@ -226,7 +224,7 @@ impl View for InteractiveView<'_> {
KeyCode::Enter => { KeyCode::Enter => {
match self.try_run(engine_state, stack) { match self.try_run(engine_state, stack) {
Ok(_) => info.report = Some(Report::default()), Ok(_) => info.report = Some(Report::default()),
Err(err) => info.report = Some(Report::error(format!("Error: {}", err))), Err(err) => info.report = Some(Report::error(format!("Error: {err}"))),
} }
Some(Transition::Ok) Some(Transition::Ok)

8
crates/nu-explore/src/views/record/mod.rs
View file

@ -691,11 +691,11 @@ fn report_cursor_position(mode: UIMode, cursor: XYCursor) -> String {
if mode == UIMode::Cursor { if mode == UIMode::Cursor {
let row = cursor.row(); let row = cursor.row();
let column = cursor.column(); let column = cursor.column();
format!("{},{}", row, column) format!("{row},{column}")
} else { } else {
let rows_seen = cursor.row_starts_at(); let rows_seen = cursor.row_starts_at();
let columns_seen = cursor.column_starts_at(); let columns_seen = cursor.column_starts_at();
format!("{},{}", rows_seen, columns_seen) format!("{rows_seen},{columns_seen}")
} }
} }
@ -707,13 +707,13 @@ fn report_row_position(cursor: XYCursor) -> String {
match percent_rows { match percent_rows {
100 => String::from("All"), 100 => String::from("All"),
value => format!("{}%", value), value => format!("{value}%"),
} }
} }
} }
fn get_percentage(value: usize, max: usize) -> usize { fn get_percentage(value: usize, max: usize) -> usize {
debug_assert!(value <= max, "{:?} {:?}", value, max); debug_assert!(value <= max, "{value:?} {max:?}");
((value as f32 / max as f32) * 100.0).floor() as usize ((value as f32 / max as f32) * 100.0).floor() as usize
} }

2
crates/nu-explore/src/views/util.rs
View file

@ -161,5 +161,5 @@ fn convert_with_precision(val: &str, precision: usize) -> Result<String, ShellEr
)); ));
} }
}; };
Ok(format!("{:.prec$}", val_float, prec = precision)) Ok(format!("{val_float:.precision$}"))
} }

4
crates/nu-json/src/error.rs
View file

@ -75,7 +75,7 @@ impl fmt::Debug for ErrorCode {
//use std::fmt::Debug; //use std::fmt::Debug;
match *self { match *self {
ErrorCode::Custom(ref msg) => write!(f, "{}", msg), ErrorCode::Custom(ref msg) => write!(f, "{msg}"),
ErrorCode::EofWhileParsingList => "EOF while parsing a list".fmt(f), ErrorCode::EofWhileParsingList => "EOF while parsing a list".fmt(f),
ErrorCode::EofWhileParsingObject => "EOF while parsing an object".fmt(f), ErrorCode::EofWhileParsingObject => "EOF while parsing an object".fmt(f),
ErrorCode::EofWhileParsingString => "EOF while parsing a string".fmt(f), ErrorCode::EofWhileParsingString => "EOF while parsing a string".fmt(f),
@ -129,7 +129,7 @@ impl fmt::Display for Error {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self { match *self {
Error::Syntax(ref code, line, col) => { Error::Syntax(ref code, line, col) => {
write!(fmt, "{:?} at line {} column {}", code, line, col) write!(fmt, "{code:?} at line {line} column {col}")
} }
Error::Io(ref error) => fmt::Display::fmt(error, fmt), Error::Io(ref error) => fmt::Display::fmt(error, fmt),
Error::FromUtf8(ref error) => fmt::Display::fmt(error, fmt), Error::FromUtf8(ref error) => fmt::Display::fmt(error, fmt),

18
crates/nu-json/src/ser.rs
View file

@ -94,49 +94,49 @@ where
#[inline] #[inline]
fn serialize_i8(self, value: i8) -> Result<()> { fn serialize_i8(self, value: i8) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
fn serialize_i16(self, value: i16) -> Result<()> { fn serialize_i16(self, value: i16) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
fn serialize_i32(self, value: i32) -> Result<()> { fn serialize_i32(self, value: i32) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
fn serialize_i64(self, value: i64) -> Result<()> { fn serialize_i64(self, value: i64) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
fn serialize_u8(self, value: u8) -> Result<()> { fn serialize_u8(self, value: u8) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
fn serialize_u16(self, value: u16) -> Result<()> { fn serialize_u16(self, value: u16) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
fn serialize_u32(self, value: u32) -> Result<()> { fn serialize_u32(self, value: u32) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
fn serialize_u64(self, value: u64) -> Result<()> { fn serialize_u64(self, value: u64) -> Result<()> {
self.formatter.start_value(&mut self.writer)?; self.formatter.start_value(&mut self.writer)?;
write!(&mut self.writer, "{}", value).map_err(From::from) write!(&mut self.writer, "{value}").map_err(From::from)
} }
#[inline] #[inline]
@ -904,7 +904,7 @@ where
N: Display + LowerExp, N: Display + LowerExp,
{ {
let f1 = value.to_string(); let f1 = value.to_string();
let f2 = format!("{:e}", value); let f2 = format!("{value:e}");
if f1.len() <= f2.len() + 1 { if f1.len() <= f2.len() + 1 {
f1 f1
} else if !f2.contains("e-") { } else if !f2.contains("e-") {

6
crates/nu-parser/src/deparse.rs
View file

@ -23,18 +23,18 @@ pub fn escape_for_script_arg(input: &str) -> String {
if let Some((arg_name, arg_val)) = input.split_once('=') { if let Some((arg_name, arg_val)) = input.split_once('=') {
// only want to escape arg_val. // only want to escape arg_val.
let arg_val = if arg_val.contains(' ') { let arg_val = if arg_val.contains(' ') {
format!("`{}`", arg_val) format!("`{arg_val}`")
} else if arg_val.contains('"') || arg_val.contains('\\') { } else if arg_val.contains('"') || arg_val.contains('\\') {
escape_quote_string(arg_val) escape_quote_string(arg_val)
} else { } else {
arg_val.into() arg_val.into()
}; };
return format!("{}={}", arg_name, arg_val); return format!("{arg_name}={arg_val}");
} }
} }
if input.contains(' ') { if input.contains(' ') {
format!("`{}`", input) format!("`{input}`")
} else if input.contains('"') || input.contains('\\') { } else if input.contains('"') || input.contains('\\') {
escape_quote_string(input) escape_quote_string(input)
} else { } else {

2
crates/nu-parser/src/eval.rs
View file

@ -36,7 +36,7 @@ pub fn eval_constant(
// TODO: Better error conversion // TODO: Better error conversion
Err(shell_error) => Err(ParseError::LabeledError( Err(shell_error) => Err(ParseError::LabeledError(
"Error when following cell path".to_string(), "Error when following cell path".to_string(),
format!("{:?}", shell_error), format!("{shell_error:?}"),
expr.span, expr.span,
)), )),
} }

Some files were not shown because too many files have changed in this diff Show more