finchie/cli_framework - Change UN2XEIEUIB4ERS3IXOHQT2GCPBKK3JKHCGEVKQFP4SCV5AONFXMQC

Migrate from `locale_select` to `env_preferences`

The env_preferences crate is being developed under ICU4X by a GSOC student, so it makes sense to switch over. The implementation is probably very flaky, but should work for now.

Created by finchie on August 29, 2024

UN2XEIEUIB4ERS3IXOHQT2GCPBKK3JKHCGEVKQFP4SCV5AONFXMQC

Dependencies

In channels

main

Change contents

File deletion: locale_select
BF:BFD[7.1] → [8.0:24]
BF:BFD[8.24] → [8.25:25]
File deletion: Cargo.toml
BF:BFD[8.25] → [8.5414:5448]
BF:BFD[8.5448] → [8.5449:5449]
B:BD[8.5449] → [8.5450:5518]
∅:D[9.246] → [8.5518:5534]
B:BD[8.5518] → [8.5518:5534]
B:BD[8.5534] → [10.1593:1654]
B:BD[10.1654] → [11.0:20]
∅:D[11.20] → [9.247:264]
B:BD[8.5554] → [9.247:264]
B:BD[9.264] → [12.5644:5685]
B:BD[8.5518] → [9.220:246]
```
[package]
name = "locale_select"
version = "0.1.0"
edition = "2021"
[dependencies]
fluent-langneg = { version = "0.14.0", features = ["cldr"] }
icu_locid = "1.5.0"
libc = "0.2.153"
[dev-dependencies]
gettext-rs = "0.7.0"
[lints]
workspace = true
```
File deletion: src
BF:BFD[8.25] → [8.439:453]
BF:BFD[8.453] → [8.454:454]

File deletion: lib.rs

BF:BFD[8.454] → [8.5367:5397]

BF:BFD[8.5397] → [8.5398:5398]

∅:D[13.11] → [8.5399:5413]

∅:D[9.354] → [8.5399:5413]

B:BD[8.5398] → [8.5399:5413]

B:BD[8.5413] → [10.605:606]

∅:D[9.404] → [10.606:700]

B:BD[10.606] → [10.606:700]

B:BD[10.700] → [9.405:431]

∅:D[9.431] → [10.731:799]

B:BD[10.731] → [10.731:799]

B:BD[10.799] → [9.432:513]

∅:D[9.513] → [10.877:1045]

B:BD[10.877] → [10.877:1045]

B:BD[10.1045] → [9.514:817]

∅:D[9.817] → [10.1162:1164]

B:BD[10.1162] → [10.1162:1164]

B:BD[10.606] → [9.355:404]

B:BD[8.5398] → [10.527:604]

B:BD[10.604] → [9.339:354]

pub mod unix;
pub fn match_locales(
    available: &[LanguageIdentifier],
    default: &LanguageIdentifier,
) -> LanguageIdentifier {
    // TODO: requesting locales should have platform-specific logic
    let requested = unix::get_locales(fetch::unix::LocaleCategory::LC_MESSAGES);
    let supported = fluent_langneg::negotiate_languages(
        &requested,
        &available,
        Some(&default),
        NegotiationStrategy::Matching,
    );
    // TODO: properly handle this case
    if let [single_locale] = supported[..] {
        // TODO: this is wasteful but avoids dealing with lifetimes for now
        single_locale.to_owned()
    } else {
        todo!("Multiple locales returned, which is not yet handled. Got: {supported:#?}");
    }
}
// TODO: this can probably be enums, not strings
use fluent_langneg::NegotiationStrategy;
use icu_locid::LanguageIdentifier;
pub mod fetch;

File deletion: unix.rs

BF:BFD[8.454] → [8.456:487]

BF:BFD[8.487] → [8.488:488]

∅:D[14.406] → [8.489:2640]

B:BD[8.488] → [8.489:2640]

∅:D[2.2] → [8.2640:2641]

B:BD[8.2640] → [8.2640:2641]

B:BD[8.2641] → [2.3:145]

∅:D[2.145] → [8.2692:5364]

B:BD[8.2692] → [8.2692:5364]

∅:D[10.526] → [8.5364:5366]

∅:D[14.1320] → [8.5364:5366]

B:BD[8.5364] → [8.5364:5366]

B:BD[8.5364] → [14.407:1320]

B:BD[14.1320] → [10.95:185]

B:BD[10.185] → [9.308:338]

