git-skel 0.1.1

a git subcommand to apply skeleton repository continuously
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use failure::Error;
use git2::Repository;
use ignore::gitignore::Gitignore;
use std::fs;
use std::io::Read;
use std::path::{Path, PathBuf};

pub fn copy(
    src: &Repository,
    tgt: &Repository,
    src_ignore: &Gitignore,
    tgt_ignore: &Gitignore,
    path: &Path,
    dry_run: bool,
) -> Result<bool, Error> {
    let src_root = PathBuf::from(src.workdir().unwrap());
    let tgt_root = PathBuf::from(tgt.workdir().unwrap());
    let src_path = src_root.join(&path);
    let tgt_path = tgt_root.join(&path);

    let src_ignored = is_ignore(src_ignore, path);
    let tgt_ignored = is_ignore(tgt_ignore, path);
    let ignored = src_ignored || tgt_ignored;

    let mut warn = false;
    if is_diff(&src_path, &tgt_path)? {
        if dry_run {
            let status = tgt.status_file(&path);
            let indicator = if ignored {
                " ignore"
            } else if let Ok(status) = status {
                if status.is_empty() {
                    " copy  "
                } else {
                    warn = true;
                    "!copy  "
                }
            } else {
                if tgt_path.exists() {
                    warn = true;
                    "!copy  "
                } else {
                    " copy  "
                }
            };
            println!("  {}: {}", indicator, path.to_string_lossy());
        } else {
            if !ignored {
                if let Some(parent) = tgt_path.parent() {
                    if !parent.exists() {
                        fs::create_dir_all(&parent)?;
                    }
                }
                if fs::symlink_metadata(&src_path)?.file_type().is_symlink() {
                    let link_path = fs::read_link(&src_path)?;
                    symlink(&link_path, &tgt_path)?;
                } else {
                    fs::copy(&src_path, &tgt_path)?;
                }
            }
        }
    }

    Ok(warn)
}

#[cfg(target_os = "windows")]
fn symlink(src: &Path, dst: &Path) -> Result<(), Error> {
    if src.is_file() {
        Ok(std::os::windows::fs::symlink_file(&src, &dst)?)
    } else {
        Ok(std::os::windows::fs::symlink_dir(&src, &dst)?)
    }
}

#[cfg(not(target_os = "windows"))]
fn symlink(src: &Path, dst: &Path) -> Result<(), Error> {
    Ok(std::os::unix::fs::symlink(&src, &dst)?)
}

fn is_diff(src_path: &Path, tgt_path: &Path) -> Result<bool, Error> {
    if let Ok(mut src) = fs::File::open(src_path) {
        if let Ok(mut tgt) = fs::File::open(tgt_path) {
            let mut src_buf = Vec::new();
            let mut tgt_buf = Vec::new();

            src.read_to_end(&mut src_buf)?;
            tgt.read_to_end(&mut tgt_buf)?;

            Ok(src_buf != tgt_buf)
        } else {
            Ok(true)
        }
    } else {
        Ok(true)
    }
}

fn is_ignore(ignore: &Gitignore, path: &Path) -> bool {
    ignore.matched(path, false).is_ignore()
}

pub fn delete(
    tgt: &Repository,
    tgt_ignore: &Gitignore,
    path: &Path,
    dry_run: bool,
) -> Result<bool, Error> {
    let tgt_root = PathBuf::from(tgt.workdir().unwrap());
    let tgt_path = tgt_root.join(&path);
    let ignored = is_ignore(tgt_ignore, path);

    let mut warn = false;
    if dry_run {
        let status = tgt.status_file(&path);
        let indicator = if ignored {
            " ignore"
        } else if let Ok(status) = status {
            if status.is_empty() {
                " delete"
            } else {
                warn = true;
                "!delete"
            }
        } else {
            if tgt_path.exists() {
                warn = true;
                "!delete"
            } else {
                "missing"
            }
        };
        println!("  {}: {}", indicator, path.to_string_lossy());
    } else {
        if !ignored && tgt_path.exists() {
            remove_recursive(&tgt_path)?;
        }
    }

    Ok(warn)
}

fn remove_recursive(path: &Path) -> Result<(), Error> {
    if path.is_dir() {
        fs::remove_dir(path)?;
    } else {
        fs::remove_file(path)?;
    }
    if let Some(parent) = path.parent() {
        if fs::read_dir(parent)?.count() == 0 {
            remove_recursive(parent)?;
        }
    }

    Ok(())
}