lingora-tui 0.4.14

Lingora is a free and open-source localization management program that analyses fluent translation files highlighting discrepancies between reference and target languages. This application provides a terminal user interface; run as `lingora-tui`.
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::{collections::HashMap, rc::Rc};

use fluent4rs::ast::Entry;
use lingora_core::prelude::{AuditIssue, AuditResult, AuditedDocument, QualifiedIdentifier};

use crate::projections::{LocaleNode, LocaleNodeId, LocaleNodeKind, LocalesHierarchy};

#[derive(Debug)]
pub struct Comparison {
    reference: Option<LocaleNodeId>,
    target: Option<LocaleNodeId>,
    audit_result: Rc<AuditResult>,
    locales_hierarchy: LocalesHierarchy,
    entries: HashMap<QualifiedIdentifier, (Vec<Entry>, Vec<Entry>)>,
    issues: Vec<AuditIssue>,
}

impl Comparison {
    pub fn from_reference(
        reference: Option<LocaleNodeId>,
        audit_result: Rc<AuditResult>,
        locales_hierarchy: LocalesHierarchy,
    ) -> Self {
        let mut comparison = Self {
            reference: None,
            target: None,
            audit_result,
            locales_hierarchy,
            entries: HashMap::default(),
            issues: Vec::default(),
        };
        comparison.update_with_reference_and_target(reference, None);
        comparison
    }

    pub fn update_with_reference_and_target(
        &mut self,
        reference: Option<LocaleNodeId>,
        target: Option<LocaleNodeId>,
    ) {
        if reference != self.reference || target != self.target {
            self.reference = reference;
            self.target = target;
            self.update();
        }
    }

    fn document(&self, node: &LocaleNode) -> Option<&AuditedDocument> {
        match node.kind() {
            LocaleNodeKind::Locale { locale } => Some(locale),
            _ => None,
        }
        .and_then(|locale| self.audit_result.document(locale))
    }

    fn update(&mut self) {
        let reference_document = self
            .reference
            .and_then(|id| self.locales_hierarchy.node(&id))
            .and_then(|node| self.document(node));

        let target_document = self
            .target
            .and_then(|id| self.locales_hierarchy.node(&id))
            .and_then(|node| self.document(node));

        let document_entries = |document: Option<&AuditedDocument>, id: &QualifiedIdentifier| {
            let entries = document.iter().flat_map(|d| d.entries(id)).cloned();
            Vec::from_iter(entries)
        };

        let entries = reference_document
            .iter()
            .chain(target_document.iter())
            .flat_map(|d| d.identifiers())
            .fold(HashMap::new(), |mut acc, id| {
                let reference_entries = document_entries(reference_document, &id);
                let target_entries = document_entries(target_document, &id);
                acc.insert(id.clone(), (reference_entries, target_entries));
                acc
            });

        self.issues = Vec::from_iter(self.audit_result.issues().cloned());
        self.entries = entries;
    }

    #[inline(always)]
    pub fn locale_node(&self, node_id: &LocaleNodeId) -> Option<&LocaleNode> {
        self.locales_hierarchy.node(node_id)
    }

    #[inline(always)]
    pub fn locales_hierarchy(&self) -> &LocalesHierarchy {
        &self.locales_hierarchy
    }

    #[inline(always)]
    pub fn identifiers(&self) -> impl Iterator<Item = &QualifiedIdentifier> {
        self.entries.keys()
    }

    #[inline(always)]
    pub fn reference_entries(
        &self,
        identifier: Option<&QualifiedIdentifier>,
    ) -> impl Iterator<Item = &Entry> {
        self.entries(self.reference, identifier)
    }

    #[inline(always)]
    pub fn target_entries(
        &self,
        identifier: Option<&QualifiedIdentifier>,
    ) -> impl Iterator<Item = &Entry> {
        self.entries(self.target, identifier)
    }

    fn entries(
        &self,
        node_id: Option<LocaleNodeId>,
        identifier: Option<&QualifiedIdentifier>,
    ) -> impl Iterator<Item = &Entry> {
        identifier.into_iter().flat_map(move |identifier| {
            node_id
                .into_iter()
                .flat_map(|id| self.locales_hierarchy.node(&id))
                .flat_map(|node| {
                    matches!(node.kind(), LocaleNodeKind::Locale { .. })
                        .then(|| node)
                        .into_iter()
                })
                .flat_map(|node| {
                    if let LocaleNodeKind::Locale { locale } = node.kind() {
                        self.audit_result.document(locale)
                    } else {
                        None
                    }
                    .into_iter()
                })
                .flat_map(|doc| doc.entries(identifier))
        })
    }
}