tcss_core/

resolver.rs

//! Path and URL resolution for TCSS imports
//!
//! This module handles resolving import paths to actual file locations:
//! - Relative paths: './colors.tcss', '../theme.tcss'
//! - Absolute paths: '/styles/base.tcss'
//! - URLs: 'https://cdn.tcss.io/animations.tcss'
//! - Package imports: '@tcss/core', 'package-name/file.tcss'

use std::path::{Path, PathBuf};

/// Type of import path
#[derive(Debug, Clone, PartialEq)]
pub enum ImportType {
    /// Relative file path (./file.tcss, ../file.tcss)
    Relative,
    
    /// Absolute file path (/path/to/file.tcss)
    Absolute,
    
    /// HTTP/HTTPS URL
    Url,
    
    /// Package import (@tcss/core, package-name)
    Package,
}

/// Resolved import information
#[derive(Debug, Clone)]
pub struct ResolvedImport {
    /// Original import path
    pub original_path: String,
    
    /// Resolved absolute path or URL
    pub resolved_path: String,
    
    /// Type of import
    pub import_type: ImportType,
}

/// Import path resolver
pub struct Resolver {
    /// Base directory for resolving relative paths
    base_dir: PathBuf,
    
    /// Package resolution paths (like node_modules)
    package_paths: Vec<PathBuf>,
}

impl Resolver {
    /// Create a new resolver with a base directory
    pub fn new<P: AsRef<Path>>(base_dir: P) -> Self {
        Self {
            base_dir: base_dir.as_ref().to_path_buf(),
            package_paths: vec![
                PathBuf::from("node_modules"),
                PathBuf::from("tcss_modules"),
            ],
        }
    }
    
    /// Add a package resolution path
    pub fn add_package_path<P: AsRef<Path>>(&mut self, path: P) {
        self.package_paths.push(path.as_ref().to_path_buf());
    }
    
    /// Resolve an import path
    pub fn resolve(&self, import_path: &str) -> Result<ResolvedImport, String> {
        let import_type = self.detect_import_type(import_path);
        
        let resolved_path = match import_type {
            ImportType::Relative => self.resolve_relative(import_path)?,
            ImportType::Absolute => self.resolve_absolute(import_path)?,
            ImportType::Url => import_path.to_string(),
            ImportType::Package => self.resolve_package(import_path)?,
        };
        
        Ok(ResolvedImport {
            original_path: import_path.to_string(),
            resolved_path,
            import_type,
        })
    }
    
    /// Detect the type of import path
    fn detect_import_type(&self, path: &str) -> ImportType {
        if path.starts_with("http://") || path.starts_with("https://") {
            ImportType::Url
        } else if path.starts_with("./") || path.starts_with("../") {
            ImportType::Relative
        } else if path.starts_with('/') {
            ImportType::Absolute
        } else {
            ImportType::Package
        }
    }
    
    /// Resolve a relative path
    fn resolve_relative(&self, path: &str) -> Result<String, String> {
        let full_path = self.base_dir.join(path);
        
        // Normalize the path
        let normalized = self.normalize_path(&full_path)?;
        
        // Check if file exists (optional, can be disabled for flexibility)
        if !normalized.exists() {
            return Err(format!("Import file not found: {}", path));
        }
        
        normalized
            .to_str()
            .ok_or_else(|| format!("Invalid path: {}", path))
            .map(|s| s.to_string())
    }
    
    /// Resolve an absolute path
    fn resolve_absolute(&self, path: &str) -> Result<String, String> {
        let full_path = PathBuf::from(path);
        
        if !full_path.exists() {
            return Err(format!("Import file not found: {}", path));
        }
        
        full_path
            .to_str()
            .ok_or_else(|| format!("Invalid path: {}", path))
            .map(|s| s.to_string())
    }
    
    /// Resolve a package import
    fn resolve_package(&self, path: &str) -> Result<String, String> {
        // Split package name and file path
        let (package_name, file_path) = if let Some(slash_pos) = path.find('/') {
            (&path[..slash_pos], Some(&path[slash_pos + 1..]))
        } else {
            (path, None)
        };
        
        // Try each package path
        for pkg_dir in &self.package_paths {
            let mut package_path = pkg_dir.join(package_name);
            
            // If no file path specified, look for index.tcss or main file
            if let Some(file) = file_path {
                package_path = package_path.join(file);
            } else {
                // Try index.tcss first
                let index_path = package_path.join("index.tcss");
                if index_path.exists() {
                    package_path = index_path;
                }
            }

            if package_path.exists() {
                return package_path
                    .to_str()
                    .ok_or_else(|| format!("Invalid package path: {}", path))
                    .map(|s| s.to_string());
            }
        }

        Err(format!("Package not found: {}", path))
    }

    /// Normalize a path (resolve .. and .)
    fn normalize_path(&self, path: &Path) -> Result<PathBuf, String> {
        path.canonicalize()
            .map_err(|e| format!("Failed to normalize path: {}", e))
    }

    /// Change the base directory
    pub fn set_base_dir<P: AsRef<Path>>(&mut self, base_dir: P) {
        self.base_dir = base_dir.as_ref().to_path_buf();
    }

    /// Get the current base directory
    pub fn base_dir(&self) -> &Path {
        &self.base_dir
    }
}

impl Default for Resolver {
    fn default() -> Self {
        Self::new(".")
    }
}

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

    #[test]
    fn test_detect_import_type() {
        let resolver = Resolver::new(".");

        assert_eq!(resolver.detect_import_type("./file.tcss"), ImportType::Relative);
        assert_eq!(resolver.detect_import_type("../file.tcss"), ImportType::Relative);
        assert_eq!(resolver.detect_import_type("/abs/path.tcss"), ImportType::Absolute);
        assert_eq!(resolver.detect_import_type("https://example.com/file.tcss"), ImportType::Url);
        assert_eq!(resolver.detect_import_type("@tcss/core"), ImportType::Package);
        assert_eq!(resolver.detect_import_type("package-name"), ImportType::Package);
    }

    #[test]
    fn test_add_package_path() {
        let mut resolver = Resolver::new(".");
        resolver.add_package_path("custom_modules");

        assert_eq!(resolver.package_paths.len(), 3);
    }
}