refactor ~ cargo make format

src/uu/od/src/prn_int.rs

@@ -153,7 +153,10 @@ fn test_format_item_hex() {
     assert_eq!(" 00000000", format_item_hex32(0));
     assert_eq!(" ffffffff", format_item_hex32(0xffff_ffff));
     assert_eq!(" 0000000000000000", format_item_hex64(0));
-    assert_eq!(" ffffffffffffffff", format_item_hex64(0xffff_ffff_ffff_ffff));
+    assert_eq!(
+        " ffffffffffffffff",
+        format_item_hex64(0xffff_ffff_ffff_ffff)
+    );
 }
 
 #[test]

src/uu/printf/src/tokenize/num_format/formatter.rs

@@ -1,4 +1,3 @@
-
 //! Primitives used by num_format and sub_modules.
 //! never dealt with above (e.g. Sub Tokenizer never uses these)
 

src/uu/printf/src/tokenize/num_format/formatters/cninetyninehexfloatf.rs

@@ -25,8 +25,13 @@ impl Formatter for CninetyNineHexFloatf {
         str_in: &str,
     ) -> Option<FormatPrimitive> {
         let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis =
+        let analysis = FloatAnalysis::analyze(
-            FloatAnalysis::analyze(&str_in, initial_prefix, Some(second_field as usize), None, true);
+            &str_in,
+            initial_prefix,
+            Some(second_field as usize),
+            None,
+            true,
+        );
         let f = get_primitive_hex(
             initial_prefix,
             &str_in[initial_prefix.offset..],
@@ -51,7 +56,11 @@ fn get_primitive_hex(
     _last_dec_place: usize,
     capitalized: bool,
 ) -> FormatPrimitive {
-    let prefix = Some(String::from(if initial_prefix.sign == -1 { "-0x" } else { "0x" }));
+    let prefix = Some(String::from(if initial_prefix.sign == -1 {
+        "-0x"
+    } else {
+        "0x"
+    }));
 
     // TODO actual conversion, make sure to get back mantissa.
     // for hex to hex, it's really just a matter of moving the

src/uu/printf/src/tokenize/num_format/formatters/decf.rs

@@ -76,11 +76,13 @@ impl Formatter for Decf {
             second_field as usize,
             None,
         );
-        Some(if get_len_fmt_primitive(&f_fl) >= get_len_fmt_primitive(&f_sci) {
+        Some(
+            if get_len_fmt_primitive(&f_fl) >= get_len_fmt_primitive(&f_sci) {
                 f_sci
             } else {
                 f_fl
-        })
+            },
+        )
     }
     fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
         primitive_to_str_common(prim, &field)

src/uu/printf/src/tokenize/num_format/formatters/float_common.rs

@@ -2,7 +2,9 @@
 // spell-checker:ignore (ToDO) arrnum
 
 use super::super::format_field::FormatField;
-use super::super::formatter::{get_it_at, warn_incomplete_conv, Base, FormatPrimitive, InitialPrefix};
+use super::super::formatter::{
+    get_it_at, warn_incomplete_conv, Base, FormatPrimitive, InitialPrefix,
+};
 use super::base_conv;
 use super::base_conv::RadixDef;
 

src/uu/printf/src/tokenize/num_format/formatters/floatf.rs

@@ -20,8 +20,13 @@ impl Formatter for Floatf {
         str_in: &str,
     ) -> Option<FormatPrimitive> {
         let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis =
+        let analysis = FloatAnalysis::analyze(
-            FloatAnalysis::analyze(&str_in, initial_prefix, None, Some(second_field as usize), false);
+            &str_in,
+            initial_prefix,
+            None,
+            Some(second_field as usize),
+            false,
+        );
         let f = get_primitive_dec(
             initial_prefix,
             &str_in[initial_prefix.offset..],

src/uu/printf/src/tokenize/num_format/formatters/intf.rs

@@ -150,7 +150,12 @@ impl Intf {
     // - if the string falls outside bounds:
     //   for i64 output, the int minimum or int max (depending on sign)
     //   for u64 output, the u64 max in the output radix
-    fn conv_from_segment(segment: &str, radix_in: Base, field_char: char, sign: i8) -> FormatPrimitive {
+    fn conv_from_segment(
+        segment: &str,
+        radix_in: Base,
+        field_char: char,
+        sign: i8,
+    ) -> FormatPrimitive {
         match field_char {
             'i' | 'd' => match i64::from_str_radix(segment, radix_in as u32) {
                 Ok(i) => {

src/uu/stat/src/stat.rs

@@ -475,12 +475,14 @@ impl Stater {
         let show_fs = matches.is_present(options::FILE_SYSTEM);
 
         let default_tokens = if format_str.is_empty() {
-            Stater::generate_tokens(&Stater::default_format(show_fs, terse, false), use_printf).unwrap()
+            Stater::generate_tokens(&Stater::default_format(show_fs, terse, false), use_printf)
+                .unwrap()
         } else {
             Stater::generate_tokens(&format_str, use_printf)?
         };
         let default_dev_tokens =
-            Stater::generate_tokens(&Stater::default_format(show_fs, terse, true), use_printf).unwrap();
+            Stater::generate_tokens(&Stater::default_format(show_fs, terse, true), use_printf)
+                .unwrap();
 
         let mount_list = if show_fs {
             // mount points aren't displayed when showing filesystem information
@@ -540,8 +542,9 @@ impl Stater {
             match result {
                 Ok(meta) => {
                     let file_type = meta.file_type();
-                    let tokens =
+                    let tokens = if self.from_user
-                        if self.from_user || !(file_type.is_char_device() || file_type.is_block_device()) {
+                        || !(file_type.is_char_device() || file_type.is_block_device())
+                    {
                         &self.default_tokens
                     } else {
                         &self.default_dev_tokens
@@ -867,7 +870,8 @@ impl Stater {
         } else {
             format_str.push_str("  File: %N\n  Size: %-10s\tBlocks: %-10b IO Block: %-6o %F\n");
             if show_dev_type {
-                format_str.push_str("Device: %Dh/%dd\tInode: %-10i  Links: %-5h Device type: %t,%T\n");
+                format_str
+                    .push_str("Device: %Dh/%dd\tInode: %-10i  Links: %-5h Device type: %t,%T\n");
             } else {
                 format_str.push_str("Device: %Dh/%dd\tInode: %-10i  Links: %h\n");
             }

tests/by-util/test_factor.rs

@@ -209,7 +209,10 @@ fn test_big_primes() {
 
 fn run(input_string: &[u8], output_string: &[u8]) {
     println!("STDIN='{}'", String::from_utf8_lossy(input_string));
-    println!("STDOUT(expected)='{}'", String::from_utf8_lossy(output_string));
+    println!(
+        "STDOUT(expected)='{}'",
+        String::from_utf8_lossy(output_string)
+    );
     // now run factor
     new_ucmd!()
         .pipe_in(input_string)

tests/by-util/test_more.rs

@@ -5,7 +5,8 @@ fn test_more_no_arg() {
     // Reading from stdin is now supported, so this must succeed
     if atty::is(atty::Stream::Stdout) {
         new_ucmd!().succeeds();
-    } else {}
+    } else {
+    }
 }
 
 #[test]
@@ -19,5 +20,6 @@ fn test_more_dir_arg() {
         const EXPECTED_ERROR_MESSAGE: &str =
             "more: '.' is a directory.\nTry 'more --help' for more information.";
         assert_eq!(result.stderr_str().trim(), EXPECTED_ERROR_MESSAGE);
-    } else {}
+    } else {
+    }
 }

tests/by-util/test_truncate.rs

@@ -47,12 +47,7 @@ fn test_reference() {
 
     scene.ucmd().arg("-s").arg("+5KB").arg(FILE1).run();
 
-    scene
+    scene.ucmd().arg("--reference").arg(FILE1).arg(FILE2).run();
-        .ucmd()
-        .arg("--reference")
-        .arg(FILE1)
-        .arg(FILE2)
-        .run();
 
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.seek(SeekFrom::Current(0)).unwrap();