renamore 0.3.2

More ways to rename 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

use std::path::{Component, Path, PathBuf};
use std::io::{ErrorKind, Result};

struct CurrentDirectory {
    previous: PathBuf,
}

impl CurrentDirectory {
    fn set<T: AsRef<Path>>(to: T) -> Result<Self> {
        let previous = std::env::current_dir()?;
        std::env::set_current_dir(to)?;
        Ok(Self { previous })
    }
}

impl Drop for CurrentDirectory {
    fn drop(&mut self) {
        std::env::set_current_dir(&self.previous).unwrap();
    }
}

fn is_exists_error<T>(result: Result<T>) -> bool {
    if let Err(e) = result {
        e.kind() == ErrorKind::AlreadyExists
    } else {
        false
    }
}

fn parent_join(path: &Path) -> PathBuf {
    let mut parent = PathBuf::new();
    parent.push(Component::ParentDir);
    parent.push(path);
    parent
}

#[test]
fn rename_exclusive_abs() -> Result<()> {
    let dir = tempfile::tempdir()?;

    let path_a = dir.path().join("a");
    let path_b = dir.path().join("b");
    let path_c = dir.path().join("c");

    std::fs::write(&path_a, "a")?;
    std::fs::create_dir(&path_b)?;

    // Rename a file to a non-existent path.
    super::rename_exclusive(&path_a, &path_c)?;
    assert!(!path_a.try_exists()?);
    assert!(path_c.try_exists()?);
    assert_eq!(std::fs::read_to_string(&path_c)?, "a");

    // Rename a directory to a non-existent path.
    super::rename_exclusive(&path_b, &path_a)?;
    assert!(!path_b.try_exists()?);
    assert!(path_a.try_exists()?);
    assert!(std::fs::metadata(&path_a)?.is_dir());

    // Rename a file to an existing directory.
    assert!(is_exists_error(super::rename_exclusive(&path_c, &path_a)));
    assert!(path_c.try_exists()?);

    // Rename a directory to an existing file.
    assert!(is_exists_error(super::rename_exclusive(&path_a, &path_c)));
    assert!(path_a.try_exists()?);

    Ok(())
}

#[test]
fn rename_exclusive_rel() -> Result<()> {
    let dir = tempfile::tempdir()?;
    let _curr = CurrentDirectory::set(dir.path())?;

    let path_a = PathBuf::from("a");
    let path_b = PathBuf::from("b");
    let path_c = PathBuf::from("c");

    std::fs::write(&path_a, "a")?;
    std::fs::write(&path_b, "b")?;
    std::fs::create_dir(&path_c)?;

    // Rename a file to a non-existent path inside a directory.
    let path_c_b = path_c.join(&path_b);
    super::rename_exclusive(&path_a, &path_c_b)?;
    assert!(!path_a.try_exists()?);
    assert!(path_c_b.try_exists()?);
    assert_eq!(std::fs::read_to_string(&path_c_b)?, "a");

    // Rename a directory to a non-existent path.
    super::rename_exclusive(&path_c, &path_a)?;
    assert!(!path_c.try_exists()?);
    assert!(path_a.try_exists()?);
    assert!(std::fs::metadata(&path_a)?.is_dir());

    let _curr = CurrentDirectory::set(&path_a)?;

    let path_up_b = parent_join(&path_b);

    // Rename a file to an existing file in the parent directory.
    assert!(is_exists_error(super::rename_exclusive(&path_b, &path_up_b)));
    assert!(path_b.try_exists()?);

    // Rename a file in a parent directory to a non-existent path.
    super::rename_exclusive(&path_up_b, &path_a)?;
    assert!(!path_up_b.try_exists()?);
    assert!(path_a.try_exists()?);
    assert_eq!(std::fs::read_to_string(&path_a)?, "b");

    // Rename a file to a non-existent path in the parent directory.
    super::rename_exclusive(&path_b, &path_up_b)?;
    assert!(!path_b.try_exists()?);
    assert!(path_up_b.try_exists()?);
    assert_eq!(std::fs::read_to_string(&path_up_b)?, "a");

    Ok(())
}

#[test]
fn rename_exclusive_is_atomic() -> Result<()> {
    if super::rename_exclusive_is_atomic(std::env::current_dir()?)? {
        println!("rename_exclusive is supported");
    } else {
        println!("rename_exclusive is not supported");
    }

    Ok(())
}