vibe-ready 0.1.1

This is the project framework for vibe coding, with multiple optional modules, aiming to quickly build vibe coding projects
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

use crate::api::engine_error::{VibeEngineError, VibeEngineErrorCode};
use crate::log::log_def::DESC;
use crate::{err, log_e};
use serde::{Deserialize, Serialize};
use std::backtrace::Backtrace;
use std::fmt;

#[repr(i32)]
#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize, Eq, Default)]
pub enum VibeConnectionStatus {
    #[default]
    Idle,

    Connecting,

    Connected,

    Disconnecting,

    Disconnected,
}

impl fmt::Display for VibeConnectionStatus {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            VibeConnectionStatus::Idle => "Idle",
            VibeConnectionStatus::Connecting => "Connecting",
            VibeConnectionStatus::Connected => "Connected",
            VibeConnectionStatus::Disconnecting => "Disconnecting",
            VibeConnectionStatus::Disconnected => "Disconnected",
        };
        write!(f, "{}", s)
    }
}

fn trans_unreachable(
    from: VibeConnectionStatus,
    to: VibeConnectionStatus,
) -> Result<VibeConnectionStatus, VibeEngineError> {
    log_e!(
        "trans_unreachable",
        DESC,
        format!(
            "trans_unreachable_test error , from: {:?},to: {:?}, -- {:?}",
            from,
            to,
            Backtrace::capture()
        )
    );
    Err(err!(VibeEngineError::from_internal_error()))
}

impl VibeConnectionStatus {
    pub fn trans(
        &mut self,
        new_status: VibeConnectionStatus,
    ) -> Result<VibeConnectionStatus, VibeEngineError> {
        let ret = match self {
            VibeConnectionStatus::Idle => match new_status {
                VibeConnectionStatus::Idle => Ok(VibeConnectionStatus::Idle),
                VibeConnectionStatus::Connecting => Ok(VibeConnectionStatus::Connecting),
                VibeConnectionStatus::Connected => trans_unreachable(self.clone(), new_status),
                VibeConnectionStatus::Disconnecting => Err(err!(VibeEngineError::from_error_code(
                    VibeEngineErrorCode::ConnectionClosed
                ))),
                VibeConnectionStatus::Disconnected => Ok(VibeConnectionStatus::Disconnected),
            },
            VibeConnectionStatus::Connecting => match new_status {
                VibeConnectionStatus::Idle => Ok(VibeConnectionStatus::Idle),
                VibeConnectionStatus::Connecting => trans_unreachable(self.clone(), new_status),
                VibeConnectionStatus::Connected => Ok(VibeConnectionStatus::Connected),
                VibeConnectionStatus::Disconnecting => Ok(VibeConnectionStatus::Disconnecting),
                VibeConnectionStatus::Disconnected => Ok(VibeConnectionStatus::Disconnected),
            },
            VibeConnectionStatus::Connected => match new_status {
                VibeConnectionStatus::Idle => Ok(VibeConnectionStatus::Idle),
                VibeConnectionStatus::Connecting => Err(VibeEngineError::from_error_code(
                    VibeEngineErrorCode::ConnectionExists,
                )),
                VibeConnectionStatus::Connected => trans_unreachable(self.clone(), new_status),
                VibeConnectionStatus::Disconnecting => Ok(VibeConnectionStatus::Disconnecting),
                VibeConnectionStatus::Disconnected => Ok(VibeConnectionStatus::Disconnected),
            },
            VibeConnectionStatus::Disconnecting => match new_status {
                VibeConnectionStatus::Idle => Ok(VibeConnectionStatus::Idle),
                VibeConnectionStatus::Connecting => Ok(VibeConnectionStatus::Connecting),
                VibeConnectionStatus::Connected => trans_unreachable(self.clone(), new_status),
                VibeConnectionStatus::Disconnecting => Err(err!(VibeEngineError::from_error_code(
                    VibeEngineErrorCode::ConnectionClosing
                ))),
                VibeConnectionStatus::Disconnected => Ok(VibeConnectionStatus::Disconnected),
            },
            VibeConnectionStatus::Disconnected => match new_status {
                VibeConnectionStatus::Idle => Ok(VibeConnectionStatus::Idle),
                VibeConnectionStatus::Connecting => Ok(VibeConnectionStatus::Connecting),
                VibeConnectionStatus::Connected => trans_unreachable(self.clone(), new_status),
                VibeConnectionStatus::Disconnecting => Err(err!(VibeEngineError::from_error_code(
                    VibeEngineErrorCode::ConnectionClosed,
                ))),
                VibeConnectionStatus::Disconnected => Ok(VibeConnectionStatus::Disconnected),
            },
        };
        *self = ret?;
        Ok(*self)
    }
}