diff options
Diffstat (limited to 'makima/src/daemon/storage')
| -rw-r--r-- | makima/src/daemon/storage/mod.rs | 5 | ||||
| -rw-r--r-- | makima/src/daemon/storage/patch.rs | 303 |
2 files changed, 307 insertions, 1 deletions
diff --git a/makima/src/daemon/storage/mod.rs b/makima/src/daemon/storage/mod.rs index cc5441a..e5457f7 100644 --- a/makima/src/daemon/storage/mod.rs +++ b/makima/src/daemon/storage/mod.rs @@ -5,4 +5,7 @@ mod patch; -pub use patch::{create_patch, apply_patch, PatchError}; +pub use patch::{ + apply_patch, create_export_patch, create_patch, get_head_sha, get_parent_sha, ExportPatchResult, + PatchError, +}; diff --git a/makima/src/daemon/storage/patch.rs b/makima/src/daemon/storage/patch.rs index 45624b5..0da4eda 100644 --- a/makima/src/daemon/storage/patch.rs +++ b/makima/src/daemon/storage/patch.rs @@ -141,6 +141,223 @@ pub async fn get_parent_sha(worktree_path: &Path) -> Result<String, PatchError> Ok(String::from_utf8_lossy(&output.stdout).trim().to_string()) } +/// Get the current HEAD commit SHA from a worktree. +pub async fn get_head_sha(worktree_path: &Path) -> Result<String, PatchError> { + let output = Command::new("git") + .current_dir(worktree_path) + .args(["rev-parse", "HEAD"]) + .output() + .await + .map_err(|e| PatchError::GitCommand(format!("Failed to get HEAD SHA: {}", e)))?; + + if !output.status.success() { + let stderr = String::from_utf8_lossy(&output.stderr); + return Err(PatchError::GitCommand(format!( + "git rev-parse HEAD failed: {}", + stderr + ))); + } + + Ok(String::from_utf8_lossy(&output.stdout).trim().to_string()) +} + +/// Result of creating an export patch. +#[derive(Debug, Clone)] +pub struct ExportPatchResult { + /// The uncompressed, human-readable patch content. + pub patch_content: String, + /// Number of files changed in the patch. + pub files_count: usize, + /// Number of lines added. + pub lines_added: usize, + /// Number of lines removed. + pub lines_removed: usize, + /// The base commit SHA that the patch is diffed against. + pub base_commit_sha: String, +} + +/// Create an uncompressed git diff patch for export. +/// +/// This creates a human-readable patch that can be applied manually or +/// shared as a file. Unlike `create_patch`, this version is not compressed +/// and is suitable for display or export. +/// +/// If `base_sha` is provided, the diff is between that commit and HEAD. +/// If `base_sha` is None, it attempts to find the merge-base with the default branch +/// or falls back to diffing uncommitted changes against HEAD. +pub async fn create_export_patch( + worktree_path: &Path, + base_sha: Option<&str>, +) -> Result<ExportPatchResult, PatchError> { + // Determine the base SHA to diff against + let resolved_base_sha = match base_sha { + Some(sha) => sha.to_string(), + None => { + // Try to find the merge-base with the default branch + // First, try to get the upstream tracking branch + let upstream_result = Command::new("git") + .current_dir(worktree_path) + .args(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]) + .output() + .await; + + let base = if let Ok(output) = upstream_result { + if output.status.success() { + let upstream = String::from_utf8_lossy(&output.stdout).trim().to_string(); + // Get merge-base with upstream + let merge_base = Command::new("git") + .current_dir(worktree_path) + .args(["merge-base", "HEAD", &upstream]) + .output() + .await; + + if let Ok(mb_output) = merge_base { + if mb_output.status.success() { + Some(String::from_utf8_lossy(&mb_output.stdout).trim().to_string()) + } else { + None + } + } else { + None + } + } else { + None + } + } else { + None + }; + + // If we couldn't find upstream, try common default branches + let base = if base.is_none() { + let default_branches = ["origin/main", "origin/master", "main", "master"]; + let mut found_base = None; + + for branch in default_branches { + let merge_base = Command::new("git") + .current_dir(worktree_path) + .args(["merge-base", "HEAD", branch]) + .output() + .await; + + if let Ok(output) = merge_base { + if output.status.success() { + found_base = Some(String::from_utf8_lossy(&output.stdout).trim().to_string()); + break; + } + } + } + found_base + } else { + base + }; + + // If still nothing, get the first commit or use HEAD~1 + base.unwrap_or_else(|| { + // This will be used, but if HEAD~1 doesn't exist (only one commit), + // git diff will handle it gracefully + "HEAD~1".to_string() + }) + } + }; + + // Get diff stats using --stat + let stat_output = Command::new("git") + .current_dir(worktree_path) + .args(["diff", "--stat", &resolved_base_sha, "HEAD"]) + .output() + .await + .map_err(|e| PatchError::GitCommand(format!("Failed to run git diff --stat: {}", e)))?; + + // Parse the stat output to get line counts + let (lines_added, lines_removed) = if stat_output.status.success() { + parse_diff_stat(&String::from_utf8_lossy(&stat_output.stdout)) + } else { + (0, 0) + }; + + // Get the actual diff content + let diff_output = Command::new("git") + .current_dir(worktree_path) + .args(["diff", &resolved_base_sha, "HEAD"]) + .output() + .await + .map_err(|e| PatchError::GitCommand(format!("Failed to run git diff: {}", e)))?; + + if !diff_output.status.success() { + let stderr = String::from_utf8_lossy(&diff_output.stderr); + return Err(PatchError::GitCommand(format!("git diff failed: {}", stderr))); + } + + let patch_content = String::from_utf8_lossy(&diff_output.stdout).to_string(); + + // Check for empty patch + if patch_content.trim().is_empty() { + return Err(PatchError::EmptyPatch); + } + + // Count files changed + let files_output = Command::new("git") + .current_dir(worktree_path) + .args(["diff", "--name-only", &resolved_base_sha, "HEAD"]) + .output() + .await + .map_err(|e| PatchError::GitCommand(format!("Failed to count files: {}", e)))?; + + let files_count = if files_output.status.success() { + String::from_utf8_lossy(&files_output.stdout) + .lines() + .filter(|l| !l.is_empty()) + .count() + } else { + 0 + }; + + Ok(ExportPatchResult { + patch_content, + files_count, + lines_added, + lines_removed, + base_commit_sha: resolved_base_sha, + }) +} + +/// Parse git diff --stat output to extract lines added and removed. +/// The last line typically looks like: " 3 files changed, 45 insertions(+), 12 deletions(-)" +fn parse_diff_stat(stat_output: &str) -> (usize, usize) { + let mut lines_added = 0; + let mut lines_removed = 0; + + // Look for the summary line at the end + for line in stat_output.lines().rev() { + let line = line.trim(); + if line.contains("changed") || line.contains("insertion") || line.contains("deletion") { + // Parse insertions + if let Some(idx) = line.find("insertion") { + let before = &line[..idx]; + if let Some(num_str) = before.split_whitespace().last() { + if let Ok(num) = num_str.parse::<usize>() { + lines_added = num; + } + } + } + // Parse deletions + if let Some(idx) = line.find("deletion") { + let before = &line[..idx]; + if let Some(num_str) = before.split(',').last() { + if let Some(num_str) = num_str.trim().split_whitespace().next() { + if let Ok(num) = num_str.parse::<usize>() { + lines_removed = num; + } + } + } + } + break; + } + } + + (lines_added, lines_removed) +} + /// Checkout a specific commit in the worktree. pub async fn checkout_commit(worktree_path: &Path, sha: &str) -> Result<(), PatchError> { let output = Command::new("git") @@ -290,4 +507,90 @@ mod tests { let result = create_patch(path, &head_sha).await; assert!(matches!(result, Err(PatchError::EmptyPatch))); } + + #[tokio::test] + async fn test_create_export_patch() { + let dir = setup_test_repo().await; + let path = dir.path(); + + // Get the initial commit SHA before making changes + let initial_sha = get_head_sha(path).await.unwrap(); + + // Make some changes and commit + fs::write(path.join("file.txt"), "modified content").unwrap(); + fs::write(path.join("new_file.txt"), "new file content").unwrap(); + Command::new("git") + .current_dir(path) + .args(["add", "."]) + .output() + .await + .unwrap(); + Command::new("git") + .current_dir(path) + .args(["commit", "-m", "changes for export"]) + .output() + .await + .unwrap(); + + // Create export patch with explicit base + let result = create_export_patch(path, Some(&initial_sha)).await.unwrap(); + + // Verify the result + assert!(!result.patch_content.is_empty()); + assert_eq!(result.files_count, 2); // file.txt and new_file.txt + assert!(result.lines_added > 0); + assert_eq!(result.base_commit_sha, initial_sha); + + // The patch should contain diff headers + assert!(result.patch_content.contains("diff --git")); + assert!(result.patch_content.contains("new_file.txt")); + } + + #[tokio::test] + async fn test_create_export_patch_no_base() { + let dir = setup_test_repo().await; + let path = dir.path(); + + // Make a second commit so we have something to diff + fs::write(path.join("file.txt"), "modified").unwrap(); + Command::new("git") + .current_dir(path) + .args(["add", "."]) + .output() + .await + .unwrap(); + Command::new("git") + .current_dir(path) + .args(["commit", "-m", "second commit"]) + .output() + .await + .unwrap(); + + // Create export patch without explicit base (will use HEAD~1) + let result = create_export_patch(path, None).await.unwrap(); + + // Verify the result + assert!(!result.patch_content.is_empty()); + assert_eq!(result.files_count, 1); + assert!(result.patch_content.contains("diff --git")); + } + + #[tokio::test] + async fn test_parse_diff_stat() { + // Test the parse_diff_stat function with various formats + let stat1 = " 3 files changed, 45 insertions(+), 12 deletions(-)"; + let (added, removed) = parse_diff_stat(stat1); + assert_eq!(added, 45); + assert_eq!(removed, 12); + + let stat2 = " 1 file changed, 10 insertions(+)"; + let (added, removed) = parse_diff_stat(stat2); + assert_eq!(added, 10); + assert_eq!(removed, 0); + + let stat3 = " 2 files changed, 5 deletions(-)"; + let (added, removed) = parse_diff_stat(stat3); + assert_eq!(added, 0); + assert_eq!(removed, 5); + } } |