fren-date 0.2.1

fren - file renamer that understands dates (library)
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

#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]

//! Integration tests for `fren_date::merge_directories`. Ports the Python
//! `test_merge_directories` and `test_unique_file_name` cases.

use fren_date::{merge_directories, unique_file_name};
use std::fs;
use std::path::Path;
use tempfile::TempDir;

fn touch(path: impl AsRef<Path>) {
    let path = path.as_ref();
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent).unwrap();
    }
    fs::write(path, b"").unwrap();
}

#[test]
fn test_unique_file_name_numeric_index() {
    let tmp = TempDir::new().unwrap();
    let path = tmp.path().join("file.txt");

    // Doesn't exist → returned as-is.
    assert_eq!(unique_file_name(&path), path);

    fs::write(&path, b"").unwrap();
    let first = path.with_file_name("file_Copy.txt");
    assert_eq!(unique_file_name(&path), first);

    fs::write(&first, b"").unwrap();
    let second = path.with_file_name("file_Copy1.txt");
    assert_eq!(unique_file_name(&first), second);

    fs::write(&second, b"").unwrap();
    let third = path.with_file_name("file_Copy2.txt");
    assert_eq!(unique_file_name(&second), third);
}

#[test]
fn test_merge_directories_full() {
    // Mirrors Python's `test_merge_directories` from
    // `tests/test_files.py` exactly.
    let tmp = TempDir::new().unwrap();
    let target = tmp.path();

    // Pre-existing target tree.
    touch(target.join("2020").join("12").join("one.txt"));
    touch(target.join("2020").join("root.txt"));

    let other = target.join("other");
    touch(other.join("2020").join("root_Copy.txt"));
    touch(other.join("2020").join("12").join("one.txt"));
    touch(other.join("2020").join("12").join("two.txt"));
    touch(other.join("2021").join("01").join("three.txt"));

    let another = target.join("another");
    touch(another.join("2020").join("12").join("one.txt"));
    touch(another.join("2020").join("12").join("two.txt"));
    touch(another.join("2020").join("root_Copy.txt"));

    merge_directories(target, &[other.as_ref(), another.as_ref()], false).unwrap();

    let mut actual: Vec<String> = walk(target);
    actual.sort();
    actual.retain(|p| !p.starts_with("other") && !p.starts_with("another")); // empty dirs left behind

    let expected = vec![
        "2020/12/one.txt",
        "2020/12/one_Copy.txt",
        "2020/12/one_Copy1.txt",
        "2020/12/two.txt",
        "2020/12/two_Copy.txt",
        "2020/root.txt",
        "2020/root_Copy.txt",
        "2020/root_Copy1.txt",
        "2021/01/three.txt",
    ];
    assert_eq!(actual, expected);
}

fn walk(root: &Path) -> Vec<String> {
    let mut out = Vec::new();
    walk_inner(root, root, &mut out);
    out
}

fn walk_inner(root: &Path, current: &Path, out: &mut Vec<String>) {
    for entry in fs::read_dir(current).unwrap() {
        let entry = entry.unwrap();
        let p = entry.path();
        if p.is_dir() {
            walk_inner(root, &p, out);
        } else {
            out.push(p.strip_prefix(root).unwrap().to_string_lossy().into_owned());
        }
    }
}

#[test]
fn merge_dry_run_makes_no_changes() {
    let tmp = TempDir::new().unwrap();
    let target = tmp.path();
    touch(target.join("a.txt"));
    let source = target.join("src");
    touch(source.join("a.txt"));

    let report = merge_directories(target, &[source.as_ref()], true).unwrap();
    assert_eq!(report.moved.len(), 1);
    // Source file should still exist (dry run).
    assert!(source.join("a.txt").exists());
}

#[test]
fn merge_skips_ds_store() {
    let tmp = TempDir::new().unwrap();
    let target = tmp.path();
    let source = target.join("src");
    touch(source.join(".DS_Store"));
    touch(source.join("real.txt"));

    let report = merge_directories(target, &[source.as_ref()], false).unwrap();
    let moved_names: Vec<_> = report
        .moved
        .iter()
        .map(|m| m.from.file_name().unwrap().to_string_lossy().into_owned())
        .collect();
    assert!(!moved_names.iter().any(|n| n == ".DS_Store"));
    assert!(moved_names.iter().any(|n| n == "real.txt"));
}