eska-presentation 0.15.2

Shared localization and path presentation for ESKA tools
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Presentation-only captions for the open-ended Designer XML vocabulary.

use eska_project_core::project::metadata_model::{MetadataKind, PropertyKey};

use super::Localizer;

impl Localizer {
    /// Resolve contextual captions first, retaining `QName` boundaries for unknown extensions.
    #[must_use]
    pub fn property_caption(
        &self,
        owner: Option<MetadataKind>,
        key: &PropertyKey,
    ) -> Option<String> {
        // Catalog names are ASCII identifiers; a hyphenated XML name must not impersonate
        // the owner segment of a contextual Fluent key.
        if !key.name.bytes().all(|byte| byte.is_ascii_alphanumeric()) {
            return None;
        }
        let namespace = match key.namespace.as_deref()? {
            "http://v8.1c.ru/8.3/MDClasses" => "md",
            "http://v8.1c.ru/8.3/xcf/readable" => "readable",
            "http://v8.1c.ru/8.1/data/core" => "core",
            "http://v8.1c.ru/8.1/data/ui" => "ui",
            "http://v8.1c.ru/8.2/managed-application/core" => "app",
            "http://v8.1c.ru/8.3/xcf/predef" => "predef",
            _ => return None,
        };
        if let Some(owner) = owner {
            let contextual = format!(
                "platform-property-{namespace}-{}-{}",
                owner.as_str(),
                key.name
            );
            if let Some(caption) = self.optional_text(&contextual) {
                return Some(caption);
            }
        }
        self.optional_text(&format!("platform-property-{namespace}-{}", key.name))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::localization::Locale;

    /// Every audited `QName` and owner resolves in both locales, including newer additions.
    #[test]
    fn catalog_covers_the_audited_vocabulary() {
        let catalog = include_str!("../../locales/platform-catalog.tsv");
        for locale in [Locale::RuRu, Locale::EnUs] {
            let localizer = Localizer::try_new(locale).unwrap();
            for line in catalog.lines().skip(1) {
                let columns: Vec<_> = line.split('\t').collect();
                assert_eq!(columns.len(), 5);
                let owner = MetadataKind::ALL
                    .iter()
                    .copied()
                    .find(|kind| kind.as_str() == columns[3]);
                assert!(columns[3].is_empty() || owner.is_some());
                let caption = localizer.property_caption(
                    owner,
                    &PropertyKey {
                        namespace: Some(columns[1].into()),
                        name: columns[2].into(),
                    },
                );
                assert_eq!(caption, localizer.optional_text(columns[0]), "{line}");
                assert!(caption.is_some_and(|text| !text.trim().is_empty()));
            }
            for line in include_str!("../../locales/platform-coverage.tsv")
                .lines()
                .skip(1)
            {
                let columns: Vec<_> = line.split('\t').collect();
                assert_eq!(columns.len(), 6);
                assert!(localizer.optional_text(columns[5]).is_some(), "{line}");
            }
        }
    }

    /// Unknown namespaces and fields cannot accidentally borrow a familiar-looking caption.
    #[test]
    fn captions_respect_namespaces_and_owner_context() {
        let localizer = Localizer::try_new(Locale::RuRu).unwrap();
        let mut key = PropertyKey {
            namespace: Some("http://v8.1c.ru/8.3/MDClasses".into()),
            name: "Type".into(),
        };
        assert_eq!(
            localizer.property_caption(None, &key).as_deref(),
            Some("Тип")
        );
        assert_eq!(
            localizer
                .property_caption(Some(MetadataKind::StyleItem), &key)
                .as_deref(),
            Some("Вид")
        );
        key.namespace = Some("urn:vendor".into());
        assert_eq!(
            localizer.property_caption(Some(MetadataKind::StyleItem), &key),
            None
        );
        key.namespace = None;
        assert_eq!(localizer.property_caption(None, &key), None);
        key.namespace = Some("http://v8.1c.ru/8.3/MDClasses".into());
        key.name = "FutureProperty".into();
        assert_eq!(localizer.property_caption(None, &key), None);
        key.name = "sequence-RegisterRecords".into();
        assert_eq!(localizer.property_caption(None, &key), None);
    }
}