style: Use inline format args

epage · epage · commit f89452f724d2 · 2024-09-27T10:56:46.000-05:00
diff --git a/examples/example_fixture.rs b/examples/example_fixture.rs
@@ -8,10 +8,10 @@ use std::process;
 
 fn run() -> Result<(), Box<dyn Error>> {
     if let Ok(text) = env::var("stdout") {
-        println!("{}", text);
+        println!("{text}");
     }
     if let Ok(text) = env::var("stderr") {
-        eprintln!("{}", text);
+        eprintln!("{text}");
     }
 
     let code = env::var("exit")
@@ -27,7 +27,7 @@ fn main() {
     let code = match run() {
         Ok(_) => 0,
         Err(ref e) => {
-            write!(&mut io::stderr(), "{}", e).expect("writing to stderr won't fail");
+            write!(&mut io::stderr(), "{e}").expect("writing to stderr won't fail");
             1
         }
     };
diff --git a/src/assert.rs b/src/assert.rs
@@ -64,7 +64,7 @@ impl<'c> OutputAssertExt for &'c mut process::Command {
                 panic!("Failed to spawn {:?}: {}", self, err);
             }
         };
-        Assert::new(output).append_context("command", format!("{:?}", self))
+        Assert::new(output).append_context("command", format!("{self:?}"))
     }
 }
 
@@ -1084,13 +1084,13 @@ impl fmt::Display for AssertError {
                 writeln!(f, "Command interrupted")
             }
             AssertReason::UnexpectedReturnCode { case_tree } => {
-                writeln!(f, "Unexpected return code, failed {}", case_tree)
+                writeln!(f, "Unexpected return code, failed {case_tree}")
             }
             AssertReason::UnexpectedStdout { case_tree } => {
-                writeln!(f, "Unexpected stdout, failed {}", case_tree)
+                writeln!(f, "Unexpected stdout, failed {case_tree}")
             }
             AssertReason::UnexpectedStderr { case_tree } => {
-                writeln!(f, "Unexpected stderr, failed {}", case_tree)
+                writeln!(f, "Unexpected stderr, failed {case_tree}")
             }
         }?;
         write!(f, "{}", self.assert)