∅:D[9.338] → [10.208:526]

B:BD[10.208] → [10.208:526]

B:BD[8.2640] → [2.0:2]

B:BD[8.488] → [14.114:234]

B:BD[14.234] → [9.265:307]

∅:D[10.52] → [14.276:321]

∅:D[9.307] → [14.276:321]

B:BD[14.276] → [14.276:321]

∅:D[10.94] → [14.321:406]

B:BD[14.321] → [14.321:406]

B:BD[14.321] → [10.53:94]

#[derive(Debug, Clone, Copy)]
enum OptionalSubtagType {
    Territory,
    Codeset,
    Modifier,
}
impl OptionalSubtagType {
    const fn try_from_char(source: char) -> Option<Self> {
        match source {
            '_' => Some(Self::Territory),
            '.' => Some(Self::Codeset),
            '@' => Some(Self::Modifier),
            _ => None,
        }
    }
}
#[derive(Debug, Clone, Copy)]
struct SubtagIndex {
    separator: OptionalSubtagType,
    separator_index: usize,
}
impl SubtagIndex {
    const fn try_from_char(captures: (usize, char)) -> Option<Self> {
        // Closure captures a tuple of length 2, destructure for readability
        let (index, source) = captures;
        if let Some(separator) = OptionalSubtagType::try_from_char(source) {
            Some(Self {
                separator,
                separator_index: index,
            })
        } else {
            None
        }
    }
    fn from_str_with_offset(source: &str, index_offset: usize) -> Option<Self> {
        source
            .chars()
            .enumerate()
            .skip(index_offset)
            .find_map(Self::try_from_char)
    }
}
#[derive(Debug, Clone, Copy)]
struct OptionalSubtag {
    start_index: usize,
    end_index: usize,
    subtag_type: OptionalSubtagType,
}
#[derive(Debug, Clone, Copy)]
struct OptionalSubtagsIterator<'locale> {
    source: &'locale str,
    current_subtag: Option<SubtagIndex>,
    next_subtag: Option<SubtagIndex>,
}
impl<'locale> OptionalSubtagsIterator<'locale> {
    fn new(source: &'locale str) -> Self {
        let current_subtag = if let Some(first_character) = source.chars().next() {
            let subtag = SubtagIndex::try_from_char((0, first_character)).expect(&format!(
                "The first character in `{source}` ('{first_character}') is not a valid separator."
            ));
            Some(subtag)
        } else {
            // The source locale is empty, return an empty iterator
            None
        };
        Self {
            source,
            current_subtag,
            next_subtag: SubtagIndex::from_str_with_offset(&source, 1),
        }
    }
impl<'locale> Iterator for OptionalSubtagsIterator<'locale> {
    type Item = OptionalSubtag;
    fn next(&mut self) -> Option<Self::Item> {
        // If the current subtag is empty, all work is done
        let current_subtag = self.current_subtag.take()?;
        let next_subtag = self.next_subtag.take();
        // Get the index of the next separator
        // If this is the last subtag then this is the length of the source
        let next_separator = next_subtag
            .as_ref()
            .map(|next_index| next_index.separator_index)
            .unwrap_or(self.source.len());
        // Modify internal state for the next iteration
        self.current_subtag = next_subtag;
        self.next_subtag = if next_separator < self.source.len() {
            SubtagIndex::from_str_with_offset(&self.source, next_separator + 1)
        } else {
            None
        };
        Some(OptionalSubtag {
            start_index: current_subtag.separator_index + 1,
            end_index: next_separator,
            subtag_type: current_subtag.separator,
        })
    }
}
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
pub struct PosixLocale<'locale> {
    pub language: &'locale str,
    pub territory: Option<&'locale str>,
    pub codeset: Option<&'locale str>,
    pub modifier: Option<&'locale str>,
}
impl<'locale> PosixLocale<'locale> {
    pub fn from_str(source: &'locale str) -> Self {
        let additional_subtags_start = source
            .chars()
            .position(|character| OptionalSubtagType::try_from_char(character).is_some());
        let language_end_bound = additional_subtags_start.unwrap_or(source.len());
        let mut locale = PosixLocale {
            language: &source[..language_end_bound],
            ..Default::default()
        };
        assert!(!locale.language.is_empty());
        let mut subtags_iter = OptionalSubtagsIterator::new(&source[language_end_bound..]);
        while let Some(subtag) = subtags_iter.next() {
            let OptionalSubtag {
                start_index,
                end_index,
                ..
            } = subtag;
            // Offset based on language boundary
            let start_index = start_index + language_end_bound;
            let end_index = end_index + language_end_bound;
            assert!(start_index <= source.len());
            assert!(end_index <= source.len());
            let subtag_slice = &source[start_index..end_index];
            match subtag.subtag_type {
                OptionalSubtagType::Territory => locale.territory = Some(subtag_slice),
                OptionalSubtagType::Codeset => locale.codeset = Some(subtag_slice),
                OptionalSubtagType::Modifier => locale.modifier = Some(subtag_slice),
            };
        }
        locale
    }
}
    pub fn icu_locale(&self) -> Result<Locale, icu_locid::ParserError> {
        let language = subtags::Language::try_from_bytes(self.language.as_bytes())?;
        let region = if let Some(territory) = self.territory {
            Some(subtags::Region::try_from_bytes(territory.as_bytes())?)
        } else {
            None
        };
        // TODO: should script/variants always be empty?
        let language_id = LanguageIdentifier {
            language,
            script: None,
            region,
            variants: Variants::new(),
        };
        // TODO: should attributes always be empty?
        let unicode_extensions = Unicode {
            keywords: POSIX_KEYWORD,
            attributes: Attributes::new(),
        };
        let extensions = Extensions::from_unicode(unicode_extensions);
        Ok(Locale {
            id: language_id,
            extensions,
        })
    }
}
pub fn get_locales(category: LocaleCategory) -> Vec<LanguageIdentifier> {
    category
        .get_locales_custom()
        .iter()
        .map(|locale_str| PosixLocale::from_str(locale_str))
        .map(|posix_locale| posix_locale.icu_locale())
        .filter_map(|potential_locale| potential_locale.ok())
        // TODO: is it ok to strip this posix metadata from the locale?
        .map(|locale| locale.id)
        .collect()
}
use icu_locid::extensions::unicode::{key, value, Attributes, Keywords, Unicode};
use icu_locid::extensions::Extensions;
use icu_locid::subtags::{self, Variants};
use icu_locid::{LanguageIdentifier, Locale};
const POSIX_KEYWORD: Keywords = Keywords::new_single(key!("va"), value!("posix"));
use crate::fetch::unix::LocaleCategory;

