eska-presentation 0.17.0

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
115
116
117
118
119
120
121
122
123
124
125
126

//! Localized application configuration errors; core retains only structured values.

use std::path::Path;

use crate::{
    localization::{LocalizationValue, Localizer},
    path_output,
};
use eska_project_core::application::SettingsError;

/// Preserve the manifest location while rendering a specific configuration failure.
pub fn present(
    localizer: &Localizer,
    path: &Path,
    error: &SettingsError,
    hyperlinks: bool,
) -> String {
    let detail = reason(localizer, error);
    localizer.format(
        "analysis-config-invalid",
        &[
            (
                "path",
                LocalizationValue::Text(&path_output::render(path, hyperlinks)),
            ),
            ("detail", LocalizationValue::Text(&detail)),
        ],
    )
}

/// Describe the rejected relationship without turning machine-facing names into translated keys.
fn reason(localizer: &Localizer, error: &SettingsError) -> String {
    match error {
        SettingsError::EmptyConfigurationSource => localizer.text("analysis-reference-empty"),
        SettingsError::ConfigurationReferenceScope => localizer.text("analysis-reference-scope"),
        SettingsError::ManagedAnalyzerField { field } => localizer.format(
            "analysis-managed-field",
            &[("field", LocalizationValue::Text(field))],
        ),
        SettingsError::InvalidAnalyzerPolicy => localizer.text("analysis-policy-invalid"),
        SettingsError::InvalidName { field, value } => localizer.format(
            "analysis-name-invalid",
            &[
                ("field", LocalizationValue::Text(field)),
                ("value", LocalizationValue::Text(value)),
            ],
        ),
        SettingsError::InvalidPlatformVersion { value } => localizer.format(
            "analysis-platform-invalid",
            &[("value", LocalizationValue::Text(value))],
        ),
        SettingsError::UnknownDefaultApplication { name } => localizer.format(
            "analysis-default-unknown",
            &[("name", LocalizationValue::Text(name.as_str()))],
        ),
        SettingsError::DuplicateMember {
            application,
            member,
        } => member_reason(
            localizer,
            "analysis-member-duplicate",
            application.as_str(),
            member.as_str(),
        ),
        SettingsError::DependencyOutsideApplication {
            application,
            member,
        } => member_reason(
            localizer,
            "analysis-dependency-outside",
            application.as_str(),
            member.as_str(),
        ),
        SettingsError::DependencyCycle { application } => localizer.format(
            "analysis-dependency-cycle",
            &[("application", LocalizationValue::Text(application.as_str()))],
        ),
        SettingsError::UnknownMember {
            application,
            member,
        } => member_reason(
            localizer,
            "analysis-member-unknown",
            application.as_str(),
            member.as_str(),
        ),
        SettingsError::WrongMemberType {
            application,
            member,
            expected,
            actual,
        } => {
            let expected = expected
                .project_types()
                .iter()
                .map(|kind| kind.as_str())
                .collect::<Vec<_>>()
                .join("|");
            localizer.format(
                "analysis-member-type",
                &[
                    ("application", LocalizationValue::Text(application.as_str())),
                    ("member", LocalizationValue::Text(member.as_str())),
                    ("expected", LocalizationValue::Text(&expected)),
                    ("actual", LocalizationValue::Text(actual.as_str())),
                ],
            )
        }
        SettingsError::MemberAnalysisUnsupported { member } => localizer.format(
            "analysis-member-settings",
            &[("member", LocalizationValue::Text(member.as_str()))],
        ),
        SettingsError::TargetPlatformScope => localizer.text("analysis-platform-scope"),
    }
}

/// Reuse the same application/member coordinates for duplicate, unknown and invalid edges.
fn member_reason(localizer: &Localizer, key: &str, application: &str, member: &str) -> String {
    localizer.format(
        key,
        &[
            ("application", LocalizationValue::Text(application)),
            ("member", LocalizationValue::Text(member)),
        ],
    )
}