broot 1.56.2

File browser and launcher
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use {
    super::{
        Selection,
        SelectionType,
    },
    crate::{
        stage::Stage,
        verb::FileTypeCondition,
    },
    std::path::Path,
};

/// Information regarding a potentially multiple set of selected paths
#[derive(Debug, Clone, Copy)]
pub enum SelInfo<'s> {
    None,
    One(Selection<'s>),
    More(&'s Stage), // by contract the stage contains at least 2 paths
}

impl<'a> SelInfo<'a> {
    pub fn to_selections(&self) -> Vec<Selection<'a>> {
        match self {
            SelInfo::None => Vec::new(),
            SelInfo::One(sel) => vec![*sel],
            SelInfo::More(stage) => stage
                .paths()
                .iter()
                .map(|path| Selection {
                    path,
                    line: 0,
                    stype: SelectionType::from(path),
                    is_exe: false, // OK, I don't know
                })
                .collect(),
        }
    }
    #[must_use]
    pub fn from_path(path: &'a Path) -> Self {
        Self::One(Selection {
            stype: SelectionType::from(path),
            line: 0,
            path,
            is_exe: false, // OK, I don't know
        })
    }
    #[must_use]
    pub fn count_paths(&self) -> usize {
        match self {
            SelInfo::None => 0,
            SelInfo::One(_) => 1,
            SelInfo::More(stage) => stage.len(),
        }
    }
    #[must_use]
    pub fn is_accepted_by(
        &self,
        condition: FileTypeCondition,
    ) -> bool {
        match self {
            SelInfo::None => true,
            SelInfo::One(sel) => condition.accepts_path(sel.path),
            SelInfo::More(stage) => {
                for path in stage.paths() {
                    if !condition.accepts_path(path) {
                        return false;
                    }
                }
                true
            }
        }
    }
    #[must_use]
    pub fn common_stype(&self) -> Option<SelectionType> {
        match self {
            SelInfo::None => None,
            SelInfo::One(sel) => Some(sel.stype),
            SelInfo::More(stage) => {
                let stype = SelectionType::from(&stage.paths()[0]);
                for path in stage.paths().iter().skip(1) {
                    if stype != SelectionType::from(path) {
                        return None;
                    }
                }
                Some(stype)
            }
        }
    }
    #[must_use]
    pub fn one_sel(self) -> Option<Selection<'a>> {
        match self {
            SelInfo::One(sel) => Some(sel),
            _ => None,
        }
    }
    #[must_use]
    pub fn first_sel(self) -> Option<Selection<'a>> {
        match self {
            SelInfo::One(sel) => Some(sel),
            SelInfo::More(stage) => stage.paths().first().map(|path| Selection {
                path,
                line: 0,
                stype: SelectionType::from(path),
                is_exe: false,
            }),
            SelInfo::None => None,
        }
    }
    #[must_use]
    pub fn one_path(self) -> Option<&'a Path> {
        self.one_sel().map(|sel| sel.path)
    }
    #[must_use]
    pub fn extension(&self) -> Option<&str> {
        match self {
            SelInfo::None => None,
            SelInfo::One(sel) => sel.path.extension().and_then(|e| e.to_str()),
            SelInfo::More(stage) => {
                let common_extension = stage.paths()[0].extension().and_then(|e| e.to_str());
                #[allow(clippy::question_mark)]
                if common_extension.is_none() {
                    return None;
                }
                for path in stage.paths().iter().skip(1) {
                    let extension = path.extension().and_then(|e| e.to_str());
                    if extension != common_extension {
                        return None;
                    }
                }
                common_extension
            }
        }
    }
}