119 lines
4.4 KiB
Rust
119 lines
4.4 KiB
Rust
use anyhow::Result;
|
|
|
|
pub fn init() -> Result<()> {
|
|
#[cfg(target_os = "macos")]
|
|
mac::init()?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
mod mac {
|
|
#![allow(clippy::let_unit_value)]
|
|
|
|
use std::ffi::{CStr, CString};
|
|
use std::{env, str};
|
|
|
|
use libc::{setlocale, LC_ALL, LC_CTYPE};
|
|
use objc2::runtime::NSObjectProtocol;
|
|
use objc2::sel;
|
|
use objc2_foundation::NSLocale;
|
|
|
|
use super::*;
|
|
|
|
const FALLBACK_LOCALE: &str = "UTF-8";
|
|
|
|
pub fn init() -> Result<()> {
|
|
set_locale_environment();
|
|
|
|
// Switch to home directory.
|
|
env::set_current_dir(dirs::home_dir().unwrap()).unwrap();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_locale_environment() {
|
|
let env_locale_c = CString::new("").expect("Should never fail to create empty CString");
|
|
let env_locale_ptr = unsafe { setlocale(LC_ALL, env_locale_c.as_ptr()) };
|
|
if !env_locale_ptr.is_null() {
|
|
let env_locale = unsafe { CStr::from_ptr(env_locale_ptr).to_string_lossy() };
|
|
|
|
// Assume `C` locale means unchanged, since it is the default anyways.
|
|
if env_locale != "C" {
|
|
log::debug!("Using locale ({env_locale}) already set via LC_ALL");
|
|
return;
|
|
}
|
|
}
|
|
|
|
let system_locale = system_locale();
|
|
if is_valid_locale(&system_locale).unwrap_or(false) {
|
|
// Use system locale.
|
|
log::debug!("Using system locale ({system_locale}) for LANG");
|
|
|
|
// Set the LANG variable to suggest (but not require) use of the
|
|
// given locale. This avoids errors when ssh-ing into a remote
|
|
// machine which doesn't have the given locale available.
|
|
env::set_var("LANG", system_locale);
|
|
} else {
|
|
// Use fallback locale.
|
|
log::debug!("Using fallback locale ({FALLBACK_LOCALE}) for LC_CTYPE");
|
|
|
|
// When using a fallback, only set LC_CTYPE.
|
|
env::set_var("LC_CTYPE", FALLBACK_LOCALE);
|
|
}
|
|
}
|
|
|
|
/// Checks whether a given locale is valid.
|
|
///
|
|
/// This changes the current value of LC_CTYPE in order to check validity,
|
|
/// but restores the previous value before returning.
|
|
fn is_valid_locale(locale: &str) -> Result<bool> {
|
|
unsafe {
|
|
let check_locale = CString::new("")?;
|
|
let new_locale = CString::new(locale)?;
|
|
|
|
let old_locale = setlocale(LC_CTYPE, check_locale.as_ptr());
|
|
let is_valid = !setlocale(LC_CTYPE, new_locale.as_ptr()).is_null();
|
|
setlocale(LC_CTYPE, old_locale);
|
|
Ok(is_valid)
|
|
}
|
|
}
|
|
|
|
/// Determine system locale based on language and country code.
|
|
//
|
|
// `NSLocale::countryCode` is deprecated in the SDK, but we keep using it to
|
|
// assemble a POSIX locale string; there is no non-deprecated accessor that
|
|
// returns the bare country code.
|
|
#[allow(deprecated)]
|
|
fn system_locale() -> String {
|
|
// Read the current locale from `NSLocale`. objc2 returns each getter
|
|
// result as a `Retained`, which claims the autoreleased value and
|
|
// releases it on drop.
|
|
let locale = NSLocale::currentLocale();
|
|
|
|
// `localeIdentifier` returns extra metadata with the locale (including currency and
|
|
// collator) on newer versions of macOS. This is not a valid locale, so we use
|
|
// `languageCode` and `countryCode`, if they're available (macOS 10.12+):
|
|
//
|
|
// https://developer.apple.com/documentation/foundation/nslocale/1416263-localeidentifier?language=objc
|
|
// https://developer.apple.com/documentation/foundation/nslocale/1643060-countrycode?language=objc
|
|
// https://developer.apple.com/documentation/foundation/nslocale/1643026-languagecode?language=objc
|
|
let is_language_code_supported = locale.respondsToSelector(sel!(languageCode));
|
|
let is_country_code_supported = locale.respondsToSelector(sel!(countryCode));
|
|
if is_language_code_supported && is_country_code_supported {
|
|
let language_code = locale.languageCode().to_string();
|
|
// `countryCode` is nil for a region-less locale, so degrade to an
|
|
// empty country.
|
|
let country_code = locale
|
|
.countryCode()
|
|
.map(|c| c.to_string())
|
|
.unwrap_or_default();
|
|
|
|
format!("{language_code}_{country_code}.UTF-8")
|
|
} else {
|
|
let identifier = locale.localeIdentifier().to_string();
|
|
|
|
identifier + ".UTF-8"
|
|
}
|
|
}
|
|
}
|