feat(ls,du,df): add thousands separator support with leading quote

Implement GNU-compatible thousands separator formatting when --block-size
starts with a single quote (e.g., --block-size="'1").

Fixes #9084

Changes:
- Add extract_thousands_separator_flag() to parse_size module
- Add format_with_thousands_separator() with locale support (LC_NUMERIC)
- Integrate into ls, du, and df utilities
- Support environment variables (LS_BLOCK_SIZE, DU_BLOCK_SIZE, etc.)
- Add 12 integration tests, all existing tests pass

Examples:
  ls -l --block-size="'1" /bin    # Shows: 1,024,000
  du --block-size="'1K" /home     # Shows: 1,234K
  df --block-size="'1" /          # Shows: 494,384,795,648

Author: naoNao89

.vscode/cspell.dictionaries/workspace.wordlist.txt

@@ -363,6 +363,8 @@ getcwd
 # * other
 weblate
 algs
+largefile
+verylargefile
 
 # translation tests
 CLICOLOR

src/uu/df/Cargo.toml

@@ -19,7 +19,13 @@ path = "src/df.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["libc", "fsext", "parser", "fs"] }
+uucore = { workspace = true, features = [
+  "libc",
+  "fsext",
+  "parser",
+  "fs",
+  "format",
+] }
 unicode-width = { workspace = true }
 thiserror = { workspace = true }
 fluent = { workspace = true }

src/uu/df/src/blocks.rs

@@ -9,7 +9,9 @@ use std::{env, fmt};
 
 use uucore::{
     display::Quotable,
-    parser::parse_size::{ParseSizeError, parse_size_non_zero_u64, parse_size_u64},
+    parser::parse_size::{
+        ParseSizeError, extract_thousands_separator_flag, parse_size_non_zero_u64, parse_size_u64,
+    },
 };
 
 /// The first ten powers of 1024.
@@ -160,6 +162,13 @@ pub(crate) enum BlockSize {
     Bytes(u64),
 }
 
