blocks 0.1.0

A high-performance Rust library for block-based content editing with JSON, Markdown, and HTML support
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

use thiserror::Error;

/// Error types for the blocks library
#[derive(Error, Debug, Clone, PartialEq)]
pub enum BlocksError {
    #[error("Invalid block type: {0}")]
    InvalidBlockType(String),

    #[error("Invalid header level: {level}. Must be between 1 and 6")]
    InvalidHeaderLevel { level: u8 },

    #[error("Empty content not allowed for block type: {block_type}")]
    EmptyContent { block_type: String },

    #[error("Conversion error: {message}")]
    ConversionError { message: String },

    #[error("Serialization error: {0}")]
    SerializationError(String),

    #[error("Invalid URL format: {url}")]
    InvalidUrl { url: String },

    #[error("Invalid image format: {reason}")]
    InvalidImage { reason: String },

    #[error("Document validation failed: {message}")]
    ValidationError { message: String },

    #[error("Invalid table structure: {reason}")]
    InvalidTable { reason: String },

    #[error("Invalid columns configuration: {reason}")]
    InvalidColumns { reason: String },

    #[error("Invalid embed configuration: {reason}")]
    InvalidEmbed { reason: String },

    #[error("CSS parsing error: {reason}")]
    CssError { reason: String },
}

/// Result type for the blocks library
pub type Result<T> = std::result::Result<T, BlocksError>;

impl From<serde_json::Error> for BlocksError {
    fn from(err: serde_json::Error) -> Self {
        BlocksError::SerializationError(err.to_string())
    }
}

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

    #[test]
    fn test_error_display() {
        let err = BlocksError::InvalidHeaderLevel { level: 10 };
        assert_eq!(
            err.to_string(),
            "Invalid header level: 10. Must be between 1 and 6"
        );
    }

    #[test]
    fn test_error_clone() {
        let err = BlocksError::EmptyContent {
            block_type: "Text".to_string(),
        };
        let cloned = err.clone();
        assert_eq!(err, cloned);
    }

    #[test]
    fn test_from_serde_error() {
        let json_err = serde_json::from_str::<i32>("invalid json").unwrap_err();
        let blocks_err = BlocksError::from(json_err);
        match blocks_err {
            BlocksError::SerializationError(msg) => assert!(msg.contains("expected")),
            _ => panic!("Expected SerializationError"),
        }
    }
}