harn-cli 0.8.0

CLI for the Harn programming language — run, test, REPL, format, and lint
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

//! Typed error enum for the `orchestrator` CLI module.
//!
//! Variants preserve exact user-facing message text via `Display`, keeping
//! the CLI's printed output byte-for-byte identical to the prior
//! `Result<T, String>` API while giving library callers a stable type.

use std::result::Result as StdResult;

use crate::package::errors::PackageError;

#[derive(Debug, thiserror::Error)]
pub enum OrchestratorError {
    #[error("{0}")]
    Common(String),
    #[error("{0}")]
    Listener(String),
    #[error("{0}")]
    Serve(String),
    #[error("{0}")]
    Deploy(String),
    #[error("{0}")]
    Inspect(String),
    #[error("{0}")]
    Stats(String),
    #[error("{0}")]
    Reload(String),
    #[error("{0}")]
    Recover(String),
    #[error("{0}")]
    Tenant(String),
    #[error("{0}")]
    Tls(String),
    #[error("{0}")]
    Queue(String),
    #[error("{0}")]
    Dlq(String),
    #[error("{0}")]
    Fire(String),
    #[error("{0}")]
    Replay(String),
    #[error("{0}")]
    Resume(String),
    #[error("{0}")]
    Role(String),
    /// Generic message captured during the `Result<T, String>` migration.
    /// New code should prefer one of the categorical variants above.
    #[error("{0}")]
    Other(String),
    #[error(transparent)]
    Package(#[from] PackageError),
}

impl OrchestratorError {
    pub fn message(&self) -> String {
        match self {
            OrchestratorError::Common(s)
            | OrchestratorError::Listener(s)
            | OrchestratorError::Serve(s)
            | OrchestratorError::Deploy(s)
            | OrchestratorError::Inspect(s)
            | OrchestratorError::Stats(s)
            | OrchestratorError::Reload(s)
            | OrchestratorError::Recover(s)
            | OrchestratorError::Tenant(s)
            | OrchestratorError::Tls(s)
            | OrchestratorError::Queue(s)
            | OrchestratorError::Dlq(s)
            | OrchestratorError::Fire(s)
            | OrchestratorError::Replay(s)
            | OrchestratorError::Resume(s)
            | OrchestratorError::Role(s)
            | OrchestratorError::Other(s) => s.clone(),
            OrchestratorError::Package(err) => err.to_string(),
        }
    }
}

impl From<String> for OrchestratorError {
    fn from(value: String) -> Self {
        OrchestratorError::Other(value)
    }
}

impl From<&str> for OrchestratorError {
    fn from(value: &str) -> Self {
        OrchestratorError::Other(value.to_string())
    }
}

/// Migration bridge: lets callers that still return `Result<T, String>`
/// receive an `OrchestratorError` via `?` without losing the user-facing
/// message. Once all CLI command modules adopt typed errors this can be
/// removed.
impl From<OrchestratorError> for String {
    fn from(error: OrchestratorError) -> Self {
        error.to_string()
    }
}

pub type OrchestratorResult<T> = StdResult<T, OrchestratorError>;