clineup 0.2.5

A command-line utility for organizing media 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
136
137

use log::{error, info};
use serde::{Deserialize, Serialize};

#[cfg(target_family = "unix")]
use std::os::unix::fs::symlink;
#[cfg(target_family = "windows")]
use std::os::windows::fs::symlink_file;

use std::path::Path;

#[derive(Debug, Deserialize, Serialize, Clone)]
pub enum OrganizationMode {
    Symlinks,
    Move,
    Copy,
}

pub trait OrganizationStrategy {
    fn organize(&self, _original_file: &Path, _destination: &Path) {}
}

pub struct CopyStrategy {}
impl CopyStrategy {
    pub fn new() -> CopyStrategy {
        CopyStrategy {}
    }
}
impl Default for CopyStrategy {
    fn default() -> Self {
        Self::new()
    }
}
impl OrganizationStrategy for CopyStrategy {
    fn organize(&self, original_file: &Path, destination: &Path) {
        info!(
            "Copying {} to {}",
            original_file.display(),
            destination.display()
        );

        if let Some(parent) = destination.parent() {
            let _ = std::fs::create_dir_all(parent);
        };

        if destination.exists() {
            error!("Destination file already exists. Aborting copy.");
            return;
        }

        let copy_result = std::fs::copy(original_file, destination);

        match copy_result {
            Ok(_) => info!("File copied successfully"),
            Err(e) => error!("Error copying file: {}", e),
        }
    }
}
pub struct SymlinksStrategy {}
impl SymlinksStrategy {
    pub fn new() -> SymlinksStrategy {
        SymlinksStrategy {}
    }
}
impl Default for SymlinksStrategy {
    fn default() -> Self {
        Self::new()
    }
}
#[cfg(target_family = "unix")]
fn make_symlink(original_file: &Path, destination: &Path) {
    let symlink_result = symlink(original_file, destination);
    match symlink_result {
        Ok(_) => info!("File symlinked successfully"),
        Err(e) => error!("Error symlinking file: {}", e),
    }
}
#[cfg(target_family = "windows")]
fn make_symlink(original_file: &Path, destination: &Path) {
    let symlink_result = symlink_file(original_file, destination);
    match symlink_result {
        Ok(_) => info!("File symlinked successfully"),
        Err(e) => error!("Error symlinking file: {}", e),
    }
}
impl OrganizationStrategy for SymlinksStrategy {
    fn organize(&self, original_file: &Path, destination: &Path) {
        info!(
            "Symlinking {} to {}",
            destination.display(),
            original_file.display(),
        );
        if let Some(parent) = destination.parent() {
            let _ = std::fs::create_dir_all(parent);
        };

        if destination.exists() {
            error!("Destination file already exists. Aborting copy.");
            return;
        }

        make_symlink(original_file, destination);
    }
}
pub struct MoveStrategy {}

impl MoveStrategy {
    pub fn new() -> MoveStrategy {
        MoveStrategy {}
    }
}
impl Default for MoveStrategy {
    fn default() -> Self {
        Self::new()
    }
}
impl OrganizationStrategy for MoveStrategy {
    fn organize(&self, original_file: &Path, destination: &Path) {
        info!(
            "Moving {} to {}",
            original_file.display(),
            destination.display(),
        );
        if let Some(parent) = destination.parent() {
            let _ = std::fs::create_dir_all(parent);
        };

        if destination.exists() {
            error!("Destination file already exists. Aborting copy.");
            return;
        }
        let move_result = std::fs::rename(original_file, destination);
        match move_result {
            Ok(_) => info!("File moved successfully"),
            Err(e) => error!("Error moving file: {}", e),
        }
    }
}