diffy 0.5.0

Tools for finding and manipulating differences between files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! A minimal patch-apply tool using diffy's multi-file patch support.
//!
//! Usage:
//!
//! ```console
//! apply <patch-file> [target-dir]
//! ```
//!
//! Applies a git-format patch file to a target directory
//! (defaults to the current directory).
//!
//! Assumes the default `a/` and `b/` path prefixes
//! from `git diff` and GNU `diff -u`.

use std::fs;
use std::path::Path;
use std::process::ExitCode;

use diffy::apply_bytes;
use diffy::binary::BinaryPatch;
use diffy::patch_set::FileOperation;
use diffy::patch_set::ParseOptions;
use diffy::patch_set::PatchKind;
use diffy::patch_set::PatchSet;

fn main() -> ExitCode {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 2 || args.len() > 3 {
        eprintln!("usage: {} <patch-file> [target-dir]", args[0]);
        return ExitCode::FAILURE;
    }
    let patch_file = Path::new(&args[1]);
    let target_dir = args.get(2).map_or_else(|| Path::new("."), |p| Path::new(p));

    if let Err(e) = apply_patch_file(patch_file, target_dir) {
        eprintln!("error: {e}");
        return ExitCode::FAILURE;
    }
    ExitCode::SUCCESS
}

fn apply_patch_file(patch_file: &Path, dst: &Path) -> Result<(), Box<dyn std::error::Error>> {
    let content = fs::read(patch_file)?;

    let patches = PatchSet::parse_bytes(&content, ParseOptions::gitdiff());

    for file_patch in patches {
        let file_patch = file_patch?;
        let operation = {
            let op = file_patch.operation();
            // Rename/Copy paths come from git headers without a/b prefix.
            let strip = match op {
                FileOperation::Rename { .. } | FileOperation::Copy { .. } => 0,
                _ => 1,
            };
            op.strip_prefix(strip)
        };

        match operation {
            FileOperation::Create(path) => {
                let target = dst.join(path_from_bytes(&path)?);
                let patched = match file_patch.patch() {
                    PatchKind::Text(patch) => apply_bytes(&[], patch)?,
                    PatchKind::Binary(BinaryPatch::Marker) => continue,
                    PatchKind::Binary(patch) => patch.apply(&[])?,
                };
                create_parent_dirs(&target)?;
                fs::write(&target, patched)?;
                eprintln!("create {}", target.display());
            }
            FileOperation::Delete(path) => {
                let target = dst.join(path_from_bytes(&path)?);
                fs::remove_file(&target)?;
                eprintln!("delete {}", target.display());
            }
            FileOperation::Modify { original, modified } => {
                let src_path = dst.join(path_from_bytes(&original)?);
                let dst_path = dst.join(path_from_bytes(&modified)?);
                let patched = match file_patch.patch() {
                    PatchKind::Text(patch) => {
                        let base = fs::read(&src_path)?;
                        apply_bytes(&base, patch)?
                    }
                    PatchKind::Binary(BinaryPatch::Marker) => continue,
                    PatchKind::Binary(patch) => {
                        let base = fs::read(&src_path)?;
                        patch.apply(&base)?
                    }
                };
                create_parent_dirs(&dst_path)?;
                fs::write(&dst_path, patched)?;
                if src_path != dst_path {
                    fs::remove_file(&src_path)?;
                    eprintln!("rename {} -> {}", src_path.display(), dst_path.display());
                } else {
                    eprintln!("modify {}", dst_path.display());
                }
            }
            FileOperation::Rename { from, to } => {
                let src_path = dst.join(path_from_bytes(&from)?);
                let dst_path = dst.join(path_from_bytes(&to)?);
                create_parent_dirs(&dst_path)?;
                fs::rename(&src_path, &dst_path)?;
                eprintln!("rename {} -> {}", src_path.display(), dst_path.display());
            }
            FileOperation::Copy { from, to } => {
                let src_path = dst.join(path_from_bytes(&from)?);
                let dst_path = dst.join(path_from_bytes(&to)?);
                create_parent_dirs(&dst_path)?;
                fs::copy(&src_path, &dst_path)?;
                eprintln!("copy {} -> {}", src_path.display(), dst_path.display());
            }
        }
    }

    Ok(())
}

#[cfg(unix)]
fn path_from_bytes(bytes: &[u8]) -> Result<&Path, Box<dyn std::error::Error>> {
    use std::os::unix::ffi::OsStrExt;
    Ok(Path::new(std::ffi::OsStr::from_bytes(bytes)))
}

#[cfg(not(unix))]
fn path_from_bytes(bytes: &[u8]) -> Result<&Path, Box<dyn std::error::Error>> {
    Ok(Path::new(std::str::from_utf8(bytes)?))
}

fn create_parent_dirs(path: &Path) -> std::io::Result<()> {
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent)?;
    }
    Ok(())
}