context-engine 0.1.6-alpha.1

Declarative state data management system for process
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

use crate::ports::provided::Value;

/// # Examples
/// ```
/// use state_engine::LogFormat;
///
/// let fn_message = LogFormat::call("State", "get", &["'key'".to_string()]);
/// assert_eq!(fn_message, "State::get('key')");
/// ```
pub struct LogFormat;

impl LogFormat {
    pub fn call(class: &str, fn_name: &str, args: &[String]) -> String {
        let args_str = args.join(", ");
        format!("{}::{}({})", class, fn_name, args_str)
    }

    /// Format Value for log output
    ///
    /// # Examples
    /// ```
    /// use state_engine::{LogFormat, Value};
    ///
    /// assert_eq!(LogFormat::format_arg(&Value::Scalar(b"text".to_vec())), "'text'");
    /// assert_eq!(LogFormat::format_arg(&Value::Null), "null");
    /// assert_eq!(LogFormat::format_arg(&Value::Sequence(vec![])), "[]");
    /// assert_eq!(LogFormat::format_arg(&Value::Mapping(vec![])), "{}");
    /// assert_eq!(LogFormat::format_arg(&Value::Sequence(vec![Value::Null, Value::Null, Value::Null])), "[3 items]");
    /// assert_eq!(LogFormat::format_arg(&Value::Mapping(vec![(b"a".to_vec(), Value::Null)])), "{1 fields}");
    /// ```
    pub fn format_arg(value: &Value) -> String {
        match value {
            Value::Scalar(b) => {
                let s = String::from_utf8_lossy(b);
                if s.len() > 50 { format!("'{}'...", &s[..47]) } else { format!("'{}'", s) }
            }
            Value::Sequence(arr) if arr.is_empty() => "[]".to_string(),
            Value::Sequence(arr) => format!("[{} items]", arr.len()),
            Value::Mapping(obj) if obj.is_empty() => "{}".to_string(),
            Value::Mapping(obj) => format!("{{{} fields}}", obj.len()),
            Value::Null => "null".to_string(),
        }
    }

    /// Format string argument for log output
    ///
    /// # Examples
    /// ```
    /// use state_engine::LogFormat;
    ///
    /// assert_eq!(LogFormat::format_str_arg("key"), "'key'");
    /// ```
    pub fn format_str_arg(s: &str) -> String {
        if s.len() > 50 {
            format!("'{}'...", &s[..47])
        } else {
            format!("'{}'", s)
        }
    }
}

/// Log macro: fn call
///
/// # Examples
/// ```ignore
/// use crate::fn_log;
///
/// fn_log!("State", "get", "cache.user");
/// // Logs: State::get('cache.user')
/// ```
#[macro_export]
macro_rules! fn_log {
    ($class:expr, $fun:expr $(, $arg:expr)*) => {{
        #[cfg(feature = "logging")]
        {
            let args: Vec<String> = vec![
                $(
                    $crate::log_format::LogFormat::format_str_arg($arg),
                )*
            ];
            log::debug!("{}", $crate::log_format::LogFormat::call($class, $fun, &args));
        }
    }};
}

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

    #[test]
    fn test_fn_multiple_args() {
        let result = LogFormat::call("State", "get", &[
            "'cache.user'".to_string(),
            "null".to_string(),
        ]);
        assert_eq!(result, "State::get('cache.user', null)");
    }

    #[test]
    fn test_format_arg_long_string() {
        let long_str = "a".repeat(60);
        let result = LogFormat::format_arg(&Value::Scalar(long_str.into_bytes()));
        assert!(result.starts_with("'aaa"));
        assert!(result.ends_with("'..."));
        assert_eq!(result.len(), 52);
    }

    #[test]
    fn test_format_str_arg_long_string() {
        let long_str = "a".repeat(60);
        let result = LogFormat::format_str_arg(&long_str);
        assert!(result.starts_with("'aaa"));
        assert!(result.ends_with("'..."));
    }
}