···

       
19
       
 
       


     

       
20
       
 
       
impl Action {

     

       
21
       
 
       
    pub async fn run(self, source: PathBuf, execute: bool) {

     

       
22
       
-
       
        if execute { self.execute(source).await } else { self.dry_run(source).await }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
23
       
 
       
    }

     

       
24
       
 
       


     

       
25
       
 
       
    pub async fn dry_run(self, source: PathBuf) {

     

···

       
19
       
 
       


     

       
20
       
 
       
impl Action {

     

       
21
       
 
       
    pub async fn run(self, source: PathBuf, execute: bool) {

     

       
22
       
+
       
        if execute {

     

       
23
       
+
       
            self.execute(source).await

     

       
24
       
+
       
        } else {

     

       
25
       
+
       
            self.dry_run(source).await

     

       
26
       
+
       
        }

     

       
27
       
 
       
    }

     

       
28
       
 
       


     

       
29
       
 
       
    pub async fn dry_run(self, source: PathBuf) {

     

···

       
7
       
 
       


     

       
8
       
 
       
use serde::Deserialize;

     

       
9
       
 
       


     

       
10
       
-
       
use crate::filters::Filter;

     

       
11
       
 
       
use crate::actions::Action;

     

       
0
       
 
       

     

       
12
       
 
       


     

       
13
       
 
       
/// Definition of the job files

     

       
14
       
 
       
#[derive(Debug, Deserialize)]

     
···

       
20
       
 
       


     

       
21
       
 
       
impl Job {

     

       
22
       
 
       
    /// Returns stream of actions that should be executed

     

       
23
       
-
       
    pub async fn actions(&self) -> Result<impl tokio_stream::Stream<Item = (Action, PathBuf)> + '_> {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
24
       
 
       
        let loc = normalise_path(&self.location);

     

       
25
       
 
       


     

       
26
       
 
       
        let dir = ReadDirStream::new(fs::read_dir(&loc).await?);

     

···

       
7
       
 
       


     

       
8
       
 
       
use serde::Deserialize;

     

       
9
       
 
       


     

       
0
       
 
       

     

       
10
       
 
       
use crate::actions::Action;

     

       
11
       
+
       
use crate::filters::Filter;

     

       
12
       
 
       


     

       
13
       
 
       
/// Definition of the job files

     

       
14
       
 
       
#[derive(Debug, Deserialize)]

     
···

       
20
       
 
       


     

       
21
       
 
       
impl Job {

     

       
22
       
 
       
    /// Returns stream of actions that should be executed

     

       
23
       
+
       
    pub async fn actions(

     

       
24
       
+
       
        &self,

     

       
25
       
+
       
    ) -> Result<impl tokio_stream::Stream<Item = (Action, PathBuf)> + '_> {

     

       
26
       
 
       
        let loc = normalise_path(&self.location);

     

       
27
       
 
       


     

       
28
       
 
       
        let dir = ReadDirStream::new(fs::read_dir(&loc).await?);

     

···

       
0
       
 
       

     

       
1
       
 
       
use color_eyre::eyre::Result;

     

       
2
       
 
       
use futures::prelude::*;

     

       
3
       
-
       
use clap::Parser;

     

       
4
       
 
       


     

       
5
       
 
       
use std::io::Read;

     

       
6
       
 
       


     

       
0
       
 
       

     

       
7
       
 
       
mod filters;

     

       
8
       
 
       
mod job;

     

       
9
       
 
       
mod pattern;

     

       
10
       
-
       
mod actions;

     

       
11
       
 
       


     

       
12
       
 
       
#[derive(Debug, Parser)]

     

       
13
       
 
       
struct Args {

     

···

       
1
       
+
       
use clap::Parser;

     

       
2
       
 
       
use color_eyre::eyre::Result;

     

       
3
       
 
       
use futures::prelude::*;

     

       
0
       
 
       

     

       
4
       
 
       


     

       
5
       
 
       
use std::io::Read;

     

       
6
       
 
       


     

       
7
       
+
       
mod actions;

     

       
8
       
 
       
mod filters;

     

       
9
       
 
       
mod job;

     

       
10
       
 
       
mod pattern;

     

       
0
       
 
       

     

       
11
       
 
       


     

       
12
       
 
       
#[derive(Debug, Parser)]

     

       
13
       
 
       
struct Args {