dnx_core/

patch.rs

use crate::errors::{DnxError, Result};
use std::collections::HashMap;
use std::path::{Path, PathBuf};

/// Manages patched dependencies.
/// Patches are stored as .patch files in a `patches/` directory and applied during install.
pub struct PatchManager {
    project_root: PathBuf,
    /// Map of "pkg@version" → patch file path
    patches: HashMap<String, String>,
}

impl PatchManager {
    pub fn new(project_root: PathBuf, patches: HashMap<String, String>) -> Self {
        Self {
            project_root,
            patches,
        }
    }

    /// Prepare a package for patching by extracting it to a temp directory.
    /// Returns the path to the temp directory where the user can make changes.
    pub fn prepare_patch(&self, package_name: &str, version: &str) -> Result<PathBuf> {
        let pkg_key = format!("{}@{}", package_name, version);
        let node_modules = self.project_root.join("node_modules");
        let dnx_dir = node_modules.join(".dnx");
        let pkg_dir = dnx_dir
            .join(&pkg_key)
            .join("node_modules")
            .join(package_name);

        if !pkg_dir.exists() {
            return Err(DnxError::Linker(format!(
                "Package {} is not installed. Run `dnx install` first.",
                pkg_key
            )));
        }

        // Create a temp directory and copy the package into it
        let patch_dir = self.project_root.join(".dnx-patches");
        std::fs::create_dir_all(&patch_dir)
            .map_err(|e| DnxError::Io(format!("Failed to create patch directory: {}", e)))?;

        let target = patch_dir.join(&pkg_key);
        if target.exists() {
            std::fs::remove_dir_all(&target)
                .map_err(|e| DnxError::Io(format!("Failed to clean patch directory: {}", e)))?;
        }

        copy_dir_recursive(&pkg_dir, &target)?;

        Ok(target)
    }

    /// Commit a patch by generating a diff between the original installed package
    /// and the modified version in the patch directory.
    /// Writes the patch file to `patches/<pkg>@<version>.patch`.
    pub fn commit_patch(&self, patch_dir: &Path) -> Result<PathBuf> {
        // Extract package name and version from the patch dir name
        let dir_name = patch_dir
            .file_name()
            .and_then(|n| n.to_str())
            .ok_or_else(|| DnxError::Io("Invalid patch directory name".to_string()))?;

        // Parse "name@version" from dir name
        let (package_name, version) = parse_pkg_key(dir_name)?;

        let pkg_key = format!("{}@{}", package_name, version);
        let node_modules = self.project_root.join("node_modules");
        let dnx_dir = node_modules.join(".dnx");
        let original_dir = dnx_dir
            .join(&pkg_key)
            .join("node_modules")
            .join(&package_name);

        if !original_dir.exists() {
            return Err(DnxError::Linker(format!(
                "Original package {} not found",
                pkg_key
            )));
        }

        // Generate unified diff
        let diff = generate_diff(&original_dir, patch_dir, &package_name)?;

        if diff.is_empty() {
            return Err(DnxError::Linker(
                "No changes detected. Make changes to the package before committing.".to_string(),
            ));
        }

        // Write patch file
        let patches_dir = self.project_root.join("patches");
        std::fs::create_dir_all(&patches_dir)
            .map_err(|e| DnxError::Io(format!("Failed to create patches directory: {}", e)))?;

        let patch_filename = format!("{}@{}.patch", package_name.replace('/', "+"), version);
        let patch_path = patches_dir.join(&patch_filename);
        std::fs::write(&patch_path, &diff)
            .map_err(|e| DnxError::Io(format!("Failed to write patch file: {}", e)))?;

        // Clean up the temporary patch working directory
        let _ = std::fs::remove_dir_all(patch_dir);

        Ok(patch_path)
    }

