System locale

Cargo.toml

@@ -66,6 +66,7 @@ members = [
     "utils/litemap",
     "utils/pattern",
     "utils/resb",
+    "utils/env_preferences",
     "utils/tinystr",
     "utils/tzif",
     "utils/writeable",

utils/env_preferences/Cargo.toml

@@ -0,0 +1,33 @@
+# This file is part of ICU4X. For terms of use, please see the file
+# called LICENSE at the top level of the ICU4X source tree
+# (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+[package]
+name = "env_preferences"
+version.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+edition.workspace = true
+repository.workspace = true
+homepage.workspace = true
+license.workspace = true
+categories.workspace = true
+include.workspace = true
+
+[dependencies]
+core-foundation-sys = "0.8.6"
+libc = "0.2.155"
+
+[dependencies.windows]
+version = "0.56.0"
+features = [
+    "System",
+    "Foundation",
+    "System_UserProfile",
+    "Foundation_Collections",
+    "Globalization",
+    "Globalization_DateTimeFormatting",
+    "Win32",
+    "Win32_Globalization"
+
+]

utils/env_preferences/LICENSE

@@ -0,0 +1,46 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 2020-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0
+
+—
+
+Portions of ICU4X may have been adapted from ICU4C and/or ICU4J.
+ICU 1.8.1 to ICU 57.1 © 1995-2016 International Business Machines Corporation and others.

utils/env_preferences/src/apple.rs

@@ -0,0 +1,89 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+pub mod apple_locales_prefs {
+    use core_foundation_sys::{
+        array::{CFArrayGetCount, CFArrayGetValueAtIndex},
+        calendar::{CFCalendarCopyCurrent, CFCalendarCopyLocale, CFCalendarGetIdentifier},
+        locale::{CFLocaleCopyPreferredLanguages, CFLocaleGetIdentifier},
+        string::CFStringGetCStringPtr,
+    };
+    use std::ffi::CStr;
+
+    pub fn get_locales_mac() -> Vec<String> {
+        let mut languages: Vec<String> = Vec::new();
+
+        unsafe {
+            let locale_carr_ref = CFLocaleCopyPreferredLanguages();
+            if !locale_carr_ref.is_null() {
+                let count = CFArrayGetCount(locale_carr_ref as _);
+
+                for i in 0..count {
+                    let lang_ptr = CFArrayGetValueAtIndex(locale_carr_ref as _, i);
+                    if !lang_ptr.is_null() {
+                        let lang_str = CFStringGetCStringPtr(lang_ptr as _, 0);
+                        if !lang_str.is_null() {
+                            let lang_rust_str = CStr::from_ptr(lang_str)
+                                .to_str()
+                                .unwrap_or("Unknown")
+                                .to_string();
+                            languages.push(lang_rust_str);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Defaulting to `und`
+        if languages.is_empty() {
+            languages.push(String::from("und"));
+        }
+        languages
+    }
+
+    pub fn get_system_calendars_macos() -> Vec<(String, String)> {
+        let mut calendars = Vec::new();
+        let mut calendar_locale_str = String::new();
+        let mut calendar_identifier_str = String::new();
+
+        unsafe {
+            let calendar = CFCalendarCopyCurrent();
+            if !calendar.is_null() {
+                let locale = CFCalendarCopyLocale(calendar as _);
+                let identifier = CFCalendarGetIdentifier(calendar as _);
+
+                if !locale.is_null() {
+                    let locale_identifier = CFLocaleGetIdentifier(locale);
+                    let locale_cstr = CFStringGetCStringPtr(locale_identifier, 0);
+
+                    if !locale_cstr.is_null() {
+                        calendar_locale_str = CStr::from_ptr(locale_cstr)
+                            .to_str()
+                            .unwrap_or("")
+                            .to_string();
+                    }
+                }
+
+                if !identifier.is_null() {
+                    let identifier_cstr = CFStringGetCStringPtr(identifier, 0);
+
+                    if !identifier_cstr.is_null() {
+                        calendar_identifier_str = CStr::from_ptr(identifier_cstr)
+                            .to_str()
+                            .unwrap_or("")
+                            .to_string();
+                    }
+                }
+
+                calendars.push((calendar_locale_str, calendar_identifier_str.clone()));
+            }
+        }
+
+        if calendars.is_empty() {
+            calendars.push((String::from("und"), String::from("Gregorian")));
+        }
+
+        calendars
+    }
+}

utils/env_preferences/src/lib.rs

@@ -0,0 +1,14 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! Retrieval of system locales and preferences.
+
+#[cfg(target_os = "linux")]
+pub mod linux;
+
+#[cfg(target_os = "macos")]
+pub mod apple;
+
+#[cfg(target_os = "windows")]
+mod windows;

utils/env_preferences/src/linux.rs

@@ -0,0 +1,71 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+pub mod linux_locales_prefs {
+    use std::{
+        borrow::Cow,
+        collections::{HashMap, HashSet},
+        ffi::CStr,
+        ptr,
+    };
+
+    use libc::{setlocale, LC_ALL, LC_TIME};
+
+    fn fetch_locale_settings() -> HashMap<String, String> {
+        let mut locale_map = HashMap::new();
+
+        // Thread safety is ensured by fallbacking to the default locale of `linux` which is `C`
+        unsafe {
+            let locales_ptr = setlocale(LC_ALL, ptr::null());
+            let locales = CStr::from_ptr(locales_ptr);
+
+            if let Ok(locales_str) = locales.to_str() {
+                let locales_slice = locales_str.split(';');
+                for locale in locales_slice {
+                    let mut locale_parts = locale.split('=');
+                    if let (Some(key), Some(value)) = (locale_parts.next(), locale_parts.next()) {
+                        locale_map.insert(key.to_string(), value.to_string());
+                    }
+                }
+            } else {
+                locale_map.insert(String::from("LC_ALL"), String::from("C"));
+            }
+        }
+
+        locale_map
+    }
+
+    pub fn get_locales_linux() -> Vec<String> {
+        let mut unique_locales = HashSet::new();
+        let locale_map = fetch_locale_settings();
+        for value in locale_map.values() {
+            unique_locales.insert(value.clone());
+        }
+
+        unique_locales.into_iter().collect()
+    }
+
+    pub fn get_system_calendars_linux(
+    ) -> Box<dyn Iterator<Item = (Cow<'static, str>, Cow<'static, str>)>> {
+        unsafe {
+            let locale_ptr = setlocale(LC_TIME, ptr::null());
+            if !locale_ptr.is_null() {
+                let c_str = CStr::from_ptr(locale_ptr);
+                if let Ok(str_slice) = c_str.to_str() {
+                    return Box::new(
+                        Some((
+                            Cow::Owned(str_slice.to_string()),
+                            Cow::Borrowed("Gregorian"),
+                        ))
+                        .into_iter(),
+                    );
+                }
+            }
+            Box::new(
+                None.into_iter()
+                    .chain(Some((Cow::Borrowed("C"), Cow::Borrowed("Gregorian")))),
+            )
+        }
+    }
+}