Apply new cargo clippy & fmt

Author: tao-guo

examples/pipes.rs

@@ -65,8 +65,7 @@ tls_init!(SETS, Vec<char>, vec![]);
 // pipes'
 tls_init!(x, Vec<i32>, vec![]); // current position
 tls_init!(y, Vec<i32>, vec![]);
-tls_init!(l, Vec<i32>, vec![]); // current directions
-                                // 0: up, 1: right, 2: down, 3: left
+tls_init!(l, Vec<i32>, vec![]); // current directions, 0: up, 1: right, 2: down, 3: left
 tls_init!(n, Vec<i32>, vec![]); // new directions
 tls_init!(v, Vec<i32>, vec![]); // current types
 tls_init!(c, Vec<String>, vec![]); // current escape codes

examples/progress.rs

@@ -1,4 +1,4 @@
-use cmd_lib::{run_cmd, CmdResult};
+use cmd_lib::{CmdResult, run_cmd};
 
 #[cmd_lib::main]
 fn main() -> CmdResult {

examples/tetris.rs

@@ -77,9 +77,10 @@ const filled_cell: &str = "[]"; // how we draw filled cell
 tls_init!(use_color, bool, true); // true if we use color, false if not
 tls_init!(score, i32, 0); // score variable initialization
 tls_init!(level, i32, 1); // level variable initialization
-tls_init!(lines_completed, i32, 0); // completed lines counter initialization
-                                    // screen_buffer is variable, that accumulates all screen changes
-                                    // this variable is printed in controller once per game cycle
+// completed lines counter initialization
+// screen_buffer is variable, that accumulates all screen changes
+// this variable is printed in controller once per game cycle
+tls_init!(lines_completed, i32, 0);
 tls_init!(screen_buffer, String, "".to_string());
 
 fn puts(changes: &str) {

examples/tracing.rs

@@ -1,6 +1,6 @@
-use cmd_lib::{run_cmd, CmdResult};
+use cmd_lib::{CmdResult, run_cmd};
 use tracing::level_filters::LevelFilter;
-use tracing_subscriber::{layer::SubscriberExt as _, util::SubscriberInitExt as _, EnvFilter};
+use tracing_subscriber::{EnvFilter, layer::SubscriberExt as _, util::SubscriberInitExt as _};
 
 #[cmd_lib::main]
 fn main() -> CmdResult {

macros/src/lexer.rs

@@ -1,6 +1,6 @@
 use crate::parser::{ParseArg, Parser};
-use proc_macro2::{token_stream, Delimiter, Ident, Literal, Span, TokenStream, TokenTree};
 use proc_macro_error2::abort;
+use proc_macro2::{Delimiter, Ident, Literal, Span, TokenStream, TokenTree, token_stream};
 use quote::quote;
 use std::iter::Peekable;
 use std::str::Chars;
@@ -65,7 +65,7 @@ pub fn scan_str_lit(lit: &Literal) -> TokenStream {
                 // If it's braced, we might have a format specifier or it might just be empty braces.
                 if chars.peek() == Some(&':') {
                     chars.next(); // Consume ':'
-                                  // Read the format specifier until '}'
+                    // Read the format specifier until '}'
                     while let Some(&c) = chars.peek() {
                         if c == '}' {
                             break;
@@ -290,14 +290,13 @@ impl Lexer {
             self.extend_last_arg(quote!(#ss.into_os_string()));
         } else {
             let mut is_redirect = false;
-            if s == "1" || s == "2" {
-                if let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap() {
-                    if p.as_char() == '>' {
-                        self.iter.next();
-                        self.scan_redirect_out(if s == "1" { 1 } else { 2 });
-                        is_redirect = true;
-                    }
-                }
+            if (s == "1" || s == "2")
+                && let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap()
+                && p.as_char() == '>'
+            {
+                self.iter.next();
+                self.scan_redirect_out(if s == "1" { 1 } else { 2 });
+                is_redirect = true;
             }
             if !is_redirect {
                 self.extend_last_arg(quote!(#s));
@@ -306,15 +305,15 @@ impl Lexer {
     }
 
     fn scan_pipe(&mut self) {
-        if let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap() {
-            if p.as_char() == '&' {
-                if let Some(ref redirect) = self.last_redirect {
-                    abort!(redirect.1, "invalid '&': found previous redirect");
-                }
-                Self::check_set_redirect(&mut self.seen_redirect.2, "stderr", p.span());
-                self.args.push(ParseArg::RedirectFd(2, 1));
-                self.iter.next();
+        if let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap()
+            && p.as_char() == '&'
+        {
+            if let Some(ref redirect) = self.last_redirect {
+                abort!(redirect.1, "invalid '&': found previous redirect");
             }
+            Self::check_set_redirect(&mut self.seen_redirect.2, "stderr", p.span());
+            self.args.push(ParseArg::RedirectFd(2, 1));
+            self.iter.next();
         }
 
         // expect new command
@@ -342,29 +341,29 @@ impl Lexer {
                 RedirectFd::Stderr { append }
             },
         );
-        if let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap() {
-            if p.as_char() == '&' {
-                if append {
-                    abort!(p.span(), "raw fd not allowed for append redirection");
+        if let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap()
+            && p.as_char() == '&'
+        {
+            if append {
+                abort!(p.span(), "raw fd not allowed for append redirection");
+            }
+            self.iter.next();
+            if let Some(TokenTree::Literal(lit)) = self.iter.peek_no_gap() {
+                let s = lit.to_string();
+                if s.starts_with('\"') || s.starts_with('r') {
+                    abort!(lit.span(), "invalid literal string after &");
                 }
-                self.iter.next();
-                if let Some(TokenTree::Literal(lit)) = self.iter.peek_no_gap() {
-                    let s = lit.to_string();
-                    if s.starts_with('\"') || s.starts_with('r') {
-                        abort!(lit.span(), "invalid literal string after &");
-                    }
-                    if &s == "1" {
-                        self.args.push(ParseArg::RedirectFd(fd, 1));
-                    } else if &s == "2" {
-                        self.args.push(ParseArg::RedirectFd(fd, 2));
-                    } else {
-                        abort!(lit.span(), "Only &1 or &2 is supported");
-                    }
-                    self.last_redirect = None;
-                    self.iter.next();
+                if &s == "1" {
+                    self.args.push(ParseArg::RedirectFd(fd, 1));
+                } else if &s == "2" {
+                    self.args.push(ParseArg::RedirectFd(fd, 2));
                 } else {
-                    abort!(self.iter.span(), "expect &1 or &2");
+                    abort!(lit.span(), "Only &1 or &2 is supported");
                 }
+                self.last_redirect = None;
+                self.iter.next();
+            } else {
+                abort!(self.iter.span(), "expect &1 or &2");
             }
         }
     }
@@ -436,11 +435,11 @@ impl Lexer {
 
     fn check_append(&mut self) -> bool {
         let mut append = false;
-        if let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap() {
-            if p.as_char() == '>' {
-                append = true;
-                self.iter.next();
-            }
+        if let Some(TokenTree::Punct(p)) = self.iter.peek_no_gap()
+            && p.as_char() == '>'
+        {
+            append = true;
+            self.iter.next();
         }
         append
     }

macros/src/lib.rs

@@ -102,8 +102,8 @@
 //! run_cmd!(ls / /x >> > /tmp/f);
 //! ```
 
-use proc_macro2::{TokenStream, TokenTree};
 use proc_macro_error2::{abort, proc_macro_error};
+use proc_macro2::{TokenStream, TokenTree};
 use quote::quote;
 
 /// Mark main function to log error result by default.

src/builtins.rs

@@ -1,5 +1,5 @@
-use crate::{debug, error, info, trace, warn};
 use crate::{CmdEnv, CmdResult};
+use crate::{debug, error, info, trace, warn};
 use std::io::{Read, Write};
 
 pub(crate) fn builtin_echo(env: &mut CmdEnv) -> CmdResult {

src/child.rs

@@ -1,5 +1,5 @@
+use crate::{CmdResult, FunResult, process};
 use crate::{info, warn};
-use crate::{process, CmdResult, FunResult};
 use os_pipe::PipeReader;
 use std::any::Any;
 use std::fmt::Display;
@@ -90,10 +90,10 @@ impl FunChildren {
     /// Waits for the children processes to exit completely, returning the stdout output.
     pub fn wait_with_output(&mut self) -> FunResult {
         let (res, stdout, _) = self.inner_wait_with_all(false);
-        if let Err(e) = res {
-            if !self.ignore_error {
-                return Err(e);
-            }
+        if let Err(e) = res
+            && !self.ignore_error
+        {
+            return Err(e);
         }
         Ok(stdout)
     }
@@ -110,11 +110,7 @@ impl FunChildren {
             }
             Ok(_) => {
                 let ret = CmdChildren::wait_children(&mut self.children);
-                if self.ignore_error {
-                    Ok(())
-                } else {
-                    ret
-                }
+                if self.ignore_error { Ok(()) } else { ret }
             }
         }
     }
@@ -234,10 +230,10 @@ impl CmdChild {
         let _stderr_thread =
             StderrThread::new(&self.cmd, &self.file, self.line, self.stderr.take(), false);
         let res = self.handle.wait(&self.cmd, &self.file, self.line);
-        if let Err(e) = res {
-            if is_last || process::pipefail_enabled() {
-                return Err(e);
-            }
+        if let Err(e) = res
+            && (is_last || process::pipefail_enabled())
+        {
+            return Err(e);
         }
         Ok(())
     }
@@ -265,10 +261,10 @@ impl CmdChild {
             capture_stderr,
         );
         let mut stdout_res = Ok(());
-        if let Some(mut stdout) = self.stdout.take() {
-            if let Err(e) = stdout.read_to_end(stdout_buf) {
-                stdout_res = Err(e)
-            }
+        if let Some(mut stdout) = self.stdout.take()
+            && let Err(e) = stdout.read_to_end(stdout_buf)
+        {
+            stdout_res = Err(e)
         }
         *stderr_buf = stderr_thread.join();
         let wait_res = self.handle.wait(&self.cmd, &self.file, self.line);

src/lib.rs

@@ -399,8 +399,8 @@ pub use log as inner_log;
 #[doc(hidden)]
 pub use logger::try_init_default_logger;
 #[doc(hidden)]
-pub use process::{register_cmd, AsOsStr, Cmd, CmdString, Cmds, GroupCmds, Redirect};
-pub use process::{set_debug, set_pipefail, CmdEnv, ScopedDebug, ScopedPipefail};
+pub use process::{AsOsStr, Cmd, CmdString, Cmds, GroupCmds, Redirect, register_cmd};
+pub use process::{CmdEnv, ScopedDebug, ScopedPipefail, set_debug, set_pipefail};
 
 mod builtins;
 mod child;

src/process.rs

@@ -1,8 +1,8 @@
 use crate::builtins::*;
 use crate::child::{CmdChild, CmdChildHandle, CmdChildren, FunChildren};
 use crate::io::{CmdIn, CmdOut};
-use crate::{debug, warn};
 use crate::{CmdResult, FunResult};
+use crate::{debug, warn};
 use faccess::{AccessMode, PathExt};
 use os_pipe::{self, PipeReader, PipeWriter};
 use std::cell::Cell;
@@ -246,10 +246,10 @@ impl GroupCmds {
 
     pub fn run_cmd(&mut self) -> CmdResult {
         for cmds in self.group_cmds.iter_mut() {
-            if let Err(e) = cmds.run_cmd(&mut self.current_dir) {
-                if !cmds.ignore_error {
-                    return Err(e);
-                }
+            if let Err(e) = cmds.run_cmd(&mut self.current_dir)
+                && !cmds.ignore_error
+            {
+                return Err(e);
             }
         }
         Ok(())
@@ -449,11 +449,11 @@ impl Cmd {
 
         let arg_str = arg.to_string_lossy().to_string();
         if arg_str != IGNORE_CMD && !self.args.iter().any(|cmd| *cmd != IGNORE_CMD) {
-            if let Some((key, value)) = arg_str.split_once('=') {
-                if key.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
-                    self.vars.insert(key.into(), value.into());
-                    return self;
-                }
+            if let Some((key, value)) = arg_str.split_once('=')
+                && key.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
+            {
+                self.vars.insert(key.into(), value.into());
+                return self;
             }
             self.in_cmd_map = CMD_MAP.lock().unwrap().contains_key(arg);
         }
@@ -779,11 +779,13 @@ mod tests {
     #[test]
     fn test_run_piped_cmds() {
         let mut current_dir = PathBuf::new();
-        assert!(Cmds::default()
-            .pipe(Cmd::default().add_args(["echo", "rust"]))
-            .pipe(Cmd::default().add_args(["wc"]))
-            .run_cmd(&mut current_dir)
-            .is_ok());
+        assert!(
+            Cmds::default()
+                .pipe(Cmd::default().add_args(["echo", "rust"]))
+                .pipe(Cmd::default().add_args(["wc"]))
+                .run_cmd(&mut current_dir)
+                .is_ok()
+        );
     }
 
     #[test]
@@ -814,10 +816,12 @@ mod tests {
         let tmp_file = "/tmp/file_echo_rust";
         let mut write_cmd = Cmd::default().add_args(["echo", "rust"]);
         write_cmd = write_cmd.add_redirect(Redirect::StdoutToFile(PathBuf::from(tmp_file), false));
-        assert!(Cmds::default()
-            .pipe(write_cmd)
-            .run_cmd(&mut current_dir)
-            .is_ok());
+        assert!(
+            Cmds::default()
+                .pipe(write_cmd)
+                .run_cmd(&mut current_dir)
+                .is_ok()
+        );
 
         let read_cmd = Cmd::default().add_args(["cat", tmp_file]);
         assert_eq!(
@@ -829,9 +833,11 @@ mod tests {
         );
 
         let cleanup_cmd = Cmd::default().add_args(["rm", tmp_file]);
-        assert!(Cmds::default()
-            .pipe(cleanup_cmd)
-            .run_cmd(&mut current_dir)
-            .is_ok());
+        assert!(
+            Cmds::default()
+                .pipe(cleanup_cmd)
+                .run_cmd(&mut current_dir)
+                .is_ok()
+        );
     }
 }