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

Implements thousands separator formatting for ls, du, and df commands with
support for leading quote format specifier. Adds comprehensive locale handling
using ICU4X when available, with fallback implementations for common locales.

Core changes:
- Add get_thousands_separator() with ICU4X support and locale caching
- Implement fallback logic for French (U+202F), English (comma), and POSIX
- Add leading quote format support to df, du, and ls
- Include locale-specific test helpers with cache bypass

Fixes:
- French locale (fr_*) now returns correct U+202F separator instead of '.'
- English locale (en_*) fallback now returns ',' instead of '\0'
- POSIX locale detection uses direct constant comparison for reliability
- Default return value correctly returns '\0' for unavailable locales

Dependencies:
- Add icu_decimal and serial_test for locale testing
- Update Cargo.lock with new dependencies

Tests:
- Add comprehensive locale and format tests for df, du, ls
- Include tests for thousands separator edge cases and locale handling

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(),