klone 1.0.2

A backup application based in the same FS that will only back the file that you changed
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

#[cfg(unix)]
use crate::sys::unix::*;
#[cfg(unix)]
type OsType = UnixFileTime;
#[cfg(windows)]
use crate::sys::windows::*;
#[cfg(windows)]
type OsType = WindowsFileTime;
use crate::config::exclusions::is_excluded;
use crate::error;
use crate::output::cli;
use crate::sys::*;
use std::fs::create_dir_all;
use std::sync::mpsc::{self, Receiver, Sender};
use std::{fs::DirEntry, path::PathBuf};
pub fn backup_preparations(
    origin_dir: PathBuf,
    target_dir: PathBuf,
) -> Result<(), crate::error::Error> {
    let (tx, rx): (Sender<String>, Receiver<String>) = mpsc::channel();
    let _wrap = super::wrapper::Wrapper;
    cli(rx)?;
    start_backup(origin_dir, target_dir, tx)
}
fn start_backup(
    origin_dir: PathBuf,
    target_dir: PathBuf,
    tx: Sender<String>,
) -> Result<(), crate::error::Error> {
    if !origin_dir.is_dir() {
        return Ok(());
    }
    for sub_dir in origin_dir.read_dir().unwrap() {
        backup_operations(
            sub_dir.map_err(|_| error::Error {
                kind: error::ErrorKind::IOError,
            })?,
            target_dir.clone(),
            tx.clone(),
        )
        .unwrap();
    }
    Ok(())
}
fn backup_operations(
    dir: DirEntry,
    target_dir: PathBuf,
    tx: Sender<String>,
) -> Result<(), crate::error::Error> {
    let path_to_target_file = target_dir.clone();
    // Add the path to the target directory
    let target_file = path_to_target_file.join(dir.file_name());
    // We check if the directory should be backed and if its a directory
    if is_excluded(dir.path().display().to_string().as_str())? {
        return Ok(());
    }
    if dir.path().is_symlink() {
        return Ok(());
    }
    match (
        should_be_backed(
            <&PathBuf as TryInto<OsType>>::try_into(&dir.path())
                .expect("Shouldn't panic as, file exists. If so, is an external error"),
            <&PathBuf as TryInto<OsType>>::try_into(&target_file)
                .expect("Shouldn't panic as, file exists. If so, is an external error"),
        ),
        dir.path().is_dir() || target_file.is_dir(),
    ) {
        // If shouldn't be backed we finish and return
        (false, _) => {
            println!("doesnt");
            Ok(())}
        ,
        // Should be backed and is a file. We copy the file and return
        (true, false) => {
            println!("Should be here");
            println!("{:?}, \n{}", dir.path().display(), dir.path().is_dir());
            println!("{:?}\n {}", &target_file, target_file.is_dir());
            // Copy contents
            tx.send(dir.path().display().to_string())
                .map_err(|_| error::Error {
                    kind: error::ErrorKind::IOError,
                })?;
            fs_extra::file::copy(
                dir.path(),
                target_file,
                &fs_extra::file::CopyOptions {
                    overwrite: true,
                    ..Default::default()
                },
            )
            .unwrap();
            //           .map_err(|_| error::Error {
            //               kind: error::ErrorKind::FSError,
            //           })?;
            Ok(())
        }
        // If should be backed and is a directory we check inside the directory for files to be
        // backed
        (true, true) => {
            //Check inside directory
            tx.send(dir.path().display().to_string())
                .map_err(|_| error::Error {
                    kind: error::ErrorKind::IOError,
                })?;
            let _ = create_dir_all(&path_to_target_file);
            self::start_backup(dir.path(), target_file, tx)?;
            Ok(())
        }
    }
}