refactor(wc): deduplicate C locale detection

Author: naoNao89

src/uu/uniq/Cargo.toml

@@ -21,8 +21,8 @@ doctest = false
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["parser"] }
 fluent = { workspace = true }
+uucore = { workspace = true, features = ["i18n-charmap", "parser"] }
 
 [dev-dependencies]
 divan = { workspace = true }

src/uu/uniq/src/uniq.rs

@@ -14,6 +14,7 @@ use std::num::IntErrorKind;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult, USimpleError};
 use uucore::format_usage;
+use uucore::i18n::charmap::is_effective_ctype_c_or_posix;
 use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 use uucore::posix::{OBSOLETE, posix_version};
 use uucore::translate;
@@ -186,14 +187,6 @@ impl Uniq {
         }
     }
 
-    fn is_c_locale() -> bool {
-        ["LC_ALL", "LC_CTYPE", "LANG"]
-            .iter()
-            .find_map(|&key| std::env::var_os(key))
-            .filter(|v| !v.is_empty())
-            .is_none_or(|v| v == "C" || v == "POSIX")
-    }
-
     fn key_end_index(&self, line: &[u8], key_start: usize) -> usize {
         let remainder = &line[key_start..];
         match self.slice_stop {
@@ -202,7 +195,7 @@ impl Uniq {
                 if remainder.is_empty() {
                     return key_start;
                 }
-                if Self::is_c_locale() {
+                if is_effective_ctype_c_or_posix() {
                     // for C or POSIX we count bytes
                     key_start + remainder.len().min(limit)
                 } else if let Ok(valid) = std::str::from_utf8(remainder) {

src/uu/wc/Cargo.toml

@@ -26,6 +26,7 @@ fluent = { workspace = true }
 thiserror = { workspace = true }
 uucore = { workspace = true, features = [
   "hardware",
+  "i18n-charmap",
   "parser",
   "pipes",
   "quoting-style",

src/uu/wc/src/count_fast.rs

@@ -6,27 +6,10 @@
 // spell-checker:ignore sysconf CTYPE
 use crate::{wc_simd_allowed, word_count::WordCount};
 use uucore::hardware::SimdPolicy;
+use uucore::i18n::charmap::is_effective_ctype_c_or_posix;
 
 use super::WordCountable;
 
-/// Check if the current locale is C or POSIX (where characters == bytes).
-/// This follows GNU coreutils behavior where MB_CUR_MAX == 1 in these locales.
-pub(crate) fn is_c_or_posix_locale() -> bool {
-    // Check LC_ALL, LC_CTYPE, and LANG in order of precedence
-    let locale_val = ["LC_ALL", "LC_CTYPE", "LANG"]
-        .iter()
-        .find_map(|&var| std::env::var(var).ok().filter(|v| !v.is_empty()));
-
-    if let Some(locale) = locale_val {
-        // Extract the base locale name (before any '.' or '@')
-        let base_locale = locale.split(&['.', '@']).next().unwrap_or(&locale);
-        base_locale == "C" || base_locale == "POSIX"
-    } else {
-        // No locale set, default to POSIX behavior (chars == bytes)
-        true
-    }
-}
-
 use std::io::{self, ErrorKind, Read};
 
 #[cfg(unix)]
@@ -242,7 +225,7 @@ pub(crate) fn count_bytes_chars_and_lines_fast<
 
     // In C/POSIX locale, characters are equivalent to bytes (MB_CUR_MAX == 1).
     // This follows GNU coreutils behavior.
-    let chars_are_bytes = is_c_or_posix_locale();
+    let chars_are_bytes = is_effective_ctype_c_or_posix();
 
     loop {
         match handle.read(buf) {

src/uu/wc/src/wc.rs

@@ -26,7 +26,7 @@ use clap::{Arg, ArgAction, ArgMatches, Command, builder::ValueParser};
 use thiserror::Error;
 use unicode_width::UnicodeWidthChar;
 use utf8::{BufReadDecoder, BufReadDecoderError};
-use uucore::{display::Quotable, translate};
+use uucore::{display::Quotable, i18n::charmap::is_effective_ctype_c_or_posix, translate};
 
 use uucore::{
     error::{FromIo, UError, UResult},
@@ -38,7 +38,7 @@ use uucore::{
 };
 
 use crate::{
-    count_fast::{count_bytes_chars_and_lines_fast, count_bytes_fast, is_c_or_posix_locale},
+    count_fast::{count_bytes_chars_and_lines_fast, count_bytes_fast},
     countable::WordCountable,
     word_count::WordCount,
 };
@@ -663,7 +663,7 @@ fn word_count_from_reader_specialized<
     let mut in_word = false;
     let mut current_len = 0;
     let is_posixly_correct = *IS_POSIXLY_CORRECT;
-    let chars_are_bytes = SHOW_CHARS && is_c_or_posix_locale();
+    let chars_are_bytes = SHOW_CHARS && is_effective_ctype_c_or_posix();
     while let Some(chunk) = reader.next_strict() {
         match chunk {
             Ok(text) => {

src/uucore/src/lib/features/i18n/charmap.rs

@@ -9,6 +9,8 @@
 
 use std::sync::OnceLock;
 
+const CTYPE_LOCALE_VARS: [&str; 3] = ["LC_ALL", "LC_CTYPE", "LANG"];
+
 enum MbEncoding {
     Utf8,
     Gb18030,
@@ -27,12 +29,29 @@ fn encoding_from_name(enc: &str) -> MbEncoding {
     }
 }
 
+/// Return the effective `LC_CTYPE` locale value from the environment.
+///
+/// Empty values are ignored, matching the locale precedence used for character
+/// map detection.
+pub fn get_effective_ctype_locale() -> Option<String> {
+    CTYPE_LOCALE_VARS
+        .iter()
+        .find_map(|&key| std::env::var(key).ok().filter(|v| !v.is_empty()))
+}
+
+/// Return whether the effective `LC_CTYPE` locale is the byte-oriented C/POSIX locale.
+///
+/// A missing effective locale defaults to POSIX behavior. Only exact `C` and
+/// `POSIX` locale values are treated as explicit C/POSIX locales; locales such
+/// as `C.UTF-8` are not.
+pub fn is_effective_ctype_c_or_posix() -> bool {
+    get_effective_ctype_locale().is_none_or(|locale| locale == "C" || locale == "POSIX")
+}
+
 fn get_encoding() -> &'static MbEncoding {
     static ENCODING: OnceLock<MbEncoding> = OnceLock::new();
     ENCODING.get_or_init(|| {
-        let val = ["LC_ALL", "LC_CTYPE", "LANG"]
-            .iter()
-            .find_map(|&k| std::env::var(k).ok().filter(|v| !v.is_empty()));
+        let val = get_effective_ctype_locale();
         let s = match val.as_deref() {
             Some(s) if s != "C" && s != "POSIX" => s,
             _ => return MbEncoding::Utf8,