scriba 0.4.0

CLI text rendering, prompts, and terminal output utilities
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
144
145
146
147
148
149

//! Error types and result type for scriba operations.

use thiserror::Error;

/// Result type for scriba operations.
///
/// # Example
///
/// ```
/// use scriba::Result;
///
/// fn setup_output() -> Result<String> {
///     Ok("Hello".to_string())
/// }
/// ```
pub type Result<T> = std::result::Result<T, ScribaError>;

/// Error types returned by scriba operations.
///
/// # Examples
///
/// ```
/// use scriba::Error;
///
/// let err = Error::InteractiveRequired;
/// assert_eq!(err.to_string(), "interactive prompt required");
/// ```
#[derive(Debug, Error)]
pub enum ScribaError {
    /// Interactive mode was required but not enabled in config.
    #[error("interactive prompt required")]
    InteractiveRequired,

    /// User cancelled an interactive prompt.
    #[error("prompt cancelled")]
    PromptCancelled,

    /// Prompt operation failed.
    #[error("prompt failed: {0}")]
    Prompt(String),

    /// Output rendering failed.
    #[error("render failed: {0}")]
    Render(String),

    /// JSON serialization failed.
    #[error("serialization failed: {0}")]
    Serialization(String),

    /// I/O operation failed.
    #[error("io failed: {0}")]
    Io(String),
}

impl From<std::io::Error> for ScribaError {
    fn from(err: std::io::Error) -> Self {
        Self::Io(err.to_string())
    }
}

impl From<serde_json::Error> for ScribaError {
    fn from(err: serde_json::Error) -> Self {
        Self::Serialization(err.to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io;

    #[test]
    fn error_interactive_required_message() {
        let err = ScribaError::InteractiveRequired;
        assert_eq!(err.to_string(), "interactive prompt required");
    }

    #[test]
    fn error_prompt_cancelled_message() {
        let err = ScribaError::PromptCancelled;
        assert_eq!(err.to_string(), "prompt cancelled");
    }

    #[test]
    fn error_prompt_message() {
        let err = ScribaError::Prompt("invalid input".to_string());
        assert!(err.to_string().contains("invalid input"));
    }

    #[test]
    fn error_render_message() {
        let err = ScribaError::Render("failed to render".to_string());
        assert!(err.to_string().contains("failed to render"));
    }

    #[test]
    fn error_serialization_message() {
        let err = ScribaError::Serialization("bad json".to_string());
        assert!(err.to_string().contains("bad json"));
    }

    #[test]
    fn error_io_message() {
        let err = ScribaError::Io("file not found".to_string());
        assert!(err.to_string().contains("file not found"));
    }

    #[test]
    fn io_error_converts_to_scriba_error() {
        let io_err = io::Error::new(io::ErrorKind::NotFound, "test error");
        let scriba_err: ScribaError = io_err.into();

        match scriba_err {
            ScribaError::Io(msg) => assert!(msg.contains("test error")),
            _ => panic!("expected Io error"),
        }
    }

    #[test]
    fn json_error_converts_to_scriba_error() {
        let json_err = serde_json::from_str::<serde_json::Value>("invalid json").unwrap_err();
        let scriba_err: ScribaError = json_err.into();

        match scriba_err {
            ScribaError::Serialization(_) => {} // Expected
            _ => panic!("expected Serialization error"),
        }
    }

    #[test]
    fn result_type_is_correct() {
        fn returns_result() -> Result<String> {
            Ok("success".to_string())
        }

        let result = returns_result();
        assert!(result.is_ok());
    }

    #[test]
    fn result_error() {
        fn returns_error() -> Result<String> {
            Err(ScribaError::Render("test".to_string()))
        }

        let result = returns_error();
        assert!(result.is_err());
    }
}