organize-rs 0.4.1

organize - a file management automation tool
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

//! Filters that organize can apply

use std::path::PathBuf;

use abscissa_core::{Command, Runnable};
use clap::Args;
use itertools::Itertools;
use organize_rs_core::{
    actors::{filter_applicator::FilterApplicator, location_walker::LocationWalker},
    filters::{
        FilterApplicationKind, FilterGroup, FilterGroupCollection, FilterGroupOperationKind,
        FilterKind, RecursiveFilterArgs,
    },
    locations::{LocationCollection, LocationKind, MaxDepth, TargetKind},
};

/// `filter` subcommand
#[derive(Command, Debug, Args, Clone)]
pub struct FilterCmd {
    #[clap(subcommand)]
    filter: FilterKind,

    /// Words in file names to be ignored
    #[arg(long, global = true)]
    ignore_name: Option<Vec<String>>,

    /// Words in Paths to be ignored
    #[arg(long, global = true)]
    ignore_path: Option<Vec<String>>,

    /// Mode, how the filters should apply
    #[arg(short, long, global = true, default_value_t = FilterApplicationKind::Any, value_enum)]
    filter_mode: FilterApplicationKind,

    #[command(flatten)]
    location_opts: LocationOpts,
}

#[derive(Debug, Args, Clone)]
#[group(id = "location")]
pub struct LocationOpts {
    /// Locations to operate on
    #[arg(short, long, global = true)]
    locations: Vec<PathBuf>,

    #[command(flatten)]
    recursive: RecursiveFilterArgs,

    /// Targets to operate on
    #[arg(short, long, global = true, default_value_t = TargetKind::Files, value_enum)]
    targets: TargetKind,
}

impl Runnable for FilterCmd {
    fn run(&self) {
        let filter_group0 = FilterGroup::new(
            FilterGroupOperationKind::Include,
            self.filter_mode,
            vec![self.filter.clone()],
        );

        let mut filters = vec![];

        if let Some(ignore_names) = self.ignore_name.clone() {
            if !ignore_names.is_empty() {
                filters.push(FilterKind::IgnoreName {
                    in_name: ignore_names,
                });
            }
        };

        if let Some(ignore_paths) = self.ignore_path.clone() {
            if !ignore_paths.is_empty() {
                filters.push(FilterKind::IgnorePath {
                    in_path: ignore_paths,
                });
            }
        };

        let mut filter_group = vec![filter_group0];

        if !filters.is_empty() {
            filter_group.push(FilterGroup::new(
                FilterGroupOperationKind::Include,
                FilterApplicationKind::None,
                filters,
            ));
        };

        let filter_group_collection = FilterGroupCollection::from_vec(filter_group);

        Self::inner_run(&filter_group_collection);
    }
}

impl FilterCmd {
    fn inner_run(filters: &FilterGroupCollection) {
        // TODO: Support different config file formats
        // ? implement `FilterKind::to_config_string(format: ConfigFileFormat)`
        let yaml_string = serde_yaml::to_string(&filters).unwrap();
        println!("This is a 'filter' snippet for a yaml config:");
        println!("'''");
        println!("{yaml_string}");
        println!("'''");
    }
}