File deletion: fetch
BF:BFD[8.454] → [13.12:28]
BF:BFD[13.28] → [13.29:29]
File deletion: mod.rs
BF:BFD[13.29] → [13.1612:1642]
BF:BFD[13.1642] → [13.1643:1643]
B:BD[13.1643] → [10.1578:1592]
```
pub mod unix;
```

File deletion: unix.rs

BF:BFD[13.29] → [13.31:62]

BF:BFD[13.62] → [13.63:63]

B:BD[13.63] → [13.64:78]

B:BD[13.78] → [9.818:1184]

∅:D[9.1184] → [13.78:79]

B:BD[13.78] → [13.78:79]

B:BD[13.79] → [9.1185:1629]

∅:D[9.1629] → [13.269:270]

B:BD[13.269] → [13.269:270]

B:BD[13.270] → [9.1630:1824]

∅:D[9.1824] → [13.875:891]

B:BD[13.875] → [13.875:891]

B:BD[13.891] → [9.1825:2049]

∅:D[9.2049] → [13.893:894]

B:BD[13.893] → [13.893:894]

B:BD[13.894] → [9.2050:2447]

∅:D[9.2447] → [13.921:1247]

B:BD[13.921] → [13.921:1247]

B:BD[13.1247] → [9.2448:2502]

∅:D[9.2502] → [10.1262:1312]

B:BD[10.1262] → [10.1262:1312]

∅:D[10.1312] → [13.1292:1348]

B:BD[13.1292] → [13.1292:1348]

B:BD[13.1348] → [10.1313:1471]

∅:D[10.1471] → [13.1593:1603]

B:BD[13.1593] → [13.1593:1603]

∅:D[10.1577] → [13.1603:1611]

∅:D[9.2734] → [13.1603:1611]

B:BD[13.1603] → [13.1603:1611]

B:BD[13.1603] → [10.1472:1560]

B:BD[10.1560] → [10.1560:1561]

B:BD[10.1561] → [10.1561:1577]

B:BD[10.1577] → [9.2503:2734]