+/// Configuration for block size display, including thousands separator flag.
+#[derive(Debug, PartialEq)]
+pub(crate) struct BlockSizeConfig {
+    pub(crate) block_size: BlockSize,
+    pub(crate) use_thousands_separator: bool,
+}
+
 impl BlockSize {
     /// Returns the associated value
     pub(crate) fn as_u64(&self) -> u64 {
@@ -191,29 +200,47 @@ impl Default for BlockSize {
     }
 }
 
-pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSize, ParseSizeError> {
+pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSizeConfig, ParseSizeError> {
     if matches.contains_id(OPT_BLOCKSIZE) {
         let s = matches.get_one::<String>(OPT_BLOCKSIZE).unwrap();
-        let bytes = parse_size_u64(s)?;
+        let (cleaned, use_thousands) = extract_thousands_separator_flag(s);
+        let bytes = parse_size_u64(cleaned)?;
 
         if bytes > 0 {
-            Ok(BlockSize::Bytes(bytes))
+            Ok(BlockSizeConfig {
+                block_size: BlockSize::Bytes(bytes),
+                use_thousands_separator: use_thousands,
+            })
         } else {
             Err(ParseSizeError::ParseFailure(format!("{}", s.quote())))
         }
     } else if matches.get_flag(OPT_PORTABILITY) {
-        Ok(BlockSize::default())
-    } else if let Some(bytes) = block_size_from_env() {
-        Ok(BlockSize::Bytes(bytes))
+        Ok(BlockSizeConfig {
+            block_size: BlockSize::default(),
+            use_thousands_separator: false,
+        })
+    } else if let Some((bytes, use_thousands)) = block_size_from_env() {
+        Ok(BlockSizeConfig {
+            block_size: BlockSize::Bytes(bytes),
+            use_thousands_separator: use_thousands,
+        })
     } else {
-        Ok(BlockSize::default())
+        Ok(BlockSizeConfig {
+            block_size: BlockSize::default(),
+            use_thousands_separator: false,
+        })
     }
 }
 
-fn block_size_from_env() -> Option<u64> {
+fn block_size_from_env() -> Option<(u64, bool)> {
     for env_var in ["DF_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"] {
         if let Ok(env_size) = env::var(env_var) {
-            return parse_size_non_zero_u64(&env_size).ok();
+            let (cleaned, use_thousands) = extract_thousands_separator_flag(&env_size);
+            if let Ok(size) = parse_size_non_zero_u64(cleaned) {
+                return Some((size, use_thousands));
+            }
+            // If env var is set but invalid, return None (don't check other env vars)
+            return None;
         }
     }
 

src/uu/df/src/df.rs

@@ -25,7 +25,7 @@ use std::io::stdout;
 use std::path::Path;
 use thiserror::Error;
 
-use crate::blocks::{BlockSize, read_block_size};
+use crate::blocks::{BlockSize, BlockSizeConfig, read_block_size};
 use crate::columns::{Column, ColumnError};
 use crate::filesystem::Filesystem;
 use crate::filesystem::FsError;
@@ -62,7 +62,7 @@ struct Options {
     show_local_fs: bool,
     show_all_fs: bool,
     human_readable: Option<HumanReadable>,
-    block_size: BlockSize,
+    block_size_config: BlockSizeConfig,
     header_mode: HeaderMode,
 
     /// Optional list of filesystem types to include in the output table.
@@ -92,7 +92,10 @@ impl Default for Options {
         Self {
             show_local_fs: Default::default(),
             show_all_fs: Default::default(),
-            block_size: BlockSize::default(),
+            block_size_config: BlockSizeConfig {
+                block_size: BlockSize::default(),
+                use_thousands_separator: false,
+            },
             human_readable: Option::default(),
             header_mode: HeaderMode::default(),
             include: Option::default(),
@@ -160,7 +163,7 @@ impl Options {
             show_local_fs: matches.get_flag(OPT_LOCAL),
             show_all_fs: matches.get_flag(OPT_ALL),
             sync: matches.get_flag(OPT_SYNC),
-            block_size: read_block_size(matches).map_err(|e| match e {
+            block_size_config: read_block_size(matches).map_err(|e| match e {
                 ParseSizeError::InvalidSuffix(s) => OptionsError::InvalidSuffix(s),
                 ParseSizeError::SizeTooBig(_) => OptionsError::BlockSizeTooLarge(
                     matches.get_one::<String>(OPT_BLOCKSIZE).unwrap().to_owned(),

src/uu/df/src/table.rs

@@ -13,6 +13,7 @@ use crate::blocks::{SuffixType, to_magnitude_and_suffix};
 use crate::columns::{Alignment, Column};
 use crate::filesystem::Filesystem;
 use crate::{BlockSize, Options};
+use uucore::format::human::format_with_thousands_separator;
 use uucore::fsext::{FsUsage, MountInfo};
 use uucore::translate;
 
@@ -266,8 +267,13 @@ impl<'a> RowFormatter<'a> {
         let s = if let Some(h) = self.options.human_readable {
             to_magnitude_and_suffix(size.into(), SuffixType::HumanReadable(h), true)
         } else {
-            let BlockSize::Bytes(d) = self.options.block_size;
-            (size as f64 / d as f64).ceil().to_string()
+            let BlockSize::Bytes(d) = self.options.block_size_config.block_size;
+            let result = (size as f64 / d as f64).ceil() as u64;
+            if self.options.block_size_config.use_thousands_separator {
+                format_with_thousands_separator(result)
+            } else {
+                result.to_string()
+            }
         };
         Cell::from_ascii_string(s)
     }
@@ -373,13 +379,13 @@ impl Header {
                     HeaderMode::PosixPortability => {
                         format!(
                             "{}{}",
-                            options.block_size.as_u64(),
+                            options.block_size_config.block_size.as_u64(),
                             translate!("df-blocks-suffix")
                         )
                     }
                     _ => format!(
                         "{}{}",
-                        options.block_size.to_header(),
+                        options.block_size_config.block_size.to_header(),
                         translate!("df-blocks-suffix")
                     ),
                 },
@@ -642,7 +648,10 @@ mod tests {
     fn test_header_with_block_size_1024() {
         init();
         let options = Options {
-            block_size: BlockSize::Bytes(3 * 1024),
+            block_size_config: crate::blocks::BlockSizeConfig {
+                block_size: BlockSize::Bytes(3 * 1024),
+                use_thousands_separator: false,
+            },
             ..Default::default()
         };
         assert_eq!(
@@ -722,7 +731,10 @@ mod tests {
     fn test_row_formatter() {
         init();
         let options = Options {
-            block_size: BlockSize::Bytes(1),
+            block_size_config: crate::blocks::BlockSizeConfig {
+                block_size: BlockSize::Bytes(1),
+                use_thousands_separator: false,
+            },
             ..Default::default()
         };
         let row = Row {
@@ -748,7 +760,10 @@ mod tests {
         init();
         let options = Options {
             columns: COLUMNS_WITH_FS_TYPE.to_vec(),
-            block_size: BlockSize::Bytes(1),
+            block_size_config: crate::blocks::BlockSizeConfig {
+                block_size: BlockSize::Bytes(1),
+                use_thousands_separator: false,
+            },
             ..Default::default()
         };
         let row = Row {
@@ -775,7 +790,10 @@ mod tests {
         init();
         let options = Options {
             columns: COLUMNS_WITH_INODES.to_vec(),
-            block_size: BlockSize::Bytes(1),
+            block_size_config: crate::blocks::BlockSizeConfig {
+                block_size: BlockSize::Bytes(1),
+                use_thousands_separator: false,
+            },
             ..Default::default()
         };
         let row = Row {
@@ -801,7 +819,10 @@ mod tests {
         init();
         let options = Options {
             columns: vec![Column::Size, Column::Itotal],
-            block_size: BlockSize::Bytes(100),
+            block_size_config: crate::blocks::BlockSizeConfig {
+                block_size: BlockSize::Bytes(100),
+                use_thousands_separator: false,
+            },
             ..Default::default()
         };
         let row = Row {
@@ -903,7 +924,10 @@ mod tests {
         init();
         fn get_formatted_values(bytes: u64, bytes_used: u64, bytes_avail: u64) -> Vec<Cell> {
             let options = Options {
-                block_size: BlockSize::Bytes(1000),
+                block_size_config: crate::blocks::BlockSizeConfig {
+                    block_size: BlockSize::Bytes(1000),
+                    use_thousands_separator: false,
+                },
                 columns: vec![Column::Size, Column::Used, Column::Avail],
                 ..Default::default()
             };

src/uu/du/src/du.rs

@@ -30,8 +30,11 @@ use uucore::line_ending::LineEnding;
 use uucore::safe_traversal::DirFd;
 use uucore::translate;
 
+use uucore::format::human::format_with_thousands_separator;
 use uucore::parser::parse_glob;
-use uucore::parser::parse_size::{ParseSizeError, parse_size_non_zero_u64, parse_size_u64};
+use uucore::parser::parse_size::{
+    ParseSizeError, extract_thousands_separator_flag, parse_size_non_zero_u64, parse_size_u64,
+};
 use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 use uucore::time::{FormatSystemTimeFallback, format, format_system_time};
 use uucore::{format_usage, show, show_error, show_warning};
@@ -91,6 +94,7 @@ struct StatPrinter {
     threshold: Option<Threshold>,
     apparent_size: bool,
     size_format: SizeFormat,
+    use_thousands_separator: bool,
     time: Option<MetadataTimeField>,
     time_format: String,
     line_ending: LineEnding,
@@ -271,26 +275,33 @@ fn get_file_info(path: &Path, _metadata: &Metadata) -> Option<FileInfo> {
     result
 }
 
-fn block_size_from_env() -> Option<u64> {
+fn block_size_from_env() -> Option<(u64, bool)> {
     for env_var in ["DU_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"] {
         if let Ok(env_size) = env::var(env_var) {
-            return parse_size_non_zero_u64(&env_size).ok();
+            let (cleaned, use_thousands) = extract_thousands_separator_flag(&env_size);
+            if let Ok(size) = parse_size_non_zero_u64(cleaned) {
+                return Some((size, use_thousands));
+            }
+            // If env var is set but invalid, return None (don't check other env vars)
+            return None;
         }
     }
 
     None
 }
 
-fn read_block_size(s: Option<&str>) -> UResult<u64> {
+fn read_block_size(s: Option<&str>) -> UResult<(u64, bool)> {
     if let Some(s) = s {
-        parse_size_u64(s)
+        let (cleaned, use_thousands) = extract_thousands_separator_flag(s);
+        parse_size_u64(cleaned)
+            .map(|size| (size, use_thousands))
             .map_err(|e| USimpleError::new(1, format_error_message(&e, s, options::BLOCK_SIZE)))
-    } else if let Some(bytes) = block_size_from_env() {
-        Ok(bytes)
+    } else if let Some((bytes, use_thousands)) = block_size_from_env() {
+        Ok((bytes, use_thousands))
     } else if env::var("POSIXLY_CORRECT").is_ok() {
-        Ok(512)
+        Ok((512, false))
     } else {
-        Ok(1024)
+        Ok((1024, false))
     }
 }
 
@@ -874,7 +885,12 @@ impl StatPrinter {
                     // we ignore block size (-B) with --inodes
                     size.to_string()
                 } else {
-                    size.div_ceil(block_size).to_string()
+                    let result = size.div_ceil(block_size);
+                    if self.use_thousands_separator {
+                        format_with_thousands_separator(result)
+                    } else {
+                        result.to_string()
+                    }
                 }
             }
         }
@@ -1005,24 +1021,24 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             .map_or(MetadataTimeField::Modification, |s| s.as_str().into())
     });
 
-    let size_format = if matches.get_flag(options::HUMAN_READABLE) {
-        SizeFormat::HumanBinary
+    let (size_format, use_thousands_separator) = if matches.get_flag(options::HUMAN_READABLE) {
+        (SizeFormat::HumanBinary, false)
     } else if matches.get_flag(options::SI) {
-        SizeFormat::HumanDecimal
+        (SizeFormat::HumanDecimal, false)
     } else if matches.get_flag(options::BYTES) {
-        SizeFormat::BlockSize(1)
+        (SizeFormat::BlockSize(1), false)
     } else if matches.get_flag(options::BLOCK_SIZE_1K) {
-        SizeFormat::BlockSize(1024)
+        (SizeFormat::BlockSize(1024), false)
     } else if matches.get_flag(options::BLOCK_SIZE_1M) {
-        SizeFormat::BlockSize(1024 * 1024)
+        (SizeFormat::BlockSize(1024 * 1024), false)
     } else {
         let block_size_str = matches.get_one::<String>(options::BLOCK_SIZE);
-        let block_size = read_block_size(block_size_str.map(AsRef::as_ref))?;
+        let (block_size, use_thousands) = read_block_size(block_size_str.map(AsRef::as_ref))?;
         if block_size == 0 {
             return Err(std::io::Error::other(translate!("du-error-invalid-block-size-argument", "option" => options::BLOCK_SIZE, "value" => block_size_str.map_or("???BUG", |v| v).quote()))
             .into());
         }
-        SizeFormat::BlockSize(block_size)
+        (SizeFormat::BlockSize(block_size), use_thousands)
     };
 
     let traversal_options = TraversalOptions {
@@ -1051,6 +1067,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let stat_printer = StatPrinter {
         max_depth,
         size_format,
+        use_thousands_separator,
         summarize,
         total: matches.get_flag(options::TOTAL),
         inodes: matches.get_flag(options::INODES),
@@ -1508,7 +1525,11 @@ mod test_du {
     fn test_read_block_size() {
         let test_data = [Some("1024".to_string()), Some("K".to_string()), None];
         for it in &test_data {
-            assert!(matches!(read_block_size(it.as_deref()), Ok(1024)));
+            assert!(matches!(read_block_size(it.as_deref()), Ok((1024, false))));
         }
+
+        // Test with thousands separator flag
+        assert!(matches!(read_block_size(Some("'1024")), Ok((1024, true))));
+        assert!(matches!(read_block_size(Some("'1K")), Ok((1024, true))));
     }
 }