git_rune/git/

diff.rs

use super::repo::GitRepo;
use crate::{error::Result, utils::GlobFilters};
use git2::{Diff, DiffOptions};

struct DiffBuilder<'a> {
    repo: &'a GitRepo,
    filter: GlobFilters,
}

struct FilteredDiff<'a> {
    diff: Diff<'a>,
    filter: GlobFilters,
}

impl<'a> DiffBuilder<'a> {
    fn new(repo: &'a GitRepo, exclude_patterns: Option<&str>) -> Result<Self> {
        // Convert exclude patterns to GlobFilters format
        // Default include all files (**/*) and exclude specified patterns
        let filter = GlobFilters::new(None, exclude_patterns)?;

        Ok(Self { repo, filter })
    }

    fn build_options() -> DiffOptions {
        let mut opts = DiffOptions::new();
        opts.include_untracked(true)
            .recurse_untracked_dirs(true)
            .show_untracked_content(true)
            .include_ignored(false)
            .patience(true)
            .minimal(true);
        opts
    }

    fn build(self) -> Result<FilteredDiff<'a>> {
        let index = self.repo.repo.index()?;
        let head_tree = self
            .repo
            .repo
            .head()
            .ok()
            .and_then(|head| head.peel_to_tree().ok());

        let mut opts = Self::build_options();
        let diff =
            self.repo
                .repo
                .diff_tree_to_index(head_tree.as_ref(), Some(&index), Some(&mut opts))?;

        Ok(FilteredDiff {
            diff,
            filter: self.filter,
        })
    }
}

impl<'a> FilteredDiff<'a> {
    fn get_filtered_paths(&self) -> Result<Vec<String>> {
        let mut paths = Vec::new();

        self.diff.foreach(
            &mut |delta, _| {
                if let Some(path) = delta.new_file().path() {
                    if let Some(path_str) = path.to_str() {
                        if self.filter.should_include(path_str) {
                            paths.push(path_str.to_owned());
                        }
                    }
                }
                true
            },
            None,
            None,
            None,
        )?;

        paths.sort();
        Ok(paths)
    }

    fn to_string(&self) -> Result<String> {
        let mut diff_string = String::new();

        // First, get all valid paths
        let valid_paths = self.get_filtered_paths()?;
        let valid_paths: std::collections::HashSet<_> = valid_paths.into_iter().collect();

        self.diff
            .print(git2::DiffFormat::Patch, |delta, _hunk, line| {
                if let Some(path) = delta.new_file().path() {
                    if let Some(path_str) = path.to_str() {
                        // Only include content from files that pass our filter
                        if valid_paths.contains(path_str) {
                            if let Ok(c) = std::str::from_utf8(line.content()) {
                                diff_string.push_str(c);
                            }
                        }
                    }
                }
                true
            })?;

        Ok(diff_string)
    }
}

pub fn get_diff_with_excludes(exclude_patterns: Option<&str>) -> Result<String> {
    let repo = GitRepo::open()?;

    if !repo.has_staged_changes()? {
        println!("No staged changes detected");
        return Ok(String::new());
    }

    let builder = DiffBuilder::new(&repo, exclude_patterns)?;
    let filtered_diff = builder.build()?;
    let diff_string = filtered_diff.to_string()?;

    if diff_string.trim().is_empty() {
        println!("No changes to commit");
        Ok(String::new())
    } else {
        Ok(diff_string)
    }
}

pub fn get_diff() -> Result<String> {
    get_diff_with_excludes(None)
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::TempDir;

    fn setup_test_repo() -> Result<(GitRepo, TempDir)> {
        let temp = TempDir::new()?;
        let path = temp.path();
        let git_repo = git2::Repository::init(path)?;

        // Set up git config
        let mut config = git_repo.config()?;
        config.set_str("user.name", "Test")?;
        config.set_str("user.email", "test@example.com")?;

        // Create test files with distinct content
        let files = [
            ("include.txt", "include file content"),
            ("exclude.js", "javascript content"),
            ("generated/exclude.txt", "generated content"),
        ];

        for (file, content) in &files {
            if let Some(parent) = std::path::Path::new(file).parent() {
                fs::create_dir_all(path.join(parent))?;
            }
            fs::write(path.join(file), content)?;
        }

        // Initial commit
        let mut index = git_repo.index()?;
        index.add_all(["*"].iter(), git2::IndexAddOption::DEFAULT, None)?;
        index.write()?;

        let tree_id = index.write_tree()?;
        let tree = git_repo.find_tree(tree_id)?;
        let sig = git2::Signature::now("Test", "test@example.com")?;
        git_repo.commit(Some("HEAD"), &sig, &sig, "Initial", &tree, &[])?;

        // Modify files with new content
        let modified_files = [
            ("include.txt", "modified include content"),
            ("exclude.js", "modified javascript content"),
            ("generated/exclude.txt", "modified generated content"),
        ];

        for (file, content) in &modified_files {
            fs::write(path.join(file), content)?;
        }

        // Stage changes
        let mut index = git_repo.index()?;
        index.add_all(["*"].iter(), git2::IndexAddOption::DEFAULT, None)?;
        index.write()?;

        Ok((GitRepo::open_from(path)?, temp))
    }

    #[test]
    fn test_filtered_diff() -> Result<()> {
        let (repo, _temp) = setup_test_repo()?;

        // Test with excludes
        let builder = DiffBuilder::new(&repo, Some("*.js,generated/*"))?;
        let filtered_diff = builder.build()?;

        // Test file paths
        let paths = filtered_diff.get_filtered_paths()?;
        assert_eq!(
            paths,
            vec!["include.txt".to_string()],
            "Wrong paths were included"
        );

        // Test diff content
        let diff_content = filtered_diff.to_string()?;
        println!("Filtered diff content:\n{}", diff_content);

        // Check diff headers
        assert!(
            !diff_content.contains("diff --git a/exclude.js"),
            "Found excluded JS file header"
        );
        assert!(
            !diff_content.contains("diff --git a/generated/"),
            "Found excluded generated file header"
        );
        assert!(
            diff_content.contains("diff --git a/include.txt"),
            "Missing included file header"
        );

        // Check file content
        assert!(
            diff_content.contains("include file content"),
            "Missing original content from included file"
        );
        assert!(
            diff_content.contains("modified include content"),
            "Missing modified content from included file"
        );

        // Verify excluded content is not present
        assert!(
            !diff_content.contains("javascript content"),
            "Found content from excluded JS file"
        );
        assert!(
            !diff_content.contains("generated content"),
            "Found content from excluded generated file"
        );

        // Test without excludes
        let builder = DiffBuilder::new(&repo, None)?;
        let filtered_diff = builder.build()?;
        let unfiltered_content = filtered_diff.to_string()?;
        println!("Unfiltered diff content:\n{}", unfiltered_content);

        // Verify all content is present when unfiltered
        assert!(unfiltered_content.contains("diff --git a/exclude.js"));
        assert!(unfiltered_content.contains("javascript content"));
        assert!(unfiltered_content.contains("diff --git a/generated/"));
        assert!(unfiltered_content.contains("generated content"));
        assert!(unfiltered_content.contains("diff --git a/include.txt"));
        assert!(unfiltered_content.contains("include file content"));

        Ok(())
    }
}