tailwind-rs-postcss 0.15.4

PostCSS integration for Tailwind-RS Core
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

//! Integration test for PostCSS functionality
//!
//! This module provides basic integration tests to verify that the PostCSS
//! engine works correctly with the existing Tailwind-RS Core.

use crate::engine::{PerformanceOptions, SourceMapOptions};
use crate::*;

/// Test basic PostCSS engine functionality
pub async fn test_basic_postcss_processing() -> Result<()> {
    let engine = PostCSSEngine::new(PostCSSConfig::default())?;
    let input_css = ".test { color: red; font-size: 16px; }";
    let result = engine.process_css(input_css).await?;

    assert!(result.css.contains(".test"));
    assert!(result.css.contains("color: red"));
    assert!(result.css.contains("font-size: 16px"));

    Ok(())
}

/// Test CSS parsing functionality
pub fn test_css_parsing() -> Result<()> {
    let parser = CSSParser::new(ParseOptions::default());
    let input = ".test { color: red; }";
    let result = parser.parse(input)?;

    match result {
        CSSNode::Stylesheet(rules) => {
            assert_eq!(rules.len(), 1);
            assert_eq!(rules[0].selector, ".test");
            assert_eq!(rules[0].declarations.len(), 1);
            assert_eq!(rules[0].declarations[0].property, "color");
            assert_eq!(rules[0].declarations[0].value, "red");
        }
        _ => panic!("Expected stylesheet"),
    }

    Ok(())
}

/// Test error handling
pub fn test_error_handling() {
    let parser = CSSParser::new(ParseOptions::default());
    let invalid_css = ".test { color: red; font-size: }"; // Missing value

    // This should either parse successfully (if we're lenient) or fail gracefully
    let result = parser.parse(invalid_css);
    // For now, we'll just ensure it doesn't panic
    let _ = result;
}

/// Test configuration
pub async fn test_configuration() -> Result<()> {
    let config = PostCSSConfig {
        source_map: true,
        source_map_options: SourceMapOptions {
            inline: false,
            file: Some("output.css.map".to_string()),
            source_root: Some("/src".to_string()),
            sources_content: true,
        },
        parser_options: ParseOptions {
            track_positions: true,
            strict_mode: false,
            custom_properties: true,
            nesting: true,
            container_queries: true,
            cascade_layers: true,
            max_nesting_depth: 10,
            plugins: Vec::new(),
        },
        transform_options: TransformOptions {
            optimize: true,
            vendor_prefixes: false,
            flatten_nesting: true,
            resolve_custom_properties: true,
        },
        performance: PerformanceOptions {
            enable_cache: true,
            cache_size_limit: 1000,
            parallel_processing: true,
            memory_optimization: true,
        },
        plugins: Vec::new(),
    };

    let engine = PostCSSEngine::new(config)?;
    assert!(engine.get_metrics().await.plugins_loaded == 0);

    Ok(())
}

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

    #[test]
    fn test_basic_parsing() {
        test_css_parsing().unwrap();
    }

    #[test]
    fn test_error_handling() {
        let parser = CSSParser::new(ParseOptions::default());
        let invalid_css = ".test { color: red; font-size: }"; // Missing value

        // This should either parse successfully (if we're lenient) or fail gracefully
        let result = parser.parse(invalid_css);
        // For now, we'll just ensure it doesn't panic
        let _ = result;
    }

    #[tokio::test]
    async fn test_configuration_async() {
        test_configuration().await.unwrap();
    }

    #[tokio::test]
    async fn test_basic_processing() {
        test_basic_postcss_processing().await.unwrap();
    }
}