commit b1fc51499e900ee54dd8b02ec1e3e1af7aff684d · hauleth.dev/ptsd

+13

examples/images-in-downloads.json

···

       1
       1
       +
       [

     

       2
       2
       +
           {

     

       3
       3
       +
               "filter": {

     

       4
       4
       +
                   "type": "all", "filters": [

     

       5
       5
       +
                       {"type": "content_type", "mime": "image/png"}

     

       6
       6
       +
                   ]

     

       7
       7
       +
               },

     

       8
       8
       +
               "location": "~/Downloads",

     

       9
       9
       +
               "actions": [

     

       10
       10
       +
                   "trash"

     

       11
       11
       +
               ]

     

       12
       12
       +
           }

     

       13
       13
       +
       ]

+14 -18

src/main.rs

···

       2
       2
        
       use futures::prelude::*;

     

       3
       3
        
       use clap::Parser;

     

       4
       4
        
       

     

       5
       5
       +
       use std::io::Read;

     

       6
       6
       +
       

     

       5
       7
        
       mod filters;

     

       6
       8
        
       mod job;

     

       7
       9
        
       mod pattern;

     

       8
       10
        
       mod actions;

     

       9
       11
        
       

     

       10
       10
       -
       const DATA: &str = r#"

     

       11
       11
       -
       [

     

       12
       12
       -
           {

     

       13
       13
       -
               "filter": {

     

       14
       14
       -
                   "type": "all", "filters": [

     

       15
       15
       -
                       {"type": "content_type", "bytes": [137, 80, 78, 71]}

     

       16
       16
       -
                   ]

     

       17
       17
       -
               },

     

       18
       18
       -
               "location": "~/Downloads",

     

       19
       19
       -
               "actions": [

     

       20
       20
       -
                   {"move": "~/test"}

     

       21
       21
       -
               ]

     

       22
       22
       -
           }

     

       23
       23
       -
       ]"#;

     

       24
       24
       -
       

     

       25
       12
        
       #[derive(Debug, Parser)]

     

       26
       13
        
       struct Args {

     

       27
       14
        
           spec: Option<std::path::PathBuf>,

     

       28
       15
        
           /// Run specified commands instead of printing them

     

       29
       29
       -
           #[arg(long, short)]

     

       16
       16
       +
           #[arg(long = "no-dry-run", short = '!')]

     

       30
       17
        
           execute: bool,

     

       31
       18
        
       }

     

       32
       19
        
       

     

       20
       20
       +
       impl Args {

     

       21
       21
       +
           fn data(&self) -> std::io::Result<Box<dyn Read>> {

     

       22
       22
       +
               Ok(match self.spec {

     

       23
       23
       +
                   Some(ref path) => Box::new(std::fs::File::open(path)?),

     

       24
       24
       +
                   None => Box::new(std::io::stdin()),

     

       25
       25
       +
               })

     

       26
       26
       +
           }

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       33
       29
        
       #[tokio::main]

     

       34
       30
        
       async fn main() -> Result<()> {

     

       35
       31
        
           let args = Args::parse();

     

       36
       32
        
       

     

       37
       37
       -
           println!("{args:#?}");

     

       33
       33
       +
           let reader = args.data()?;

     

       38
       34
        
       

     

       39
       39
       -
           let jobs: Vec<job::Job> = serde_json::from_str(DATA).unwrap();

     

       35
       35
       +
           let jobs: Vec<job::Job> = serde_json::from_reader(reader)?;

     

       40
       36
        
       

     

       41
       37
        
           stream::iter(&jobs)

     

       42
       38
        
               .then(|job| job.actions())