    /// Apply all configured patches to installed packages.
    /// Called after linking during install.
    pub fn apply_patches(&self) -> Result<PatchStats> {
        let mut stats = PatchStats::default();

        for (pkg_key, patch_file) in &self.patches {
            let patch_path = self.project_root.join(patch_file);
            if !patch_path.exists() {
                eprintln!(
                    "\x1b[33m⚠  Patch file not found: {}\x1b[0m",
                    patch_path.display()
                );
                stats.failed += 1;
                continue;
            }

            let (package_name, _version) = match parse_pkg_key(pkg_key) {
                Ok(v) => v,
                Err(_) => {
                    stats.failed += 1;
                    continue;
                }
            };

            let node_modules = self.project_root.join("node_modules");
            let dnx_dir = node_modules.join(".dnx");
            let pkg_dir = dnx_dir
                .join(pkg_key)
                .join("node_modules")
                .join(&package_name);

            if !pkg_dir.exists() {
                stats.failed += 1;
                continue;
            }

            match apply_patch_file(&patch_path, &pkg_dir) {
                Ok(()) => stats.applied += 1,
                Err(e) => {
                    eprintln!(
                        "\x1b[33m⚠  Failed to apply patch for {}: {}\x1b[0m",
                        pkg_key, e
                    );
                    stats.failed += 1;
                }
            }
        }

        Ok(stats)
    }
}

#[derive(Debug, Default)]
pub struct PatchStats {
    pub applied: usize,
    pub failed: usize,
}

/// Parse a "name@version" key into (name, version).
/// Handles scoped packages: "@scope/pkg@1.0.0"
fn parse_pkg_key(key: &str) -> Result<(String, String)> {
    if let Some(stripped) = key.strip_prefix('@') {
        // Scoped: find the second '@'
        if let Some(idx) = stripped.find('@') {
            return Ok((key[..idx + 1].to_string(), stripped[idx + 1..].to_string()));
        }
    } else if let Some(idx) = key.find('@') {
        return Ok((key[..idx].to_string(), key[idx + 1..].to_string()));
    }
    Err(DnxError::Linker(format!("Invalid package key: {}", key)))
}

/// Generate a unified diff between original and modified directories.
fn generate_diff(original: &Path, modified: &Path, _pkg_name: &str) -> Result<String> {
    let mut diff = String::new();

    // Walk modified directory for changed/added files
    for entry in walkdir::WalkDir::new(modified)
        .into_iter()
        .filter_map(|e| e.ok())
    {
        if !entry.file_type().is_file() {
            continue;
        }

        let relative = entry
            .path()
            .strip_prefix(modified)
            .map_err(|e| DnxError::Io(format!("Failed to get relative path: {}", e)))?;

        let original_file = original.join(relative);
        let modified_file = entry.path();

        let original_content = if original_file.exists() {
            std::fs::read_to_string(&original_file).unwrap_or_default()
        } else {
            String::new()
        };

        let modified_content = std::fs::read_to_string(modified_file).unwrap_or_default();

        if original_content != modified_content {
            let relative_str = relative.to_string_lossy().replace('\\', "/");
            diff.push_str(&format!("--- a/{}\n", relative_str));
            diff.push_str(&format!("+++ b/{}\n", relative_str));

            // Simple line-based diff
            let orig_lines: Vec<&str> = original_content.lines().collect();
            let mod_lines: Vec<&str> = modified_content.lines().collect();

            diff.push_str(&format!(
                "@@ -1,{} +1,{} @@\n",
                orig_lines.len(),
                mod_lines.len()
            ));

            for line in &orig_lines {
                diff.push_str(&format!("-{}\n", line));
            }
            for line in &mod_lines {
                diff.push_str(&format!("+{}\n", line));
            }
        }
    }

    // Check for deleted files
    for entry in walkdir::WalkDir::new(original)
        .into_iter()
        .filter_map(|e| e.ok())
    {
        if !entry.file_type().is_file() {
            continue;
        }
        let relative = entry
            .path()
            .strip_prefix(original)
            .map_err(|e| DnxError::Io(format!("Failed to get relative path: {}", e)))?;
        let modified_file = modified.join(relative);
        if !modified_file.exists() {
            let relative_str = relative.to_string_lossy().replace('\\', "/");
            diff.push_str(&format!("--- a/{}\n", relative_str));
            diff.push_str("+++ /dev/null\n");
            let content = std::fs::read_to_string(entry.path()).unwrap_or_default();
            let lines: Vec<&str> = content.lines().collect();
            diff.push_str(&format!("@@ -1,{} +0,0 @@\n", lines.len()));
            for line in &lines {
                diff.push_str(&format!("-{}\n", line));
            }
        }
    }

    Ok(diff)
}

