cuengine 0.26.19

Go-Rust FFI bridge for CUE evaluation with production-ready features
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

//! Error types for CUE evaluation
//!
//! This module provides standalone error types for the cuengine crate,
//! allowing it to be used independently of the cuenv ecosystem.

use std::path::Path;
use thiserror::Error;

/// Errors that can occur during CUE evaluation
#[derive(Error, Debug)]
pub enum CueEngineError {
    /// Configuration error (invalid paths, settings, etc.)
    #[error("Configuration error: {message}")]
    Configuration {
        /// Error message describing the configuration problem
        message: String,
    },

    /// FFI operation failed
    #[error("FFI operation failed in {function}: {message}")]
    Ffi {
        /// Name of the FFI function that failed
        function: &'static str,
        /// Error message from the FFI layer
        message: String,
    },

    /// CUE parsing or evaluation failed
    #[error("CUE parsing failed at {}: {message}", path.display())]
    CueParse {
        /// Path to the CUE file that failed to parse
        path: Box<Path>,
        /// Error message from the CUE parser
        message: String,
    },

    /// Validation error (input/output validation)
    #[error("Validation failed: {message}")]
    Validation {
        /// Error message describing the validation failure
        message: String,
    },

    /// Cache operation error
    #[error("Cache error: {message}")]
    Cache {
        /// Error message describing the cache problem
        message: String,
    },
}

impl CueEngineError {
    /// Create a configuration error
    #[must_use]
    pub fn configuration(message: impl Into<String>) -> Self {
        Self::Configuration {
            message: message.into(),
        }
    }

    /// Create an FFI error
    #[must_use]
    pub fn ffi(function: &'static str, message: impl Into<String>) -> Self {
        Self::Ffi {
            function,
            message: message.into(),
        }
    }

    /// Create a CUE parse error
    #[must_use]
    pub fn cue_parse(path: &Path, message: impl Into<String>) -> Self {
        Self::CueParse {
            path: path.into(),
            message: message.into(),
        }
    }

    /// Create a validation error
    #[must_use]
    pub fn validation(message: impl Into<String>) -> Self {
        Self::Validation {
            message: message.into(),
        }
    }

    /// Create a cache error
    #[must_use]
    pub fn cache(message: impl Into<String>) -> Self {
        Self::Cache {
            message: message.into(),
        }
    }
}

/// Result type for CUE evaluation operations
pub type Result<T> = std::result::Result<T, CueEngineError>;

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

    #[test]
    fn test_configuration_error() {
        let err = CueEngineError::configuration("invalid setting");
        assert!(err.to_string().contains("Configuration error"));
        assert!(err.to_string().contains("invalid setting"));
    }

    #[test]
    fn test_ffi_error() {
        let err = CueEngineError::ffi("cue_eval_package", "null pointer");
        assert!(err.to_string().contains("FFI operation failed"));
        assert!(err.to_string().contains("cue_eval_package"));
        assert!(err.to_string().contains("null pointer"));
    }

    #[test]
    fn test_cue_parse_error() {
        let path = Path::new("/some/path");
        let err = CueEngineError::cue_parse(path, "syntax error");
        assert!(err.to_string().contains("CUE parsing failed"));
        assert!(err.to_string().contains("/some/path"));
        assert!(err.to_string().contains("syntax error"));
    }

    #[test]
    fn test_validation_error() {
        let err = CueEngineError::validation("path too long");
        assert!(err.to_string().contains("Validation failed"));
        assert!(err.to_string().contains("path too long"));
    }

    #[test]
    fn test_cache_error() {
        let err = CueEngineError::cache("capacity must be non-zero");
        assert!(err.to_string().contains("Cache error"));
        assert!(err.to_string().contains("capacity must be non-zero"));
    }

    #[test]
    fn test_error_is_send_sync() {
        fn assert_send_sync<T: Send + Sync>() {}
        assert_send_sync::<CueEngineError>();
    }
}