tcss_core/

generator.rs

//! CSS Generator for TCSS
//!
//! This module converts a processed AST (with evaluated expressions) into valid CSS output.

use crate::ast::{ASTNode, Expr, Program, Property};
use crate::executor::Executor;

/// Options for CSS generation
#[derive(Debug, Clone)]
pub struct GeneratorOptions {
    /// Minify the output (remove whitespace)
    pub minify: bool,
    
    /// Indentation string (e.g., "  " or "\t")
    pub indent: String,
    
    /// Add newline at end of file
    pub trailing_newline: bool,
}

impl Default for GeneratorOptions {
    fn default() -> Self {
        Self {
            minify: false,
            indent: "  ".to_string(),
            trailing_newline: true,
        }
    }
}

/// CSS Generator
pub struct Generator {
    options: GeneratorOptions,
    executor: Executor,
}

impl Generator {
    /// Create a new generator with default options
    pub fn new() -> Self {
        Self {
            options: GeneratorOptions::default(),
            executor: Executor::new(),
        }
    }

    /// Create a new generator with custom options
    pub fn with_options(options: GeneratorOptions) -> Self {
        Self {
            options,
            executor: Executor::new(),
        }
    }

    /// Generate CSS from a TCSS program
    pub fn generate(&mut self, program: &Program) -> Result<String, String> {
        // First, execute the program to evaluate all expressions
        self.executor.execute(program)?;

        // Then, generate CSS from CSS rules
        let mut css = String::new();

        for node in &program.nodes {
            if let ASTNode::CSSRule { selector, properties } = node {
                let rule = self.generate_css_rule(selector, properties)?;
                css.push_str(&rule);
                
                if !self.options.minify {
                    css.push('\n');
                }
            }
        }

        // Add trailing newline if requested
        if self.options.trailing_newline && !css.is_empty() && !css.ends_with('\n') {
            css.push('\n');
        }

        Ok(css)
    }

    /// Generate a CSS rule
    fn generate_css_rule(&mut self, selector: &str, properties: &[Property]) -> Result<String, String> {
        let mut css = String::new();

        // Selector
        css.push_str(selector);
        
        if self.options.minify {
            css.push('{');
        } else {
            css.push_str(" {\n");
        }

        // Properties
        for (_i, property) in properties.iter().enumerate() {
            if !self.options.minify {
                css.push_str(&self.options.indent);
            }

            css.push_str(&property.name);
            css.push(':');
            
            if !self.options.minify {
                css.push(' ');
            }

            // Evaluate the property value
            let value = self.evaluate_property_value(&property.value)?;
            css.push_str(&value);
            css.push(';');

            if !self.options.minify {
                css.push('\n');
            }
        }

        // Closing brace
        css.push('}');
        
        if !self.options.minify {
            css.push('\n');
        }

        Ok(css)
    }

    /// Evaluate a property value expression
    fn evaluate_property_value(&mut self, expr: &Expr) -> Result<String, String> {
        let value = self.executor.evaluate_expr(expr)?;
        Ok(value.to_css_string())
    }

    /// Generate minified CSS from a TCSS program
    pub fn generate_minified(&mut self, program: &Program) -> Result<String, String> {
        let original_minify = self.options.minify;
        self.options.minify = true;
        let result = self.generate(program);
        self.options.minify = original_minify;
        result
    }

    /// Generate formatted CSS from a TCSS program
    pub fn generate_formatted(&mut self, program: &Program) -> Result<String, String> {
        let original_minify = self.options.minify;
        self.options.minify = false;
        let result = self.generate(program);
        self.options.minify = original_minify;
        result
    }

    /// Get a reference to the executor (for testing)
    pub fn executor(&self) -> &Executor {
        &self.executor
    }

    /// Get a mutable reference to the executor
    pub fn executor_mut(&mut self) -> &mut Executor {
        &mut self.executor
    }

    /// Get the current options
    pub fn options(&self) -> &GeneratorOptions {
        &self.options
    }

    /// Set new options
    pub fn set_options(&mut self, options: GeneratorOptions) {
        self.options = options;
    }
}

impl Default for Generator {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::lexer::Lexer;
    use crate::parser::Parser;

    fn generate_css(source: &str) -> Result<String, String> {
        let mut lexer = Lexer::new(source);
        let tokens = lexer.tokenize()?;
        let mut parser = Parser::new(tokens);
        let program = parser.parse()?;
        let mut generator = Generator::new();
        generator.generate(&program)
    }

    #[test]
    fn test_simple_css_rule() {
        let source = ".button:\n    padding: 16px\n    color: #fff";
        let css = generate_css(source).unwrap();
        assert!(css.contains(".button"));
        assert!(css.contains("padding: 16px;"));
        assert!(css.contains("color: #fff;"));
    }

    #[test]
    fn test_with_variable() {
        let source = "@var primary: #3498db\n\n.button:\n    background: primary";
        let css = generate_css(source).unwrap();
        assert!(css.contains("background: #3498db;"));
    }

    #[test]
    fn test_with_function() {
        let source = r#"
@fn spacing(x):
    return x * 16px

.container:
    padding: spacing(2)
"#;
        let css = generate_css(source).unwrap();
        assert!(css.contains("padding: 32px;"));
    }

    #[test]
    fn test_minified_output() {
        let source = ".button:\n    padding: 16px\n    color: #fff";
        let mut lexer = Lexer::new(source);
        let tokens = lexer.tokenize().unwrap();
        let mut parser = Parser::new(tokens);
        let program = parser.parse().unwrap();

        let mut generator = Generator::with_options(GeneratorOptions {
            minify: true,
            indent: "  ".to_string(),
            trailing_newline: false,
        });

        let css = generator.generate(&program).unwrap();
        assert_eq!(css, ".button{padding:16px;color:#fff;}");
    }

    #[test]
    fn test_formatted_output() {
        let source = ".button:\n    padding: 16px";
        let css = generate_css(source).unwrap();
        assert!(css.contains("  padding: 16px;"));
        assert!(css.contains("{\n"));
        assert!(css.contains("}\n"));
    }

    #[test]
    fn test_multiple_rules() {
        let source = r#"
.button:
    padding: 16px

.container:
    margin: 20px
"#;
        let css = generate_css(source).unwrap();
        assert!(css.contains(".button"));
        assert!(css.contains(".container"));
        assert!(css.contains("padding: 16px;"));
        assert!(css.contains("margin: 20px;"));
    }

    #[test]
    fn test_complex_expressions() {
        let source = r#"
@var base: 16px
@var multiplier: 2

.container:
    padding: base * multiplier
    margin: base + 8px
"#;
        let css = generate_css(source).unwrap();
        assert!(css.contains("padding: 32px;"));
        assert!(css.contains("margin: 24px;"));
    }

    #[test]
    fn test_string_values() {
        let source = r#"
@var font: "Arial"

.text:
    font-family: font
"#;
        let css = generate_css(source).unwrap();
        assert!(css.contains("font-family: Arial;"));
    }

    #[test]
    fn test_nested_function_calls() {
        let source = r#"
@fn double(x):
    return x * 2

@fn quadruple(x):
    return double(double(x))

.box:
    width: quadruple(10px)
"#;
        let css = generate_css(source).unwrap();
        assert!(css.contains("width: 40px;"));
    }
}