use std::env;
use std::ffi::CStr;
const NUL_BYTE: &[u8] = b"\0";
macro_rules! repr_lc {
    ($($variant:ident),+) => {
        #[derive(Clone, Copy, Debug)]
        #[allow(non_camel_case_types)] // Required for parity with C enum
        pub enum LocaleCategory {
            $($variant,)*
        }
        impl TryFrom<i32> for LocaleCategory {
            type Error = ();
            fn try_from(value: i32) -> Result<Self, Self::Error> {
                match value {
                    $(libc::$variant => Ok(Self::$variant),)*
                    _ => Err(())
                }
            }
        }
        impl Into<i32> for LocaleCategory {
            fn into(self) -> i32 {
                match self {
                    $(Self::$variant => libc::$variant,)*
                }
            }
        }
        impl LocaleCategory {
            fn as_str(&self) -> &str {
                match self {
                    $(Self::$variant => stringify!($variant),)*
                }
            }
        }
    }
}
repr_lc! {
    LC_ALL,
    LC_CTYPE,
    LC_COLLATE,
    LC_MESSAGES,
    LC_MONETARY,
    LC_NUMERIC,
    LC_TIME,
    LC_ADDRESS,
    LC_IDENTIFICATION,
    LC_MEASUREMENT,
    LC_NAME,
    LC_PAPER,
    LC_TELEPHONE
}
// TODO: handle and document safety invariants
fn get_locale_libc(category: i32) -> String {
    let empty_cstr = CStr::from_bytes_with_nul(NUL_BYTE).unwrap();
    let locale_string_pointer = unsafe { libc::setlocale(category, empty_cstr.as_ptr()) };
    let locale_c_str = unsafe { CStr::from_ptr(locale_string_pointer) };
    locale_c_str.to_str().unwrap().to_string()
}
impl LocaleCategory {
    /// Query the locale following the POSIX spec:
    /// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html#tag_08_02
    ///
    /// Order of precedence:
    /// 1. LC_ALL
    /// 2. LC_{NUMERIC, TIME, etc}
    /// 3. LANG
    /// 4. Default locale (handled by caller, this function will return None)
    pub fn get_locales_custom(&self) -> Vec<String> {
        let mut locales = Vec::with_capacity(3);
        if let Ok(global_locale) = env::var("LC_ALL") {
            locales.push(global_locale);
        }
        if let Ok(category_locale) = env::var(self.as_str()) {
            locales.push(category_locale);
        }
    }
}
        if let Ok(lang) = env::var("LANG") {
            locales.push(lang);
        }
        locales
    }
    pub fn get_locales_libc(self) -> Vec<String> {
        let global_locale = get_locale_libc(libc::LC_ALL);
        let locale_for_category = get_locale_libc(self.into());
        vec![global_locale, locale_for_category]

File deletion: tests
BF:BFD[8.25] → [8.27:43]
BF:BFD[8.43] → [8.44:44]

File deletion: unix.rs

BF:BFD[8.44] → [8.46:77]

BF:BFD[8.77] → [8.78:78]

B:BD[8.78] → [12.2464:2618]

∅:D[12.2618] → [8.79:117]

B:BD[8.78] → [8.79:117]

B:BD[8.117] → [12.2619:3092]

∅:D[12.3092] → [8.117:436]

B:BD[8.117] → [8.117:436]

∅:D[14.113] → [8.436:438]

B:BD[8.436] → [8.436:438]

B:BD[8.438] → [12.3093:5643]

B:BD[8.436] → [14.0:113]

use std::collections::HashSet;
use gettextrs::LocaleCategory as GettextCategory;
use locale_select::fetch::unix::LocaleCategory as LocaleSelectCategory;
use locale_select::unix::PosixLocale;
const GETTEXT_CATEGORIES: [GettextCategory; 13] = [
    GettextCategory::LcAll,
    GettextCategory::LcCType,
    GettextCategory::LcCollate,
    GettextCategory::LcMessages,
    GettextCategory::LcMonetary,
    GettextCategory::LcNumeric,
    GettextCategory::LcTime,
    GettextCategory::LcAddress,
    GettextCategory::LcIdentification,
    GettextCategory::LcMeasurement,
    GettextCategory::LcName,
    GettextCategory::LcPaper,
    GettextCategory::LcTelephone,
];
#[test]
fn simple_en_us() {
    let locale = "en_US.utf8";
    let parsed_locale = PosixLocale::from_str(locale);
    assert_eq!(
        parsed_locale,
        PosixLocale {
            language: "en",
            territory: Some("US"),
            codeset: Some("utf8"),
            modifier: None,
        }
    );
}
#[test]
/// Exactly compare the output of get_locales_libc() with get_locales_custom()
fn compare_libc_with_custom_impl_exact() {
    for gettext_category in GETTEXT_CATEGORIES {
        let locale_select_category =
            LocaleSelectCategory::try_from(gettext_category as i32).unwrap();
        let libc_locales = locale_select_category.get_locales_libc();
        let custom_locales = locale_select_category.get_locales_custom();
        assert_eq!(libc_locales, custom_locales);
    }
}
#[test]
/// Compare the output of get_locales_libc() with get_locales_custom() using a HashSet
///
/// This will make sure that both functions return the same data, even if it's not
/// in the same order or items are duplicated. If the `_exact()` variant of this test
/// fails, this test may still pass.
fn compare_libc_with_custom_impl_hash_set() {
    for gettext_category in GETTEXT_CATEGORIES {
        let locale_select_category =
            LocaleSelectCategory::try_from(gettext_category as i32).unwrap();
        let libc_locales: HashSet<String> =
            HashSet::from_iter(locale_select_category.get_locales_libc().into_iter());
        let custom_locales: HashSet<String> =
            HashSet::from_iter(locale_select_category.get_locales_custom().into_iter());
        assert_eq!(
            libc_locales
                .symmetric_difference(&custom_locales)
                .collect::<Vec<_>>(),
            Vec::<&String>::new()
        );
    }
}
#[test]
/// Compare get_locales_libc() with the implementation from gettext-rs
fn compare_libc_with_gettext() {
    for gettext_category in GETTEXT_CATEGORIES {
        let locale_select_category =
            LocaleSelectCategory::try_from(gettext_category as i32).unwrap();
        let libc_locales = locale_select_category.get_locales_libc();
        let gettext_locales =
            String::from_utf8(gettextrs::setlocale(gettext_category, b"").unwrap()).unwrap();
        assert_eq!(libc_locales[0], gettext_locales);
    }
}
#[test]
/// Compare get_locales_custom() with the implementation from gettext-rs
fn compare_custom_with_gettext() {
    for gettext_category in GETTEXT_CATEGORIES {
        let locale_select_category =
            LocaleSelectCategory::try_from(gettext_category as i32).unwrap();
        let custom_locales = locale_select_category.get_locales_custom();
        let gettext_locales =
            String::from_utf8(gettextrs::setlocale(gettext_category, b"").unwrap()).unwrap();
        assert_eq!(custom_locales[0], gettext_locales);
    }
}
    assert_eq!(
        parsed_locale.icu_locale().unwrap(),
        "en-US-u-va-posix".parse().unwrap()
    );

File deletion: README.md

BF:BFD[8.25] → [3.0:33]

BF:BFD[3.33] → [3.34:34]

B:BD[3.34] → [3.35:1664]

# `locale_select`
A simple library for selecting the user's locale preferences for various ICU4X modules, such as calendar, datetime and decimals.
## Alternatives
This library is specific to ICU4X, but there are many Rust APIs with a similar focus. Here are some that I could find, and what they seem to do differently:
- [`simple-locale`](https://github.com/johnstonskj/simple-locale): very close to this crate, but doesn't use ICU4X libraries
- [`locale_settings`](https://docs.rs/locale-settings/latest/locale_settings): unmaintained(?) version of `simple-locale::settings`
- [`sys_locale`](https://github.com/1password/sys-locale): single locale instead of per-category
- [`utf8-locale`](https://gitlab.com/ppentchev/utf8-locale), [`locale-config`](https://github.com/rust-locale/locale_config): categories are less strongly typed
- [`gettextrs::setlocale()`](https://docs.rs/gettext-rs/latest/gettextrs/fn.setlocale.html): `gettext` bindings, this function can query the locale by setting the locale to a null string
## Useful links
- POSIX:
  - Locale category data: https://www.man7.org/linux/man-pages/man5/locale.5.html
  - Locale category definitions: https://www.man7.org/linux/man-pages/man7/locale.7.html
  - Description of locale names: https://www.gnu.org/software/libc/manual/html_node/Locale-Names.html
  - Locale spec: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html
  - Localization variables spec: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html#tag_08_02
  - Unicode handling of POSIX identifiers: https://unicode.org/reports/tr35/tr35.html#Legacy_Variants

Insertion in fluent_embed/src/lib.rs at line 1 [15.82]

[15.82]

[15.83]

use env_preferences::LocaleCategory;
use fluent_langneg::NegotiationStrategy;

Deletion in fluent_embed/src/lib.rs at line 14 [15.82]
∅:D[4.132] → [15.382:405]
B:BD[15.382] → [15.382:405]
```
pub use locale_select;
```

Replacement in fluent_embed/src/lib.rs at line 40 [15.82]

B:BD[16.5089] → [16.5089:5149]

        let selected_locale = locale_select::match_locales(

[16.5089]

[16.5149]

        let canonical_locale = <Self as Localize<W>>::CANONICAL_LOCALE;
        // MacOS and Windows return in order of preference, but Linux returns a HashMap
        let requested_locales = get_locales();
        let selected_locale = fluent_langneg::negotiate_languages(
            &requested_locales,

Replacement in fluent_embed/src/lib.rs at line 48 [15.82]

B:BD[16.5181] → [16.5181:5235]

            &<Self as Localize<W>>::CANONICAL_LOCALE,

[16.5181]

[16.5235]

            Some(&canonical_locale),
            NegotiationStrategy::Matching,

Replacement in fluent_embed/src/lib.rs at line 51 [15.82]

B:BD[16.5246] → [16.5246:5304]

        self.message_for_locale(writer, &selected_locale)

[16.5246]

[16.5304]

        self.message_for_locale(writer, &selected_locale[0])

Insertion in fluent_embed/src/lib.rs at line 55 [15.82]

[15.810]

#[cfg(target_os = "linux")]
// TODO: does not add `-u-va-posix` extension, see https://unicode.org/reports/tr35/tr35.html#Legacy_Variants
pub fn get_locales() -> Vec<LanguageIdentifier> {
    let mut retrieved_locales = env_preferences::get_locales().unwrap();
    let locale_order = vec![
        retrieved_locales.remove(&LocaleCategory::All),
        retrieved_locales.remove(&LocaleCategory::Messages),
        std::env::var("LANG").ok(),
    ];
    locale_order
        .into_iter()
        .filter_map(|optional_locale| optional_locale)
        .map(|locale| LanguageIdentifier::try_from_bytes(locale.as_bytes()).unwrap())
        .collect()
}
#[cfg(any(target_os = "macos", target_os = "windows"))]
pub fn get_locales() -> Vec<LanguageIdentifier> {
    env_preferences::get_locales()
        .unwrap()
        .map(|locale| LanguageIdentifier::try_from_bytes(locale.as_bytes()).unwrap())
        .collect()
}

Insertion in fluent_embed/Cargo.toml at line 11 [15.1078]
[5.5149]
[11.4377]
```
env_preferences = { git = "https://github.com/unicode-org/icu4x" }
```
Insertion in fluent_embed/Cargo.toml at line 13 [15.1078]
[11.4435]
[16.5311]
```
fluent-langneg = { version = "0.14.1", features = ["cldr"] }
```
Deletion in fluent_embed/Cargo.toml at line 21 [15.1078]
∅:D[11.4602] → [15.1261:1307]
B:BD[15.1261] → [15.1261:1307]
```
locale_select = { path = "../locale_select" }
```

Replacement in Cargo.toml at line 2 [17.197]

B:BD[17.210] → [18.1007:1074]

members = ["fluent_embed", "fluent_embed_derive", "locale_select"]

[17.210]

[17.238]

members = ["fluent_embed", "fluent_embed_derive"]

Deletion in Cargo.lock at line 64 [20.4277]

∅:D[19.14465] → [12.0:189]

B:BD[21.1230] → [12.0:189]


[[package]]
name = "block"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"

Insertion in Cargo.lock at line 102 [20.4277]

[22.1228]

[23.458]


[[package]]
name = "core-foundation-sys"
version = "0.8.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"

Insertion in Cargo.lock at line 143 [20.4277]

[23.661]

name = "env_preferences"
version = "1.5.0"
source = "git+https://github.com/unicode-org/icu4x#c3e6abcfb231521b1abe3519e3e27cc284e54fde"
dependencies = [
 "core-foundation-sys",
 "libc",
 "windows",
]
[[package]]

Insertion in Cargo.lock at line 204 [20.4277]
[5.5430]
[18.1075]
```
 "env_preferences",
```
Insertion in Cargo.lock at line 206 [20.4277]
[18.1093]
[18.1093]
```
 "fluent-langneg",
```
Deletion in Cargo.lock at line 214 [20.4277]
B:BD[18.1194] → [18.1194:1212]
```
 "locale_select",
```

Deletion in Cargo.lock at line 345 [20.4277]

∅:D[6.3694] → [23.3340:3355]

B:BD[23.3340] → [23.3340:3355]

∅:D[23.3355] → [12.393:860]

B:BD[12.393] → [12.393:860]

]
[[package]]
name = "gettext-rs"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e49ea8a8fad198aaa1f9655a2524b64b70eb06b2f3ff37da407566c93054f364"
dependencies = [
 "gettext-sys",
 "locale_config",
]
[[package]]
name = "gettext-sys"
version = "0.21.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c63ce2e00f56a206778276704bbe38564c8695249fdc8f354b4ef71c57c3839d"
dependencies = [
 "cc",
 "temp-dir",

Deletion in Cargo.lock at line 611 [20.4277]

∅:D[11.9277] → [12.861:1056]

B:BD[22.3670] → [12.861:1056]


[[package]]
name = "lazy_static"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"

Deletion in Cargo.lock at line 631 [20.4277]

B:BD[12.1070] → [12.1070:1339]

∅:D[12.1339] → [21.2186:2199]

B:BD[22.3861] → [21.2186:2199]

B:BD[21.2199] → [8.5657:5715]

B:BD[8.5715] → [10.1912:1931]

B:BD[10.1931] → [12.1340:1355]

∅:D[12.1355] → [8.5715:5729]

∅:D[10.1931] → [8.5715:5729]

B:BD[8.5715] → [8.5715:5729]

B:BD[8.5729] → [12.1356:1578]

∅:D[12.1578] → [9.210:219]

B:BD[8.5729] → [9.210:219]

∅:D[9.219] → [8.5729:5744]

B:BD[8.5729] → [8.5729:5744]

name = "locale_config"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08d2c35b16f4483f6c26f0e4e9550717a2f6575bcd6f12a53ff0c490a94a6934"
dependencies = [
 "lazy_static",
 "objc",
 "objc-foundation",
 "regex",
 "winapi",
]
[[package]]
name = "locale_select"
version = "0.1.0"
dependencies = [
 "fluent-langneg",
 "gettext-rs",
 "icu_locid",
 "libc",
]
[[package]]
name = "malloc_buf"
version = "0.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
dependencies = [
 "libc",
]
[[package]]

Deletion in Cargo.lock at line 732 [20.4277]

B:BD[12.1594] → [12.1594:2269]

∅:D[12.2269] → [21.2810:2812]

B:BD[21.2810] → [21.2810:2812]

∅:D[21.2812] → [22.3861:3874]

B:BD[22.3861] → [22.3861:3874]

name = "objc"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
dependencies = [
 "malloc_buf",
]
[[package]]
name = "objc-foundation"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9"
dependencies = [
 "block",
 "objc",
 "objc_id",
]
[[package]]
name = "objc_id"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b"
dependencies = [
 "objc",
]
[[package]]

Deletion in Cargo.lock at line 1093 [20.4277]

B:BD[12.2283] → [12.2283:2463]

∅:D[12.2463] → [24.2224:2237]

B:BD[24.2224] → [24.2224:2237]

name = "temp-dir"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f227968ec00f0e5322f9b8173c7a0cbcff6181a0a5b28e9892491c286277231"
[[package]]

Insertion in Cargo.lock at line 1236 [20.4277]

[21.4712]

]
[[package]]
name = "winapi-util"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
dependencies = [
 "windows-sys 0.52.0",

Replacement in Cargo.lock at line 1248 [20.4277]

B:BD[21.4727] → [21.4727:4761]

name = "winapi"
version = "0.3.9"

[21.4727]

[21.4761]

name = "windows"
version = "0.56.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1de69df01bdf1ead2f4ac895dc77c9351aefff65b2f3db429a343f9cbf05e132"
dependencies = [
 "windows-core",
 "windows-targets 0.52.6",
]
[[package]]
name = "windows-core"
version = "0.56.0"

Replacement in Cargo.lock at line 1261 [20.4277]

B:BD[21.4826] → [21.4826:4904]

checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"

[21.4826]

[21.4904]

checksum = "4698e52ed2d08f8658ab0c39512a7c00ee5fe2688c65f8c0a4f06750d729f2a6"

Replacement in Cargo.lock at line 1263 [20.4277]

B:BD[21.4921] → [21.4921:4985]

 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",

[21.4921]

[21.4985]

 "windows-implement",
 "windows-interface",
 "windows-result",
 "windows-targets 0.52.6",

Replacement in Cargo.lock at line 1270 [20.4277]
B:BD[21.5000] → [21.5000:5054]
```
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
```
[21.5000]
[21.5054]
```
name = "windows-implement"
version = "0.56.0"
```

Replacement in Cargo.lock at line 1273 [20.4277]

B:BD[21.5119] → [21.5119:5197]

checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[21.5119]

[21.5197]

checksum = "f6fc35f58ecd95a9b71c4f2329b911016e6bec66b3f2e6a4aad86bd2e99e2f9b"
dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.71",
]

Replacement in Cargo.lock at line 1281 [20.4277]
B:BD[21.5210] → [21.5210:5231]
B:BD[21.5231] → [25.458:476]
```
name = "winapi-util"
version = "0.1.8"
```
[21.5210]
[21.5249]
```
name = "windows-interface"
version = "0.56.0"
```

Replacement in Cargo.lock at line 1284 [20.4277]

B:BD[21.5314] → [25.477:555]

checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"

[21.5314]

[21.5392]

checksum = "08990546bf4edef8f431fa6326e032865f27138718c587dc21bc0265bbcb57cc"

Replacement in Cargo.lock at line 1286 [20.4277]
B:BD[21.5409] → [25.556:579]
```
 "windows-sys 0.52.0",
```
[21.5409]
[21.5420]
```
 "proc-macro2",
 "quote",
 "syn 2.0.71",
```
Replacement in Cargo.lock at line 1292 [20.4277]
B:BD[22.5251] → [21.5423:5479]
```
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
```
[22.5251]
[21.5479]
```
name = "windows-result"
version = "0.1.2"
```

Replacement in Cargo.lock at line 1295 [20.4277]

B:BD[21.5544] → [21.5544:5622]

checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

[21.5544]

[19.19132]

checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
dependencies = [
 "windows-targets 0.52.6",
]

Migrate from `locale_select` to `env_preferences`

Dependencies

In channels

Change contents

File deletion: locale_select

File deletion: Cargo.toml

File deletion: src

File deletion: lib.rs

File deletion: unix.rs

File deletion: fetch

File deletion: mod.rs

File deletion: unix.rs

File deletion: tests

File deletion: unix.rs

File deletion: README.md

Insertion in fluent_embed/src/lib.rs at line 1 [15.82]

Deletion in fluent_embed/src/lib.rs at line 14 [15.82]

Replacement in fluent_embed/src/lib.rs at line 40 [15.82]

Replacement in fluent_embed/src/lib.rs at line 48 [15.82]

Replacement in fluent_embed/src/lib.rs at line 51 [15.82]

Insertion in fluent_embed/src/lib.rs at line 55 [15.82]

Insertion in fluent_embed/Cargo.toml at line 11 [15.1078]

Insertion in fluent_embed/Cargo.toml at line 13 [15.1078]

Deletion in fluent_embed/Cargo.toml at line 21 [15.1078]

Replacement in Cargo.toml at line 2 [17.197]

Deletion in Cargo.lock at line 64 [20.4277]

Insertion in Cargo.lock at line 102 [20.4277]

Insertion in Cargo.lock at line 143 [20.4277]

Insertion in Cargo.lock at line 204 [20.4277]

Insertion in Cargo.lock at line 206 [20.4277]

Deletion in Cargo.lock at line 214 [20.4277]

Deletion in Cargo.lock at line 345 [20.4277]

Deletion in Cargo.lock at line 611 [20.4277]

Deletion in Cargo.lock at line 631 [20.4277]

Deletion in Cargo.lock at line 732 [20.4277]

Deletion in Cargo.lock at line 1093 [20.4277]

Insertion in Cargo.lock at line 1236 [20.4277]

Replacement in Cargo.lock at line 1248 [20.4277]

Replacement in Cargo.lock at line 1261 [20.4277]

Replacement in Cargo.lock at line 1263 [20.4277]

Replacement in Cargo.lock at line 1270 [20.4277]

Replacement in Cargo.lock at line 1273 [20.4277]

Replacement in Cargo.lock at line 1281 [20.4277]

Replacement in Cargo.lock at line 1284 [20.4277]

Replacement in Cargo.lock at line 1286 [20.4277]

Replacement in Cargo.lock at line 1292 [20.4277]

Replacement in Cargo.lock at line 1295 [20.4277]