commit 8068c0e40d0eb56a8d8713ea356856264b4502d4 · hauleth.dev/ptsd

+5 -1

src/actions.rs

···

       19
       19
        
       

     

       20
       20
        
       impl Action {

     

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

     

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

     

       22
       22
       +
               if execute {

     

       23
       23
       +
                   self.execute(source).await

     

       24
       24
       +
               } else {

     

       25
       25
       +
                   self.dry_run(source).await

     

       26
       26
       +
               }

     

       23
       27
        
           }

     

       24
       28
        
       

     

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

+4 -2

src/job.rs

···

       7
       7
        
       

     

       8
       8
        
       use serde::Deserialize;

     

       9
       9
        
       

     

       10
       10
       -
       use crate::filters::Filter;

     

       11
       10
        
       use crate::actions::Action;

     

       11
       11
       +
       use crate::filters::Filter;

     

       12
       12
        
       

     

       13
       13
        
       /// Definition of the job files

     

       14
       14
        
       #[derive(Debug, Deserialize)]

     
···

       20
       20
        
       

     

       21
       21
        
       impl Job {

     

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

     

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

     

       23
       23
       +
           pub async fn actions(

     

       24
       24
       +
               &self,

     

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

     

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

     

       25
       27
        
       

     

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

+2 -2

src/main.rs

···

       1
       1
       +
       use clap::Parser;

     

       1
       2
        
       use color_eyre::eyre::Result;

     

       2
       3
        
       use futures::prelude::*;

     

       3
       3
       -
       use clap::Parser;

     

       4
       4
        
       

     

       5
       5
        
       use std::io::Read;

     

       6
       6
        
       

     

       7
       7
       +
       mod actions;

     

       7
       8
        
       mod filters;

     

       8
       9
        
       mod job;

     

       9
       10
        
       mod pattern;

     

       10
       10
       -
       mod actions;

     

       11
       11
        
       

     

       12
       12
        
       #[derive(Debug, Parser)]

     

       13
       13
        
       struct Args {