diff --git a/src/bin/bin_fixture.rs b/src/bin/bin_fixture.rs
@@ -8,10 +8,10 @@ use std::process;
 
 fn run() -> Result<(), Box<dyn Error>> {
     if let Ok(text) = env::var("stdout") {
-        println!("{}", text);
+        println!("{text}");
     }
     if let Ok(text) = env::var("stderr") {
-        eprintln!("{}", text);
+        eprintln!("{text}");
     }
 
     if let Some(timeout) = env::var("sleep").ok().and_then(|s| s.parse().ok()) {
@@ -31,7 +31,7 @@ fn main() {
     let code = match run() {
         Ok(_) => 0,
         Err(ref e) => {
-            write!(&mut io::stderr(), "{}", e).expect("writing to stderr won't fail");
+            write!(&mut io::stderr(), "{e}").expect("writing to stderr won't fail");
             1
         }
     };
diff --git a/src/cargo.rs b/src/cargo.rs
@@ -181,7 +181,7 @@ impl Error for CargoError {}
 impl fmt::Display for CargoError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(ref cause) = self.cause {
-            writeln!(f, "Cause: {}", cause)?;
+            writeln!(f, "Cause: {cause}")?;
         }
         Ok(())
     }
@@ -222,7 +222,7 @@ pub fn cargo_bin<S: AsRef<str>>(name: S) -> path::PathBuf {
 }
 
 fn cargo_bin_str(name: &str) -> path::PathBuf {
-    let env_var = format!("CARGO_BIN_EXE_{}", name);
+    let env_var = format!("CARGO_BIN_EXE_{name}");
     env::var_os(env_var)
         .map(|p| p.into())
         .unwrap_or_else(|| target_dir().join(format!("{}{}", name, env::consts::EXE_SUFFIX)))
diff --git a/src/cmd.rs b/src/cmd.rs
@@ -648,7 +648,7 @@ impl<'c> OutputAssertExt for &'c mut Command {
         let output = match self.output() {
             Ok(output) => output,
             Err(err) => {
-                panic!("Failed to spawn {:?}: {}", self, err);
+                panic!("Failed to spawn {self:?}: {err}");
             }
         };
         let assert = Assert::new(output).append_context("command", format!("{:?}", self.cmd));
diff --git a/src/output.rs b/src/output.rs
@@ -109,7 +109,7 @@ impl<'c> OutputOkExt for &'c mut process::Command {
         if output.status.success() {
             Ok(output)
         } else {
-            let error = OutputError::new(output).set_cmd(format!("{:?}", self));
+            let error = OutputError::new(output).set_cmd(format!("{self:?}"));
             Err(error)
         }
     }
@@ -266,8 +266,8 @@ enum OutputCause {
 impl fmt::Display for OutputCause {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            OutputCause::Expected(ref e) => write!(f, "{:#}", e),
-            OutputCause::Unexpected(ref e) => write!(f, "{:#}", e),
+            OutputCause::Expected(ref e) => write!(f, "{e:#}"),
+            OutputCause::Unexpected(ref e) => write!(f, "{e:#}"),
         }
     }
 }
@@ -369,9 +369,9 @@ fn format_bytes(data: &[u8], f: &mut impl fmt::Write) -> fmt::Result {
             .as_bstr()
             .lines_with_terminator()
             .skip(LINES_MAX_START + lines_omitted);
-        writeln!(f, "<{} lines total>", lines_total)?;
+        writeln!(f, "<{lines_total} lines total>")?;
         write_debug_bstrs(f, true, start_lines)?;
-        writeln!(f, "<{} lines omitted>", lines_omitted)?;
+        writeln!(f, "<{lines_omitted} lines omitted>")?;
         write_debug_bstrs(f, true, end_lines)
     } else if BYTES_MIN_OVERFLOW <= data.len() {
         write!(
@@ -434,7 +434,7 @@ mod test {
     fn format_bytes() {
         let mut s = String::new();
         for i in 0..80 {
-            s.push_str(&format!("{}\n", i));
+            s.push_str(&format!("{i}\n"));
         }
 
         let mut buf = String::new();
diff --git a/tests/cargo.rs b/tests/cargo.rs
@@ -34,7 +34,7 @@ fn mod_example() {
             .unwrap();
         let mut cmd = bin_under_test.command();
         let output = cmd.unwrap();
-        println!("{:?}", output);
+        println!("{output:?}");
     }
 }
 
@@ -43,20 +43,20 @@ fn mod_example() {
 fn trait_example() {
     let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
     let output = cmd.unwrap();
-    println!("{:?}", output);
+    println!("{output:?}");
 }
 
 #[test]
 #[should_panic] // No bin named `assert_cmd
 fn cargo_bin_example_1() {
     let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
     let output = cmd.unwrap();
-    println!("{:?}", output);
+    println!("{output:?}");
 }
 
 #[test]
 fn cargo_bin_example_2() {
     let mut cmd = Command::cargo_bin("bin_fixture").unwrap();
     let output = cmd.unwrap();
-    println!("{:?}", output);
+    println!("{output:?}");
 }

Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@ use std::process;`
`8`	`8`
`9`	`9`	`fn run() -> Result<(), Box<dyn Error>> {`
`10`	`10`	`if let Ok(text) = env::var("stdout") {`
`11`		`- println!("{}", text);`
	`11`	`+ println!("{text}");`
`12`	`12`	`}`
`13`	`13`	`if let Ok(text) = env::var("stderr") {`
`14`		`- eprintln!("{}", text);`
	`14`	`+ eprintln!("{text}");`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`let code = env::var("exit")`
`@@ -27,7 +27,7 @@ fn main() {`
`27`	`27`	`let code = match run() {`
`28`	`28`	`Ok(_) => 0,`
`29`	`29`	`Err(ref e) => {`
`30`		`- write!(&mut io::stderr(), "{}", e).expect("writing to stderr won't fail");`
	`30`	`+ write!(&mut io::stderr(), "{e}").expect("writing to stderr won't fail");`
`31`	`31`	`1`
`32`	`32`	`}`
`33`	`33`	`};`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ impl<'c> OutputAssertExt for &'c mut process::Command {`
`64`	`64`	`panic!("Failed to spawn {:?}: {}", self, err);`
`65`	`65`	`}`
`66`	`66`	`};`
`67`		`- Assert::new(output).append_context("command", format!("{:?}", self))`
	`67`	`+ Assert::new(output).append_context("command", format!("{self:?}"))`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`@@ -1084,13 +1084,13 @@ impl fmt::Display for AssertError {`
`1084`	`1084`	`writeln!(f, "Command interrupted")`
`1085`	`1085`	`}`
`1086`	`1086`	`AssertReason::UnexpectedReturnCode { case_tree } => {`
`1087`		`- writeln!(f, "Unexpected return code, failed {}", case_tree)`
	`1087`	`+ writeln!(f, "Unexpected return code, failed {case_tree}")`
`1088`	`1088`	`}`
`1089`	`1089`	`AssertReason::UnexpectedStdout { case_tree } => {`
`1090`		`- writeln!(f, "Unexpected stdout, failed {}", case_tree)`
	`1090`	`+ writeln!(f, "Unexpected stdout, failed {case_tree}")`
`1091`	`1091`	`}`
`1092`	`1092`	`AssertReason::UnexpectedStderr { case_tree } => {`
`1093`		`- writeln!(f, "Unexpected stderr, failed {}", case_tree)`
	`1093`	`+ writeln!(f, "Unexpected stderr, failed {case_tree}")`
`1094`	`1094`	`}`
`1095`	`1095`	`}?;`
`1096`	`1096`	`write!(f, "{}", self.assert)`
Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ impl Error for CargoError {}`
`181`	`181`	`impl fmt::Display for CargoError {`
`182`	`182`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`183`	`183`	`if let Some(ref cause) = self.cause {`
`184`		`- writeln!(f, "Cause: {}", cause)?;`
	`184`	`+ writeln!(f, "Cause: {cause}")?;`
`185`	`185`	`}`
`186`	`186`	`Ok(())`
`187`	`187`	`}`
`@@ -222,7 +222,7 @@ pub fn cargo_bin<S: AsRef<str>>(name: S) -> path::PathBuf {`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`fn cargo_bin_str(name: &str) -> path::PathBuf {`
`225`		`- let env_var = format!("CARGO_BIN_EXE_{}", name);`
	`225`	`+ let env_var = format!("CARGO_BIN_EXE_{name}");`
`226`	`226`	`env::var_os(env_var)`
`227`	`227`	`.map(\|p\| p.into())`
`228`	`228`	`.unwrap_or_else(\|\| target_dir().join(format!("{}{}", name, env::consts::EXE_SUFFIX)))`
Original file line number	Diff line number	Diff line change
`@@ -648,7 +648,7 @@ impl<'c> OutputAssertExt for &'c mut Command {`
`648`	`648`	`let output = match self.output() {`
`649`	`649`	`Ok(output) => output,`
`650`	`650`	`Err(err) => {`
`651`		`- panic!("Failed to spawn {:?}: {}", self, err);`
	`651`	`+ panic!("Failed to spawn {self:?}: {err}");`
`652`	`652`	`}`
`653`	`653`	`};`
`654`	`654`	`let assert = Assert::new(output).append_context("command", format!("{:?}", self.cmd));`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ fn mod_example() {`
`34`	`34`	`.unwrap();`
`35`	`35`	`let mut cmd = bin_under_test.command();`
`36`	`36`	`let output = cmd.unwrap();`
`37`		`- println!("{:?}", output);`
	`37`	`+ println!("{output:?}");`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`@@ -43,20 +43,20 @@ fn mod_example() {`
`43`	`43`	`fn trait_example() {`
`44`	`44`	`let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();`
`45`	`45`	`let output = cmd.unwrap();`
`46`		`- println!("{:?}", output);`
	`46`	`+ println!("{output:?}");`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`#[test]`
`50`	`50`	#[should_panic] // No bin named `assert_cmd
`51`	`51`	`fn cargo_bin_example_1() {`
`52`	`52`	`let mut cmd = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();`
`53`	`53`	`let output = cmd.unwrap();`
`54`		`- println!("{:?}", output);`
	`54`	`+ println!("{output:?}");`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`#[test]`
`58`	`58`	`fn cargo_bin_example_2() {`
`59`	`59`	`let mut cmd = Command::cargo_bin("bin_fixture").unwrap();`
`60`	`60`	`let output = cmd.unwrap();`
`61`		`- println!("{:?}", output);`
	`61`	`+ println!("{output:?}");`
`62`	`62`	`}`