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 {
    crate::verb::*,
    serde::{
        Deserialize,
        Deserializer,
        Serialize,
        Serializer,
    },
    std::fmt,
};

/// A pattern which can be expanded into an executable
#[derive(Debug, Clone)]
pub struct ExecPattern {
    tokens: Vec<String>,
}

impl ExecPattern {
    pub fn from_string(s: &str) -> Self {
        Self {
            tokens: splitty::split_unquoted_whitespace(s)
                .unwrap_quotes(true)
                .map(String::from)
                .collect(),
        }
    }
    pub fn from_tokens(tokens: Vec<String>) -> Self {
        Self { tokens }
    }
    pub fn tokens(&self) -> &[String] {
        &self.tokens
    }
    pub fn into_tokens(self) -> Vec<String> {
        self.tokens
    }
    pub fn is_empty(&self) -> bool {
        self.tokens.is_empty()
    }
    pub fn has_selection_group(&self) -> bool {
        self.tokens.iter().any(|s| str_has_selection_group(s))
    }
    pub fn has_other_panel_group(&self) -> bool {
        self.tokens.iter().any(|s| str_has_other_panel_group(s))
    }
    pub fn to_internal_pattern(&self) -> Option<String> {
        let first_token = self.tokens.first()?;
        if first_token.starts_with(':') || first_token.starts_with(' ') {
            let mut ip = String::from(&first_token[1..]);
            for token in self.tokens.iter().skip(1) {
                ip.push(' ');
                ip.push_str(token);
            }
            Some(ip)
        } else {
            None
        }
    }

    pub fn visit_arg_defs(
        &self,
        f: &mut dyn FnMut(&VerbArgDef),
    ) {
        for token in &self.tokens {
            for capture in ARG_DEF_GROUP.captures_iter(token) {
                let arg_def = VerbArgDef::from_capture(&capture);
                f(&arg_def);
            }
        }
    }

    /// Tell whether, in case of a multiple selection, the command should be executed once per
    /// selection or once for all selections together (meaning the selections will be merged).
    pub fn coarity(&self) -> CommandCoarity {
        let mut has_repeated = false;
        self.visit_arg_defs(&mut |arg_def| {
            for flag in &arg_def.flags {
                debug!("arg {} has flag {:?}", arg_def.name, flag);
                if flag.is_merging() {
                    has_repeated = true;
                }
            }
        });
        if has_repeated {
            CommandCoarity::Merged
        } else {
            CommandCoarity::PerSelection
        }
    }
}

// This implementation builds a string used for description (eg in help)
impl fmt::Display for ExecPattern {
    fn fmt(
        &self,
        f: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        for (idx, s) in self.tokens.iter().enumerate() {
            if idx > 0 {
                write!(f, " ")?;
            }
            write!(f, "{s}")?;
        }
        Ok(())
    }
}

impl Serialize for ExecPattern {
    fn serialize<S: Serializer>(
        &self,
        serializer: S,
    ) -> Result<S::Ok, S::Error> {
        self.tokens.serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for ExecPattern {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum Raw {
            Single(String),
            Multiple(Vec<String>),
        }

        let tokens = match Raw::deserialize(deserializer)? {
            Raw::Single(s) => splitty::split_unquoted_whitespace(&s)
                .map(String::from)
                .collect(),
            Raw::Multiple(v) => v,
        };

        Ok(ExecPattern { tokens })
    }
}