ruchy 4.1.1

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
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

//! WASM Helper Functions
//!
//! Platform-agnostic utilities for WASM REPL.

/// Generate a unique session ID
pub fn generate_session_id() -> String {
    #[cfg(target_arch = "wasm32")]
    {
        // Use browser's crypto API for UUID
        format!("session-{}", js_sys::Date::now())
    }
    #[cfg(not(target_arch = "wasm32"))]
    {
        // Use system time for non-WASM builds
        format!(
            "session-{}",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .expect("SystemTime should be after UNIX_EPOCH")
                .as_millis()
        )
    }
}

/// Get current timestamp in milliseconds
pub fn get_timestamp() -> f64 {
    #[cfg(target_arch = "wasm32")]
    {
        js_sys::Date::now()
    }
    #[cfg(not(target_arch = "wasm32"))]
    {
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .expect("SystemTime should be after UNIX_EPOCH")
            .as_millis() as f64
    }
}

/// `JsValue` stub for non-WASM builds
#[cfg(not(target_arch = "wasm32"))]
#[derive(Debug, Clone)]
pub struct JsValue;

#[cfg(target_arch = "wasm32")]
pub use wasm_bindgen::prelude::JsValue;

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

    #[test]
    fn test_generate_session_id() {
        let id = generate_session_id();
        assert!(id.starts_with("session-"));
    }

    #[test]
    fn test_generate_session_id_unique() {
        let id1 = generate_session_id();
        std::thread::sleep(std::time::Duration::from_millis(1));
        let id2 = generate_session_id();
        assert_ne!(id1, id2);
    }

    #[test]
    fn test_get_timestamp() {
        let ts = get_timestamp();
        assert!(ts > 0.0);
    }

    #[test]
    fn test_get_timestamp_monotonic() {
        let ts1 = get_timestamp();
        std::thread::sleep(std::time::Duration::from_millis(1));
        let ts2 = get_timestamp();
        assert!(ts2 >= ts1);
    }

    #[test]
    fn test_get_timestamp_reasonable_value() {
        let ts = get_timestamp();
        // Should be after year 2020 (1577836800000 ms)
        assert!(ts > 1_577_836_800_000.0);
    }

    #[cfg(not(target_arch = "wasm32"))]
    #[test]
    fn test_jsvalue_stub_debug() {
        let js = JsValue;
        let debug = format!("{:?}", js);
        assert!(debug.contains("JsValue"));
    }

    #[cfg(not(target_arch = "wasm32"))]
    #[test]
    fn test_jsvalue_stub_clone() {
        let js = JsValue;
        let _cloned = js.clone();
    }

    // ===== Property Tests =====

    #[cfg(test)]
    mod property_tests {
        use super::*;
        use proptest::prelude::*;

        proptest! {
            #![proptest_config(ProptestConfig::with_cases(100))]

            /// Property: Session IDs always start with "session-"
            #[test]
            fn prop_session_id_format(_dummy: u8) {
                let id = generate_session_id();
                prop_assert!(id.starts_with("session-"));
            }

            /// Property: Timestamps are always positive
            #[test]
            fn prop_timestamp_positive(_dummy: u8) {
                let ts = get_timestamp();
                prop_assert!(ts > 0.0);
            }

            /// Property: Timestamps are monotonically increasing
            #[test]
            fn prop_timestamp_monotonic(_dummy: u8) {
                let ts1 = get_timestamp();
                let ts2 = get_timestamp();
                prop_assert!(ts2 >= ts1);
            }
        }
    }
}