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

use futures::StreamExt; // 0.3.1

use crate::result::Result;
use crate::work::Work;
use log::*;
use tokio::fs;

impl<'a> Work<'a> {
    pub fn echo(self, target: impl Into<String>) -> Result<Work<'a>> {
        let target = target.into();

        self.add_work(move |elements| {
            elements
                .filter_map(move |element| {
                    let target = target.clone();
                    async move {
                        println!(
                            "{:?} -> {:?}",
                            element.get_file().path(),
                            element.expand(target).await.unwrap()
                        );

                        Some(element)
                    }
                })
                .boxed()
        })
    }

    pub fn copy(self, target: impl Into<String>) -> Result<Work<'a>> {
        let target = target.into();

        self.add_work(move |elements| {
            elements
                .filter_map(move |element| {
                    let target = target.clone();
                    async move {
                        let from = element.get_file().path();
                        let to = std::path::PathBuf::from(element.expand(target).await.ok()?);

                        info!("COPY: {:?} -> {:?}", &from, &to);
                        if let Some(parent) = to.parent() {
                            if let Err(e) = fs::create_dir_all(parent).await {
                                error!("COPY: Could not create dir {:?}: {:?}", parent, e);
                            };
                        }

                        if let Err(e) = fs::copy(&from, &to).await {
                            error!("COPY: Could not move from {:?} to {:?}: {:?}", from, to, e);
                        };

                        Some(element)
                    }
                })
                .boxed()
        })
    }

    pub fn r#move(self, target: impl Into<String>) -> Result<Work<'a>> {
        let target = target.into();

        self.add_work(move |elements| {
            elements
                .filter_map(move |element| {
                    let target = target.clone();
                    async move {
                        let from = element.get_file().path();
                        let to = std::path::PathBuf::from(element.expand(target).await.ok()?);

                        info!("MOVE: {:?} -> {:?}", from, to);

                        if let Some(parent) = to.parent() {
                            if let Err(e) = fs::create_dir_all(parent).await {
                                error!("MOVE: Could not create dir {:?}: {:?}", parent, e);
                            };
                        }

                        if let Err(e) = fs::rename(&from, &to).await {
                            error!("MOVE: Could not move from {:?} to {:?}: {:?}", from, to, e);
                        };

                        Some(element)
                    }
                })
                .boxed()
        })
    }
}