all: run clippy --fix

Author: numas13

admin/src/cli.rs

@@ -25,7 +25,7 @@ pub struct Cli {
 impl Default for Cli {
     fn default() -> Cli {
         Cli {
-            address: format!("{}:{}", DEFAULT_HOST, DEFAULT_PORT),
+            address: format!("{DEFAULT_HOST}:{DEFAULT_PORT}"),
             command: String::new(),
             hash_len: admin::HASH_LEN,
             hash_key: admin::HASH_KEY.to_owned(),
@@ -35,12 +35,12 @@ impl Default for Cli {
 }
 
 fn print_usage(opts: Options) {
-    let brief = format!("Usage: {} [options]", BIN_NAME);
+    let brief = format!("Usage: {BIN_NAME} [options]");
     print!("{}", opts.usage(&brief));
 }
 
 fn print_version() {
-    println!("{} v{}", PKG_NAME, PKG_VERSION);
+    println!("{PKG_NAME} v{PKG_VERSION}");
 }
 
 pub fn parse() -> Cli {
@@ -62,7 +62,7 @@ pub fn parse() -> Cli {
     let matches = match opts.parse(&args[1..]) {
         Ok(m) => m,
         Err(e) => {
-            eprintln!("{}", e);
+            eprintln!("{e}");
             process::exit(1);
         }
     };

admin/src/main.rs

@@ -112,7 +112,7 @@ fn main() {
     let cli = cli::parse();
 
     if let Err(e) = send_command(&cli) {
-        eprintln!("error: {}", e);
+        eprintln!("error: {e}");
         std::process::exit(1);
     }
 }

master/bin/cli.rs

@@ -36,12 +36,12 @@ pub struct Cli {
 }
 
 fn print_usage(opts: Options) {
-    let brief = format!("Usage: {} [options]", BIN_NAME);
+    let brief = format!("Usage: {BIN_NAME} [options]");
     print!("{}", opts.usage(&brief));
 }
 
 fn print_version() {
-    println!("{} v{}", PKG_NAME, PKG_VERSION);
+    println!("{PKG_NAME} v{PKG_VERSION}");
 }
 
 pub fn parse() -> Result<Cli, Error> {
@@ -87,7 +87,7 @@ pub fn parse() -> Result<Cli, Error> {
         match config::parse_log_level(value.as_ref()) {
             Some(level) => cli.log_level = Some(level),
             None => {
-                eprintln!("Invalid value for log option: \"{}\"", value);
+                eprintln!("Invalid value for log option: \"{value}\"");
                 process::exit(1);
             }
         }

master/bin/logger.rs

@@ -47,7 +47,7 @@ static LOGGER: Logger = Logger::new();
 
 pub fn init() -> &'static Logger {
     if let Err(e) = log::set_logger(&LOGGER) {
-        eprintln!("Failed to initialize logger: {}", e);
+        eprintln!("Failed to initialize logger: {e}");
     }
     &LOGGER
 }

master/bin/main.rs

@@ -52,16 +52,16 @@ fn load_config(cli: &Cli, logger: &Logger) -> Result<Config, config::Error> {
 
 fn run() -> Result<(), Error> {
     let cli = cli::parse().unwrap_or_else(|e| {
-        eprintln!("{}", e);
+        eprintln!("{e}");
         std::process::exit(1);
     });
 
     let logger = logger::init();
 
     let cfg = load_config(&cli, logger).unwrap_or_else(|e| {
         match cli.config_path.as_deref() {
-            Some(p) => eprintln!("Failed to load config \"{}\": {}", p, e),
-            None => eprintln!("{}", e),
+            Some(p) => eprintln!("Failed to load config \"{p}\": {e}"),
+            None => eprintln!("{e}"),
         }
         process::exit(1);
     });

master/src/config.rs

@@ -208,7 +208,7 @@ where
     D: Deserializer<'de>,
 {
     let s = <&str>::deserialize(de)?;
-    parse_log_level(s).ok_or_else(|| D::Error::custom(format!("Invalid log level: \"{}\"", s)))
+    parse_log_level(s).ok_or_else(|| D::Error::custom(format!("Invalid log level: \"{s}\"")))
 }
 
 pub fn parse_log_level(s: &str) -> Option<LevelFilter> {
@@ -240,7 +240,7 @@ where
 {
     let s = <&str>::deserialize(de)?;
     s.parse()
-        .map_err(|_| D::Error::custom(format!("Invalid version: \"{}\"", s)))
+        .map_err(|_| D::Error::custom(format!("Invalid version: \"{s}\"")))
 }
 
 pub fn load<P: AsRef<Path>>(path: P) -> Result<Config, Error> {

observer/examples/monitor.rs

@@ -102,11 +102,11 @@ impl Handler for Monitor {
         match self.servers.entry(addr) {
             Entry::Occupied(mut e) => {
                 println!("{:24?} --- {:>7.1} {}", addr, ' ', e.get());
-                println!("{:24?} +++ {:>7.1?} {}", addr, ping, info);
+                println!("{addr:24?} +++ {ping:>7.1?} {info}");
                 e.insert(info);
             }
             Entry::Vacant(e) => {
-                println!("{:24?} +++ {:>7.1?} {}", addr, ping, info);
+                println!("{addr:24?} +++ {ping:>7.1?} {info}");
                 e.insert(info);
             }
         }

observer/src/lib.rs

@@ -127,7 +127,7 @@ impl<'a> ObserverBuilder<'a> {
         fn append<T: fmt::Display>(out: &mut String, key: &str, value: Option<T>) {
             use fmt::Write;
             if let Some(value) = value {
-                write!(out, "\\{}\\{}", key, value).unwrap();
+                write!(out, "\\{key}\\{value}").unwrap();
             }
         }
 

protocol/src/cursor/write.rs

@@ -189,7 +189,7 @@ impl<'a> CursorMut<'a> {
     }
 
     pub fn put_as_str<T: fmt::Display>(&mut self, value: T) -> Result<&mut Self> {
-        write!(self, "{}", value).map_err(|_| CursorError::UnexpectedEnd)?;
+        write!(self, "{value}").map_err(|_| CursorError::UnexpectedEnd)?;
         Ok(self)
     }
 

protocol/src/filter.rs

@@ -302,42 +302,42 @@ impl fmt::Display for &Filter<'_> {
         display_flag!("dedicated", FilterFlags::DEDICATED);
         display_flag!("secure", FilterFlags::SECURE);
         if let Some(s) = self.gamedir {
-            write!(fmt, "\\gamedir\\{}", s)?;
+            write!(fmt, "\\gamedir\\{s}")?;
         }
         display_flag!("secure", FilterFlags::SECURE);
         if let Some(s) = self.map {
-            write!(fmt, "\\map\\{}", s)?;
+            write!(fmt, "\\map\\{s}")?;
         }
         display_flag!("empty", FilterFlags::EMPTY);
         display_flag!("full", FilterFlags::FULL);
         display_flag!("password", FilterFlags::PASSWORD);
         display_flag!("noplayers", FilterFlags::NOPLAYERS);
         if let Some(v) = self.clver {
-            write!(fmt, "\\clver\\{}", v)?;
+            write!(fmt, "\\clver\\{v}")?;
         }
         display_flag!("nat", FilterFlags::NAT);
         display_flag!("lan", FilterFlags::LAN);
         display_flag!("bots", FilterFlags::BOTS);
         if let Some(x) = self.key {
-            write!(fmt, "\\key\\{:x}", x)?;
+            write!(fmt, "\\key\\{x:x}")?;
         }
         if let Some(x) = self.protocol {
-            write!(fmt, "\\protocol\\{}", x)?;
+            write!(fmt, "\\protocol\\{x}")?;
         }
         if let Some(x) = self.client_buildnum {
-            write!(fmt, "\\buildnum\\{}", x)?;
+            write!(fmt, "\\buildnum\\{x}")?;
         }
         if let Some(x) = self.client_os {
-            write!(fmt, "\\os\\{}", x)?;
+            write!(fmt, "\\os\\{x}")?;
         }
         if let Some(x) = self.client_arch {
-            write!(fmt, "\\arch\\{}", x)?;
+            write!(fmt, "\\arch\\{x}")?;
         }
         if let Some(x) = self.client_branch {
-            write!(fmt, "\\branch\\{}", x)?;
+            write!(fmt, "\\branch\\{x}")?;
         }
         if let Some(x) = self.client_commit {
-            write!(fmt, "\\commit\\{}", x)?;
+            write!(fmt, "\\commit\\{x}")?;
         }
         Ok(())
     }