reratui-macro 0.1.0

Procedural macros for component definition, RSX syntax, and hook validation in Reratui
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

/// Comprehensive error type for RSX macro processing
#[derive(Debug, thiserror::Error)]
pub enum RsxError {
    #[error("Invalid component name: {message}")]
    InvalidComponentName {
        message: String,
        span: proc_macro2::Span,
        suggestion: Option<String>,
    },

    #[error("Invalid attribute: {message}")]
    #[allow(unused)]
    InvalidAttribute {
        message: String,
        span: proc_macro2::Span,
        suggestion: Option<String>,
    },

    #[error("Mismatched tags: {message}")]
    MismatchedTags {
        message: String,
        span: proc_macro2::Span,
        opening_tag: String,
        closing_tag: String,
    },

    #[error("Syntax error: {message}")]
    SyntaxError {
        message: String,
        span: proc_macro2::Span,
        suggestion: Option<String>,
    },

    #[error("Validation error: {message}")]
    ValidationError {
        message: String,
        span: proc_macro2::Span,
        details: Option<String>,
    },

    #[error("Internal error: {message}")]
    #[allow(unused)]
    InternalError { message: String, context: String },

    #[error("For-loop error: {message}")]
    ForLoopError {
        message: String,
        span: proc_macro2::Span,
        suggestion: Option<String>,
    },
}

impl RsxError {
    /// Convert to a syn::Error with rich formatting
    pub fn to_syn_error(&self) -> syn::Error {
        match self {
            RsxError::InvalidComponentName {
                message,
                span,
                suggestion,
            } => {
                let error_msg = if let Some(suggestion) = suggestion {
                    format!(
                        "Invalid component name: {}\n\nSuggestion: {}",
                        message, suggestion
                    )
                } else {
                    format!("Invalid component name: {}", message)
                };
                syn::Error::new(*span, error_msg)
            }
            RsxError::InvalidAttribute {
                message,
                span,
                suggestion,
            } => {
                let error_msg = if let Some(suggestion) = suggestion {
                    format!(
                        "Invalid attribute: {}\n\nSuggestion: {}",
                        message, suggestion
                    )
                } else {
                    format!("Invalid attribute: {}", message)
                };
                syn::Error::new(*span, error_msg)
            }
            RsxError::MismatchedTags {
                message,
                span,
                opening_tag,
                closing_tag,
            } => {
                let error_msg = format!(
                    "Mismatched tags: {}\n\nOpening tag: <{}>\nClosing tag: </{}>\n\nTags must match exactly.",
                    message, opening_tag, closing_tag
                );
                syn::Error::new(*span, error_msg)
            }
            RsxError::SyntaxError {
                message,
                span,
                suggestion,
            } => {
                let error_msg = if let Some(suggestion) = suggestion {
                    format!("Syntax error: {}\n\nSuggestion: {}", message, suggestion)
                } else {
                    format!("Syntax error: {}", message)
                };
                syn::Error::new(*span, error_msg)
            }
            RsxError::ValidationError {
                message,
                span,
                details,
            } => {
                let error_msg = if let Some(details) = details {
                    format!("Validation error: {}\n\nDetails: {}", message, details)
                } else {
                    format!("Validation error: {}", message)
                };
                syn::Error::new(*span, error_msg)
            }
            RsxError::InternalError { message, context } => {
                let error_msg = format!(
                    "Internal error: {}\nContext: {}\n\nThis is likely a bug in the RSX macro. Please report it.",
                    message, context
                );
                syn::Error::new(proc_macro2::Span::call_site(), error_msg)
            }
            RsxError::ForLoopError {
                message,
                span,
                suggestion,
            } => {
                let error_msg = if let Some(suggestion) = suggestion {
                    format!("For-loop error: {}\n\nSuggestion: {}", message, suggestion)
                } else {
                    format!("For-loop error: {}", message)
                };
                syn::Error::new(*span, error_msg)
            }
        }
    }
}

// Result type for RSX operations
// pub type RsxResult<T> = Result<T, RsxError>;