/// Apply a patch file to a package directory.
/// Uses a simple line-based patch application.
fn apply_patch_file(patch_path: &Path, pkg_dir: &Path) -> Result<()> {
    let patch_content = std::fs::read_to_string(patch_path)
        .map_err(|e| DnxError::Io(format!("Failed to read patch file: {}", e)))?;

    let mut current_file: Option<PathBuf> = None;
    let mut new_content = String::new();
    let mut in_hunk = false;

    for line in patch_content.lines() {
        if let Some(relative) = line.strip_prefix("+++ b/") {
            // Flush previous file
            if let Some(ref file_path) = current_file {
                if let Some(parent) = file_path.parent() {
                    std::fs::create_dir_all(parent)
                        .map_err(|e| DnxError::Io(format!("Failed to create directory: {}", e)))?;
                }
                std::fs::write(file_path, &new_content)
                    .map_err(|e| DnxError::Io(format!("Failed to write patched file: {}", e)))?;
            }

            if relative == "/dev/null" {
                current_file = None;
            } else {
                current_file = Some(pkg_dir.join(relative));
            }
            new_content.clear();
            in_hunk = false;
        } else if line.starts_with("--- a/") {
            // Skip the old file header
        } else if line.starts_with("@@") {
            in_hunk = true;
        } else if in_hunk {
            if let Some(stripped) = line.strip_prefix('+') {
                new_content.push_str(stripped);
                new_content.push('\n');
            } else if line.starts_with('-') {
                // Skip removed lines
            } else if let Some(stripped) = line.strip_prefix(' ') {
                new_content.push_str(stripped);
                new_content.push('\n');
            }
        }
    }

    // Flush last file
    if let Some(ref file_path) = current_file {
        if let Some(parent) = file_path.parent() {
            std::fs::create_dir_all(parent)
                .map_err(|e| DnxError::Io(format!("Failed to create directory: {}", e)))?;
        }
        std::fs::write(file_path, &new_content)
            .map_err(|e| DnxError::Io(format!("Failed to write patched file: {}", e)))?;
    }

    // Handle deleted files
    let patch_content2 = std::fs::read_to_string(patch_path).unwrap_or_default();
    let mut delete_next = false;
    for line in patch_content2.lines() {
        if line.starts_with("+++ /dev/null") {
            delete_next = true;
        } else if delete_next && line.starts_with("--- a/") {
            let relative = &line[6..];
            let file_path = pkg_dir.join(relative);
            let _ = std::fs::remove_file(&file_path);
            delete_next = false;
        } else {
            delete_next = false;
        }
    }

    Ok(())
}

/// Copy a directory recursively.
fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<()> {
    std::fs::create_dir_all(dst).map_err(|e| {
        DnxError::Io(format!(
            "Failed to create directory {}: {}",
            dst.display(),
            e
        ))
    })?;

    for entry in std::fs::read_dir(src)
        .map_err(|e| DnxError::Io(format!("Failed to read directory {}: {}", src.display(), e)))?
    {
        let entry = entry.map_err(|e| DnxError::Io(format!("Failed to read entry: {}", e)))?;
        let src_path = entry.path();
        let dst_path = dst.join(entry.file_name());

        if entry
            .file_type()
            .map_err(|e| DnxError::Io(format!("Failed to get file type: {}", e)))?
            .is_dir()
        {
            copy_dir_recursive(&src_path, &dst_path)?;
        } else {
            std::fs::copy(&src_path, &dst_path).map_err(|e| {
                DnxError::Io(format!(
                    "Failed to copy {} to {}: {}",
                    src_path.display(),
                    dst_path.display(),
                    e
                ))
            })?;
        }
    }

    Ok(())
}