rustyle_css/

modules.rs

//! CSS Modules support
//!
//! Provides support for external CSS files and CSS module compilation.

use crate::parser::CssParser;
use crate::scope::generate_class_name;
use crate::style::register_style;
use std::collections::HashMap;
use std::path::Path;

/// CSS Module definition with scoped class names
#[derive(Clone, Debug)]
pub struct CssModule {
    pub name: String,
    pub css: String,
    pub class_names: HashMap<String, String>,
    pub module_id: String,
}

impl CssModule {
    /// Create a new CSS module from CSS string
    pub fn new(name: &str, css: &str) -> Self {
        let module_id = generate_class_name(&format!("{}{}", name, css));
        let mut class_names = HashMap::new();

        // Extract class names from CSS and generate scoped versions
        Self::extract_and_scope_classes(css, &module_id, &mut class_names);

        // Process and scope the CSS
        let scoped_css = Self::scope_css_module(css, &module_id, &class_names);

        Self {
            name: name.to_string(),
            css: scoped_css,
            class_names,
            module_id,
        }
    }

    /// Extract class names from CSS and generate scoped versions
    fn extract_and_scope_classes(
        css: &str,
        module_id: &str,
        class_names: &mut HashMap<String, String>,
    ) {
        use regex::Regex;

        // Match class selectors: .className
        let class_re = Regex::new(r"\.([a-zA-Z_-][a-zA-Z0-9_-]*)").unwrap();

        for cap in class_re.captures_iter(css) {
            let original_class = &cap[1];
            if !class_names.contains_key(original_class) {
                // Generate scoped class name: module_id-original_class
                let scoped = format!("{}-{}", module_id, original_class);
                class_names.insert(original_class.to_string(), scoped);
            }
        }
    }

    /// Scope CSS module by replacing class names with scoped versions
    fn scope_css_module(
        css: &str,
        _module_id: &str,
        class_names: &HashMap<String, String>,
    ) -> String {
        use regex::Regex;

        let mut scoped = css.to_string();

        // Replace all class selectors with scoped versions
        for (original, scoped_name) in class_names {
            // Match .original (but not already scoped)
            let pattern = format!(r"\.({})(?![a-zA-Z0-9_-])", regex::escape(original));
            if let Ok(re) = Regex::new(&pattern) {
                scoped = re
                    .replace_all(&scoped, |_caps: &regex::Captures| {
                        format!(".{}", scoped_name)
                    })
                    .to_string();
            }
        }

        // Process CSS through parser for validation and optimization
        CssParser::parse(&scoped).unwrap_or(scoped)
    }

    /// Register the module styles
    pub fn register(&self) {
        register_style(&self.module_id, &self.css);
    }

    /// Get a scoped class name from the module
    pub fn class(&self, name: &str) -> Option<&String> {
        self.class_names.get(name)
    }

    /// Get the module ID
    pub fn module_id(&self) -> &str {
        &self.module_id
    }

    /// Get all class names
    pub fn classes(&self) -> &HashMap<String, String> {
        &self.class_names
    }
}

/// CSS Module loader for file system support
pub struct CssModuleLoader;

impl CssModuleLoader {
    /// Load a CSS module from a file path
    ///
    /// Reads the CSS file from disk, parses it, and generates scoped class names.
    /// The path should be relative to the crate root or an absolute path.
    pub fn load<P: AsRef<Path>>(path: P) -> Result<CssModule, String> {
        let path = path.as_ref();

        // Try to read the file
        let css_content = std::fs::read_to_string(path)
            .map_err(|e| format!("Failed to read CSS file {}: {}", path.display(), e))?;

        // Use the file name (without extension) as the module name
        let module_name = path
            .file_stem()
            .and_then(|s| s.to_str())
            .unwrap_or("module");

        // Create module from content
        Ok(CssModule::new(module_name, &css_content))
    }

    /// Load a CSS module from a string
    pub fn from_str(name: &str, css: &str) -> CssModule {
        CssModule::new(name, css)
    }

    /// Load multiple CSS modules from a directory
    pub fn load_directory<P: AsRef<Path>>(dir: P) -> Result<Vec<CssModule>, String> {
        let dir = dir.as_ref();
        let mut modules = Vec::new();

        let entries = std::fs::read_dir(dir)
            .map_err(|e| format!("Failed to read directory {}: {}", dir.display(), e))?;

        for entry in entries {
            let entry = entry.map_err(|e| format!("Failed to read directory entry: {}", e))?;
            let path = entry.path();

            if path.extension().and_then(|s| s.to_str()) == Some("css") {
                match Self::load(&path) {
                    Ok(module) => modules.push(module),
                    Err(e) => eprintln!(
                        "Warning: Failed to load CSS module {}: {}",
                        path.display(),
                        e
                    ),
                }
            }
        }

        Ok(modules)
    }
}

/// Type-safe CSS module class accessor
///
/// This struct is generated by the `css_module!` macro to provide
/// type-safe access to CSS module class names.
#[derive(Clone, Debug)]
pub struct CssModuleClasses {
    module: CssModule,
}

impl CssModuleClasses {
    /// Create a new CSS module classes accessor
    pub fn new(module: CssModule) -> Self {
        Self { module }
    }

    /// Get a class name by its original name
    pub fn get(&self, name: &str) -> String {
        self.module
            .class(name)
            .cloned()
            .unwrap_or_else(|| format!("{}-{}", self.module.module_id(), name))
    }

    /// Get the module
    pub fn module(&self) -> &CssModule {
        &self.module
    }
}