citum_schema_style/locale/
raw_conversion.rs

1/*
2SPDX-License-Identifier: MIT OR Apache-2.0
3SPDX-FileCopyrightText: © 2023-2026 Bruce D'Arcus and Citum contributors
4*/
5
6//! Conversion from [`raw::RawLocale`] (serde-facing schema) into the runtime
7//! [`Locale`] type, plus the file/YAML/JSON/CBOR loaders that drive it.
8//!
9//! Parsing helpers (`extract_*`, `parse_*`, `from_raw_gendered_string`) live
10//! alongside `from_raw` so a reader sees the whole transformation in one
11//! place. Public Locale APIs unrelated to raw conversion stay in `mod.rs`.
12
13use super::Locale;
14use super::message::{MessageEvaluator, Mf2MessageEvaluator, NoOpEvaluator};
15use super::raw;
16use super::types::{
17    ContributorTerm, DateTerms, LocaleOverride, LocatorTerm, MaybeGendered, MessageSyntax,
18    MonthNames, SimpleTerm, SingularPlural, TermForm,
19};
20use crate::citation::LocatorType;
21use crate::template::ContributorRole;
22use std::collections::HashMap;
23use std::sync::Arc;
24
25impl Locale {
26    /// Load a locale from a YAML string.
27    ///
28    /// # Errors
29    ///
30    /// Returns an error when the YAML cannot be parsed into a locale.
31    pub fn from_yaml_str(yaml: &str) -> Result<Self, String> {
32        let raw: raw::RawLocale = serde_yaml::from_str(yaml)
33            .map_err(|e| format!("Failed to parse locale YAML: {}", e))?;
34
35        Ok(Self::from_raw(raw))
36    }
37
38    /// Load a locale by ID (e.g., "en-US", "de-DE") from a locales directory.
39    /// Falls back to en-US if the locale file is not found.
40    pub fn load(locale_id: &str, locales_dir: &std::path::Path) -> Self {
41        let extensions = ["yaml", "yml", "json", "cbor"];
42
43        for ext in &extensions {
44            let file_name = format!("{}.{}", locale_id, ext);
45            let file_path = locales_dir.join(&file_name);
46
47            if file_path.exists() {
48                match Self::from_file(&file_path) {
49                    Ok(locale) => return locale,
50                    Err(e) => {
51                        eprintln!(
52                            "Warning: Failed to load locale {}.{}: {}",
53                            locale_id, ext, e
54                        );
55                    }
56                }
57            }
58        }
59
60        if locale_id.contains('-') {
61            let base = locale_id.split('-').next().unwrap_or("en");
62            if let Ok(entries) = std::fs::read_dir(locales_dir) {
63                for entry in entries.flatten() {
64                    let name = entry.file_name();
65                    let name_str = name.to_string_lossy();
66                    if (name_str.starts_with(base)
67                        && extensions.iter().any(|ext| name_str.ends_with(ext)))
68                        && let Ok(locale) = Self::from_file(&entry.path())
69                    {
70                        return locale;
71                    }
72                }
73            }
74        }
75
76        Self::en_us()
77    }
78
79    /// Load locale from a file path directly (detects format).
80    ///
81    /// # Errors
82    ///
83    /// Returns an error when the file cannot be read or its contents cannot be
84    /// parsed as a supported locale format.
85    pub fn from_file(path: &std::path::Path) -> Result<Self, String> {
86        let bytes =
87            std::fs::read(path).map_err(|e| format!("Failed to read locale file: {}", e))?;
88        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("yaml");
89
90        match ext {
91            "cbor" => ciborium::de::from_reader::<raw::RawLocale, _>(std::io::Cursor::new(&bytes))
92                .map(Self::from_raw)
93                .map_err(|e| format!("Failed to parse CBOR locale: {}", e)),
94            "json" => serde_json::from_slice::<raw::RawLocale>(&bytes)
95                .map(Self::from_raw)
96                .map_err(|e| format!("Failed to parse JSON locale: {}", e)),
97            _ => {
98                let content = String::from_utf8_lossy(&bytes);
99                Self::from_yaml_str(&content)
100            }
101        }
102    }
103
104    /// Convert a RawLocale to a Locale, seeding from [`Locale::en_us()`].
105    ///
106    /// This is the inheritance model non-en-US locales rely on: a partial
107    /// locale file (e.g. `ar-AR`, `eu-ES`) only overrides the fields it
108    /// specifies, and everything else falls back to the English baseline —
109    /// but the inheritance is field-granular, not uniform. `roles`,
110    /// `locators`, `terms`, `vocab`, `messages`, `date_formats`, and
111    /// `legacy_term_aliases` are merged key-by-key into the base, so an
112    /// omitted key keeps the base's value while an explicit raw entry
113    /// overrides it. Inherited message fallbacks do not shadow structured
114    /// terms supplied by the raw locale.
115    fn from_raw(raw: raw::RawLocale) -> Self {
116        Self::from_raw_with_base(raw, Locale::en_us())
117    }
118
119    /// Convert a RawLocale to a Locale, seeding from the given `base` locale
120    /// instead of always inheriting from [`Locale::en_us()`].
121    ///
122    /// This exists so [`Locale::en_us()`] itself can parse the embedded
123    /// `en-US.yaml` without infinite recursion: it seeds from
124    /// [`Locale::default()`] (a non-circular, fully-formed empty locale)
125    /// rather than from `en_us()`. Non-en-US locale loading is unaffected —
126    /// [`Locale::from_raw`] still calls this with `Locale::en_us()` as the
127    /// base, preserving partial-locale inheritance behavior.
128    #[allow(
129        clippy::too_many_lines,
130        reason = "Complex parsing of raw locale data with multiple term types"
131    )]
132    pub(super) fn from_raw_with_base(raw: raw::RawLocale, base: Self) -> Self {
133        let punctuation_in_quote = raw.locale.starts_with("en-US")
134            || (raw.locale.starts_with("en") && !raw.locale.starts_with("en-GB"));
135
136        let mut locale = base;
137        locale.locale = raw.locale.clone();
138        Self::remove_base_messages_shadowed_by_raw_terms(&raw, &mut locale.messages);
139        locale.dates = DateTerms {
140            months: MonthNames {
141                long: raw.dates.months.long,
142                short: raw.dates.months.short,
143            },
144            seasons: raw.dates.seasons,
145            uncertainty_term: raw.dates.uncertainty_term,
146            open_ended_term: raw.dates.open_ended_term,
147            am: raw.dates.am,
148            pm: raw.dates.pm,
149            timezone_utc: raw.dates.timezone_utc,
150            before_era: raw.dates.before_era,
151            ad: raw.dates.ad,
152            bc: raw.dates.bc,
153            bce: raw.dates.bce,
154            ce: raw.dates.ce,
155        };
156        locale.punctuation_in_quote = punctuation_in_quote;
157        locale.sort_articles = Self::default_articles_for_locale(&raw.locale);
158
159        locale.locale_schema_version = raw.locale_schema_version;
160        locale.evaluation = raw.evaluation.unwrap_or_default();
161        locale.messages.extend(raw.messages);
162        locale.date_formats.extend(raw.date_formats);
163        locale.legacy_term_aliases.extend(raw.legacy_term_aliases);
164
165        if let Some(raw_vocab) = raw.vocab {
166            locale.vocab.genre.extend(raw_vocab.genre);
167            locale.vocab.medium.extend(raw_vocab.medium);
168        }
169
170        if let Some(go) = raw.grammar_options {
171            locale.grammar_options = go;
172        } else {
173            locale.grammar_options.punctuation_in_quote = locale.punctuation_in_quote;
174        }
175        locale.punctuation_in_quote = locale.grammar_options.punctuation_in_quote;
176        locale.punctuation_realization = raw.punctuation_realization;
177
178        if let Some(nf) = raw.number_formats {
179            locale.number_formats = nf;
180        }
181
182        let explicit_locator_keys: std::collections::HashSet<LocatorType> = raw
183            .locators
184            .keys()
185            .filter_map(|key| Self::parse_builtin_locator_type(key))
186            .collect();
187
188        for (key, value) in &raw.locators {
189            if let Some(locator_type) = Self::parse_locator_type(key) {
190                let locator_term = LocatorTerm {
191                    long: Self::extract_singular_plural(value.long.as_ref().as_ref()),
192                    short: Self::extract_singular_plural(value.short.as_ref().as_ref()),
193                    symbol: Self::extract_singular_plural(value.symbol.as_ref().as_ref()),
194                    gender: value.gender.clone(),
195                };
196                locale.locators.insert(locator_type, locator_term);
197            }
198        }
199
200        for (key, value) in &raw.terms {
201            if let Some(locator_type) = Self::parse_builtin_locator_type(key)
202                && !explicit_locator_keys.contains(&locator_type)
203                && let Some(forms) = Self::get_forms(value)
204            {
205                let locator_term = LocatorTerm {
206                    long: Self::extract_singular_plural(forms.get("long").as_ref()),
207                    short: Self::extract_singular_plural(forms.get("short").as_ref()),
208                    symbol: Self::extract_singular_plural(forms.get("symbol").as_ref()),
209                    gender: None,
210                };
211                locale.locators.insert(locator_type, locator_term);
212                continue;
213            }
214
215            match key.as_str() {
216                "and" => {
217                    if let Some(forms) = Self::get_forms(value) {
218                        if let Some(v) = forms.get("long").and_then(|v| v.as_string()) {
219                            locale.terms.and = Some(v.to_string());
220                        }
221                        if let Some(v) = forms.get("symbol").and_then(|v| v.as_string()) {
222                            locale.terms.and_symbol = Some(v.to_string());
223                        }
224                    }
225                }
226                "et_al" => {
227                    if let Some(forms) = Self::get_forms(value)
228                        && let Some(v) = forms.get("long").and_then(|v| v.as_string())
229                    {
230                        locale.terms.et_al = Some(v.to_string());
231                    }
232                }
233                "and others" | "and_others" => {
234                    if let Some(forms) = Self::get_forms(value)
235                        && let Some(v) = forms.get("long").and_then(|v| v.as_string())
236                    {
237                        locale.terms.and_others = Some(v.to_string());
238                    }
239                }
240                "accessed" => {
241                    if let Some(forms) = Self::get_forms(value)
242                        && let Some(v) = forms.get("long").and_then(|v| v.as_string())
243                    {
244                        locale.terms.accessed = Some(v.to_string());
245                    }
246                }
247                "ibid" => {
248                    if let Some(forms) = Self::get_forms(value)
249                        && let Some(v) = forms.get("long").and_then(|v| v.as_string())
250                    {
251                        locale.terms.ibid = Some(v.to_string());
252                    }
253                }
254                "no date" => {
255                    let simple = Self::extract_simple_term_from_raw(value);
256                    let short_fallback = simple.short.as_default_str().to_string();
257                    locale
258                        .terms
259                        .general
260                        .insert(super::types::GeneralTerm::NoDate, simple);
261                    locale.terms.no_date.get_or_insert(short_fallback);
262                }
263                "no_date" => {
264                    let simple = Self::extract_simple_term_from_raw(value);
265                    locale.terms.no_date = Some(simple.short.as_str().to_string());
266                    locale
267                        .terms
268                        .general
269                        .entry(super::types::GeneralTerm::NoDate)
270                        .or_insert(simple);
271                }
272                _ => {
273                    if let Some(general_term) = Self::parse_general_term(key) {
274                        let simple = Self::extract_simple_term_from_raw(value);
275                        locale.terms.general.insert(general_term, simple);
276                    } else {
277                        let normalized = Self::normalize_term_key(key);
278                        if Self::is_known_type_term_key(&normalized) {
279                            let simple = Self::extract_simple_term_from_raw(value);
280                            locale.type_terms.insert(normalized, simple);
281                        }
282                    }
283                }
284            }
285        }
286
287        for (key, role_term) in &raw.roles {
288            let contributor_term = ContributorTerm {
289                singular: Self::extract_simple_term(&role_term.long, &role_term.short, false),
290                plural: Self::extract_simple_term(&role_term.long, &role_term.short, true),
291                verb: Self::extract_verb_term(&role_term.verb, &role_term.verb_short),
292            };
293            if let Some(role) = Self::parse_role_name(key) {
294                locale.roles.insert(role, contributor_term);
295            } else {
296                let canonical = if key == "editortranslator" {
297                    "editor-translator".to_string()
298                } else {
299                    Self::normalize_term_key(key)
300                };
301                locale.role_combinations.insert(canonical, contributor_term);
302            }
303        }
304
305        locale.evaluator = match locale.evaluation.message_syntax {
306            MessageSyntax::Mf2 => Arc::new(Mf2MessageEvaluator) as Arc<dyn MessageEvaluator>,
307            MessageSyntax::Static => Arc::new(NoOpEvaluator),
308        };
309
310        locale
311    }
312
313    /// Get default articles for a locale based on language code.
314    fn default_articles_for_locale(locale_id: &str) -> Vec<String> {
315        #[allow(clippy::string_slice, reason = "locale_id is expected to be ASCII")]
316        let lang = &locale_id[..2.min(locale_id.len())];
317        match lang {
318            "en" => vec!["the".into(), "a".into(), "an".into()],
319            "de" => vec![
320                "der".into(),
321                "die".into(),
322                "das".into(),
323                "ein".into(),
324                "eine".into(),
325            ],
326            "fr" => vec![
327                "le".into(),
328                "la".into(),
329                "les".into(),
330                "l'".into(),
331                "un".into(),
332                "une".into(),
333            ],
334            "es" => vec![
335                "el".into(),
336                "la".into(),
337                "los".into(),
338                "las".into(),
339                "un".into(),
340                "una".into(),
341            ],
342            "it" => vec![
343                "il".into(),
344                "lo".into(),
345                "la".into(),
346                "i".into(),
347                "gli".into(),
348                "le".into(),
349                "un".into(),
350                "una".into(),
351            ],
352            "pt" => vec![
353                "o".into(),
354                "a".into(),
355                "os".into(),
356                "as".into(),
357                "um".into(),
358                "uma".into(),
359            ],
360            "nl" => vec!["de".into(), "het".into(), "een".into()],
361            _ => vec![],
362        }
363    }
364
365    fn get_forms(value: &raw::RawTermValue) -> Option<&HashMap<String, raw::RawTermValue>> {
366        match value {
367            raw::RawTermValue::Forms(forms) => Some(forms),
368            _ => None,
369        }
370    }
371
372    fn parse_locator_type(name: &str) -> Option<LocatorType> {
373        LocatorType::from_key(name).ok()
374    }
375
376    fn parse_builtin_locator_type(name: &str) -> Option<LocatorType> {
377        match Self::parse_locator_type(name)? {
378            LocatorType::Custom(_) => None,
379            locator => Some(locator),
380        }
381    }
382
383    fn parse_role_name(name: &str) -> Option<ContributorRole> {
384        match name {
385            "author" => Some(ContributorRole::Author),
386            "chair" => Some(ContributorRole::Chair),
387            "editor" => Some(ContributorRole::Editor),
388            "translator" => Some(ContributorRole::Translator),
389            "director" => Some(ContributorRole::Director),
390            "compiler" => Some(ContributorRole::Composer),
391            "illustrator" => Some(ContributorRole::Illustrator),
392            "collection-editor" => Some(ContributorRole::CollectionEditor),
393            "container-author" => Some(ContributorRole::ContainerAuthor),
394            "editorial-director" => Some(ContributorRole::EditorialDirector),
395            "textual-editor" | "textual_editor" => Some(ContributorRole::TextualEditor),
396            "interviewer" => Some(ContributorRole::Interviewer),
397            "original-author" => Some(ContributorRole::OriginalAuthor),
398            "recipient" => Some(ContributorRole::Recipient),
399            "reviewed-author" => Some(ContributorRole::ReviewedAuthor),
400            "performer" => Some(ContributorRole::Performer),
401            "composer" => Some(ContributorRole::Composer),
402            "writer" => Some(ContributorRole::Writer),
403            "producer" => Some(ContributorRole::Producer),
404            _ => None,
405        }
406    }
407
408    fn remove_base_messages_shadowed_by_raw_terms(
409        raw: &raw::RawLocale,
410        messages: &mut HashMap<String, String>,
411    ) {
412        for key in raw.locators.keys() {
413            if let Some(locator) = Self::parse_builtin_locator_type(key) {
414                for form in [TermForm::Long, TermForm::Short] {
415                    if let Some(message_id) = Self::locator_message_id(&locator, &form) {
416                        messages.remove(message_id);
417                    }
418                }
419            }
420        }
421
422        for key in raw.roles.keys() {
423            if let Some(role) = Self::parse_role_name(key) {
424                for form in [
425                    TermForm::Long,
426                    TermForm::Short,
427                    TermForm::Verb,
428                    TermForm::VerbShort,
429                ] {
430                    if let Some(message_id) = Self::role_message_id(&role, &form) {
431                        messages.remove(message_id);
432                    }
433                }
434            }
435        }
436
437        for key in raw.terms.keys() {
438            if let Some(term) = Self::parse_general_term(key) {
439                for form in [TermForm::Long, TermForm::Short] {
440                    if let Some(message_id) = Self::general_message_id(&term, &form) {
441                        messages.remove(message_id);
442                    }
443                }
444            }
445        }
446    }
447
448    fn extract_singular_plural(value: Option<&&raw::RawTermValue>) -> Option<SingularPlural> {
449        match value {
450            Some(raw::RawTermValue::SingularPlural { singular, plural }) => Some(SingularPlural {
451                singular: Self::from_raw_gendered_string(singular),
452                plural: Self::from_raw_gendered_string(plural),
453            }),
454            Some(raw::RawTermValue::Simple(s)) => Some(SingularPlural {
455                singular: MaybeGendered::Plain(s.clone()),
456                plural: MaybeGendered::Plain(s.clone()),
457            }),
458            Some(raw::RawTermValue::Gendered {
459                masculine,
460                feminine,
461                neuter,
462                common,
463            }) => Some(SingularPlural {
464                singular: MaybeGendered::Gendered {
465                    masculine: masculine.clone(),
466                    feminine: feminine.clone(),
467                    neuter: neuter.clone(),
468                    common: common.clone(),
469                },
470                plural: MaybeGendered::Gendered {
471                    masculine: masculine.clone(),
472                    feminine: feminine.clone(),
473                    neuter: neuter.clone(),
474                    common: common.clone(),
475                },
476            }),
477            Some(raw::RawTermValue::Forms(forms)) => {
478                let singular = forms
479                    .get("singular")
480                    .map(Self::extract_maybe_gendered_string);
481                let plural = forms.get("plural").map(Self::extract_maybe_gendered_string);
482
483                singular.map(|s| SingularPlural {
484                    plural: plural.unwrap_or_else(|| s.clone()),
485                    singular: s,
486                })
487            }
488            _ => None,
489        }
490    }
491
492    fn extract_simple_term(
493        long: &Option<raw::RawTermValue>,
494        short: &Option<raw::RawTermValue>,
495        plural: bool,
496    ) -> SimpleTerm {
497        let long_str = long
498            .as_ref()
499            .map(|v| Self::extract_simple_gendered_term(v, plural))
500            .unwrap_or_default();
501
502        let short_str = short
503            .as_ref()
504            .map(|v| Self::extract_simple_gendered_term(v, plural))
505            .unwrap_or_default();
506
507        SimpleTerm {
508            long: long_str,
509            short: short_str,
510        }
511    }
512
513    fn extract_verb_term(
514        verb: &Option<raw::RawTermValue>,
515        verb_short: &Option<raw::RawTermValue>,
516    ) -> SimpleTerm {
517        let long_str = verb
518            .as_ref()
519            .and_then(|v| v.as_string())
520            .unwrap_or("")
521            .into();
522
523        let short_str = verb_short
524            .as_ref()
525            .and_then(|v| v.as_string())
526            .unwrap_or("")
527            .into();
528
529        SimpleTerm {
530            long: long_str,
531            short: short_str,
532        }
533    }
534
535    /// Normalize a locale term key to canonical kebab-case.
536    ///
537    /// Locale YAML files and style templates may use underscores or spaces
538    /// interchangeably with hyphens (e.g. `no_date`, `no date`, `no-date`).
539    /// This helper converts all three forms to the single canonical
540    /// kebab-case key so `parse_general_term` only needs to match one pattern
541    /// per term.
542    fn normalize_term_key(s: &str) -> String {
543        s.replace(['_', ' '], "-")
544    }
545
546    /// Parse a locale term key into a structured general-term identifier.
547    pub fn parse_general_term(name: &str) -> Option<super::types::GeneralTerm> {
548        use super::types::GeneralTerm;
549        match Self::normalize_term_key(name).as_str() {
550            "in" => Some(GeneralTerm::In),
551            "accessed" => Some(GeneralTerm::Accessed),
552            "cited" => Some(GeneralTerm::Cited),
553            "retrieved" => Some(GeneralTerm::Retrieved),
554            "at" => Some(GeneralTerm::At),
555            "from" => Some(GeneralTerm::From),
556            "of" => Some(GeneralTerm::Of),
557            "to" => Some(GeneralTerm::To),
558            "by" => Some(GeneralTerm::By),
559            "no-date" => Some(GeneralTerm::NoDate),
560            "anonymous" => Some(GeneralTerm::Anonymous),
561            "circa" => Some(GeneralTerm::Circa),
562            "available-at" => Some(GeneralTerm::AvailableAt),
563            "ibid" => Some(GeneralTerm::Ibid),
564            "and" => Some(GeneralTerm::And),
565            "role-conjunction" => Some(GeneralTerm::RoleConjunction),
566            "et-al" => Some(GeneralTerm::EtAl),
567            "and-others" => Some(GeneralTerm::AndOthers),
568            "forthcoming" => Some(GeneralTerm::Forthcoming),
569            "online" => Some(GeneralTerm::Online),
570            "here" => Some(GeneralTerm::Here),
571            "deposited" => Some(GeneralTerm::Deposited),
572            "review-of" => Some(GeneralTerm::ReviewOf),
573            "original-work-published" => Some(GeneralTerm::OriginalWorkPublished),
574            "personal-communication" => Some(GeneralTerm::PersonalCommunication),
575            "patent" => Some(GeneralTerm::Patent),
576            "issued" => Some(GeneralTerm::Issued),
577            "volume" => Some(GeneralTerm::Volume),
578            "issue" => Some(GeneralTerm::Issue),
579            "page" => Some(GeneralTerm::Page),
580            "chapter" => Some(GeneralTerm::Chapter),
581            "edition" => Some(GeneralTerm::Edition),
582            "section" => Some(GeneralTerm::Section),
583            "version" => Some(GeneralTerm::Version),
584            _ => None,
585        }
586    }
587
588    /// Reference-type description term keys recognized for
589    /// [`Locale::type_terms`] (the `type-label` component's fallback data).
590    ///
591    /// Legacy locale files (`terms:`) carry a wide mix of CSL 1.0 term keys
592    /// — general terms, locator labels, and reference-type descriptions —
593    /// under one flat map. General terms and locators are already claimed by
594    /// `parse_general_term` and `parse_builtin_locator_type` above; this is
595    /// an explicit allowlist of the *remaining* keys that are genuinely
596    /// reference-type descriptions, cross-referenced against the finite set
597    /// of strings `citum_schema_data`'s `Reference::ref_type()` can actually
598    /// produce (see `citum-engine/src/values/type_class.rs` module docs).
599    ///
600    /// This is deliberately an explicit list, not "capture anything
601    /// unclaimed" — the unclaimed remainder also includes unrelated dead
602    /// data (era terms, punctuation terms, number-variable labels like
603    /// `version`/`printing`) that must not leak into `type_terms`.
604    ///
605    /// Membership here only makes `en-US.yaml`'s existing term *reachable*;
606    /// it does not guarantee every `ref_type()` output has a term to reach.
607    /// A handful of real `ref_type()` outputs currently have no authored
608    /// term in `en-US.yaml` at all — `book`, `brief`, `bill-proceeding`,
609    /// `bill-record`, `chapter`, `figure`, `manual`, `statute` — so
610    /// `type-label` falls back to an empty label for those types today.
611    /// That is a locale-content gap (nothing to allowlist), not a bug in
612    /// this function; only `dataset` is exercised by a shipped style so far.
613    fn is_known_type_term_key(normalized_key: &str) -> bool {
614        const KNOWN_TYPE_TERM_KEYS: &[&str] = &[
615            "article-journal",
616            "article-magazine",
617            "article-newspaper",
618            "broadcast",
619            "classic",
620            "collection",
621            "dataset",
622            "document",
623            "entry",
624            "entry-dictionary",
625            "entry-encyclopedia",
626            "event",
627            "graphic",
628            "hearing",
629            "interview",
630            "legal-case",
631            "legislation",
632            "manuscript",
633            "map",
634            "motion-picture",
635            "musical-score",
636            "pamphlet",
637            "paper-conference",
638            "performance",
639            "periodical",
640            "personal-communication",
641            "post",
642            "post-weblog",
643            "preprint",
644            "regulation",
645            "report",
646            "review",
647            "review-book",
648            "software",
649            "song",
650            "speech",
651            "standard",
652            "thesis",
653            "treaty",
654            "webpage",
655        ];
656        KNOWN_TYPE_TERM_KEYS.contains(&normalized_key)
657    }
658
659    fn extract_simple_term_from_raw(value: &raw::RawTermValue) -> SimpleTerm {
660        match value {
661            raw::RawTermValue::Simple(s) => SimpleTerm {
662                long: s.clone().into(),
663                short: s.clone().into(),
664            },
665            raw::RawTermValue::Gendered {
666                masculine,
667                feminine,
668                neuter,
669                common,
670            } => SimpleTerm {
671                long: MaybeGendered::Gendered {
672                    masculine: masculine.clone(),
673                    feminine: feminine.clone(),
674                    neuter: neuter.clone(),
675                    common: common.clone(),
676                },
677                short: MaybeGendered::Gendered {
678                    masculine: masculine.clone(),
679                    feminine: feminine.clone(),
680                    neuter: neuter.clone(),
681                    common: common.clone(),
682                },
683            },
684            raw::RawTermValue::Forms(forms) => {
685                let long = forms
686                    .get("long")
687                    .map(Self::extract_maybe_gendered_string)
688                    .unwrap_or_default();
689                let short = forms
690                    .get("short")
691                    .map(Self::extract_maybe_gendered_string)
692                    .unwrap_or_else(|| long.clone());
693                SimpleTerm { long, short }
694            }
695            raw::RawTermValue::SingularPlural { singular, .. } => SimpleTerm {
696                long: Self::from_raw_gendered_string(singular),
697                short: Self::from_raw_gendered_string(singular),
698            },
699        }
700    }
701
702    fn from_raw_gendered_string(value: &raw::RawGenderedString) -> MaybeGendered<String> {
703        match value {
704            raw::RawGenderedString::Simple(value) => MaybeGendered::Plain(value.clone()),
705            raw::RawGenderedString::Gendered {
706                masculine,
707                feminine,
708                neuter,
709                common,
710            } => MaybeGendered::Gendered {
711                masculine: masculine.clone(),
712                feminine: feminine.clone(),
713                neuter: neuter.clone(),
714                common: common.clone(),
715            },
716        }
717    }
718
719    fn extract_maybe_gendered_string(value: &raw::RawTermValue) -> MaybeGendered<String> {
720        match value {
721            raw::RawTermValue::Simple(value) => MaybeGendered::Plain(value.clone()),
722            raw::RawTermValue::Gendered {
723                masculine,
724                feminine,
725                neuter,
726                common,
727            } => MaybeGendered::Gendered {
728                masculine: masculine.clone(),
729                feminine: feminine.clone(),
730                neuter: neuter.clone(),
731                common: common.clone(),
732            },
733            raw::RawTermValue::SingularPlural { singular, .. } => {
734                Self::from_raw_gendered_string(singular)
735            }
736            raw::RawTermValue::Forms(forms) => forms
737                .get("long")
738                .or_else(|| forms.get("singular"))
739                .map(Self::extract_maybe_gendered_string)
740                .unwrap_or_default(),
741        }
742    }
743
744    fn extract_simple_gendered_term(
745        value: &raw::RawTermValue,
746        plural: bool,
747    ) -> MaybeGendered<String> {
748        match value {
749            raw::RawTermValue::Simple(value) => MaybeGendered::Plain(value.clone()),
750            raw::RawTermValue::Gendered {
751                masculine,
752                feminine,
753                neuter,
754                common,
755            } => MaybeGendered::Gendered {
756                masculine: masculine.clone(),
757                feminine: feminine.clone(),
758                neuter: neuter.clone(),
759                common: common.clone(),
760            },
761            raw::RawTermValue::SingularPlural {
762                singular,
763                plural: plural_value,
764            } => {
765                if plural {
766                    Self::from_raw_gendered_string(plural_value)
767                } else {
768                    Self::from_raw_gendered_string(singular)
769                }
770            }
771            raw::RawTermValue::Forms(forms) => {
772                let key = if plural { "plural" } else { "singular" };
773                forms
774                    .get(key)
775                    .or_else(|| forms.get("long"))
776                    .map(Self::extract_maybe_gendered_string)
777                    .unwrap_or_default()
778            }
779        }
780    }
781
782    /// Apply a partial override, merging its fields into this locale.
783    ///
784    /// Performs key-by-key insertion or replacement for:
785    /// - `messages`: new or updated message IDs
786    /// - `grammar_options`: if `Some`, replaces the entire block and syncs
787    ///   `punctuation_in_quote` field
788    /// - `legacy_term_aliases`: new or updated term aliases
789    pub fn apply_override(&mut self, ov: &LocaleOverride) {
790        for (k, v) in &ov.messages {
791            self.messages.insert(k.clone(), v.clone());
792        }
793        if let Some(go) = &ov.grammar_options {
794            self.grammar_options = go.clone();
795            self.punctuation_in_quote = go.punctuation_in_quote;
796        }
797        for (k, v) in &ov.legacy_term_aliases {
798            self.legacy_term_aliases.insert(k.clone(), v.clone());
799        }
800    }
801}
citum_schema_style/locale/raw_conversion.rs

citum_schema_style/locale/
raw_conversion.rs
