feat(df): add thousands separator support with locale-aware formatting

Adds thousands separator support to df command with locale-aware formatting:
- Implements get_thousands_separator() with ICU library integration
- Adds French locale support (narrow no-break space U+202F)
- Adds English locale support (comma separator)
- Fixes macOS POSIX locale detection
- Ensures POSIX/C standard compliance for default behavior

Changes include:
- Core thousands separator implementation in uucore
- df-specific integration in blocks.rs, df.rs, and table.rs

Author: naoNao89

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

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

Cargo.lock

@@ -362,6 +362,7 @@ regex = "1.10.4"
 rstest = "0.26.0"
 rust-ini = "0.21.0"
 same-file = "1.0.6"
+serial_test = "3.1"
 self_cell = "1.0.4"
 # FIXME we use the exact version because the new 0.5.3 requires an MSRV of 1.88
 selinux = "=0.5.2"

Cargo.toml

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

src/uu/df/Cargo.toml

@@ -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/blocks.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(),