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

//! Localized presentation of component transport failures.

use crate::localization::{LocalizationValue, Localizer};
use eska_tool_runtime::Error;
pub use eska_tool_runtime::contract::respond as tool_contract;

/// Present structured client failures without putting transport diagnostics on stdout.
#[must_use]
pub fn present(error: &Error, localizer: &Localizer) -> String {
    match error {
        Error::Missing { component } => localizer.format(
            "component-missing",
            &[
                ("tool", LocalizationValue::Text(component.name())),
                ("variable", LocalizationValue::Text(component.variable())),
            ],
        ),
        Error::Invalid {
            component,
            path,
            source,
        } => localizer.format(
            "component-invalid",
            &[
                ("tool", LocalizationValue::Text(component.name())),
                ("path", LocalizationValue::Text(&path.to_string_lossy())),
                ("reason", LocalizationValue::Text(&source.to_string())),
            ],
        ),
        Error::Incompatible { tool, receipt } => localizer.format(
            "component-incompatible",
            &[
                ("tool", LocalizationValue::Text(tool)),
                (
                    "receipt",
                    LocalizationValue::Text(&receipt.to_string_lossy()),
                ),
            ],
        ),
        Error::Signal(source) => localizer.format(
            "component-signal-error",
            &[("reason", LocalizationValue::Text(&source.to_string()))],
        ),
        Error::Process { component, source } => localizer.format(
            "component-process-error",
            &[
                ("tool", LocalizationValue::Text(component.name())),
                ("reason", LocalizationValue::Text(&source.to_string())),
            ],
        ),
        Error::Selection { component, path } => localizer.format(
            "component-invalid",
            &[
                ("tool", LocalizationValue::Text(component.name())),
                ("path", LocalizationValue::Text(&path.to_string_lossy())),
                (
                    "reason",
                    LocalizationValue::Text(&localizer.text("component-executable-required")),
                ),
            ],
        ),
        Error::Timeout => localizer.text("component-timeout"),
        Error::Cancelled => localizer.text("component-cancelled"),
        Error::InvalidResponse => localizer.text("component-response-invalid"),
        Error::OutputTooLarge => localizer.text("component-output-too-large"),
        Error::Failed => localizer.text("component-failed"),
        Error::Rejected {
            component, code, ..
        } => localizer.format(
            "component-rejected",
            &[
                ("tool", LocalizationValue::Text(component.name())),
                ("code", LocalizationValue::Text(code)),
            ],
        ),
    }
}

/// Refuse an incompatible managed installation after help/version parsing, before project writes.
///
/// # Errors
/// Prints the localized installation error and returns the failure status.
pub fn verify_installation(
    tool: &str,
    localizer: &Localizer,
) -> Result<(), std::process::ExitCode> {
    let result = std::env::current_exe()
        .map_err(|_| Error::Failed)
        .and_then(|binary| eska_tool_runtime::installation::verify(&binary, tool));
    result.map_err(|error| {
        eprintln!("{}", present(&error, localizer));
        std::process::ExitCode::FAILURE
    })
}