Struct broot::verb::VerbDescription
source · Expand description
how a verb is described in the help screen
Fields§
§code: bool
§content: String
Implementations§
source§impl VerbDescription
impl VerbDescription
sourcepub fn from_code(content: String) -> Self
pub fn from_code(content: String) -> Self
Examples found in repository?
src/verb/builtin.rs (line 44)
33 34 35 36 37 38 39 40 41 42 43 44 45 46
fn external(
invocation_str: &str,
execution_str: &str,
exec_mode: ExternalExecutionMode,
) -> Verb {
let execution = VerbExecution::External(
ExternalExecution::new(ExecPattern::from_string(execution_str), exec_mode)
);
Verb::new(
Some(invocation_str),
execution,
VerbDescription::from_code(execution_str.to_string()),
).unwrap()
}
More examples
src/conf/verb_conf.rs (line 130)
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 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
pub fn make_verb(&self, previous_verbs: &[Verb]) -> Result<Verb, ConfError> {
let vc = self;
if vc.leave_broot == Some(false) && vc.from_shell == Some(true) {
return Err(ConfError::InvalidVerbConf {
details: "You can't simultaneously have leave_broot=false and from_shell=true".to_string(),
});
}
let invocation = vc.invocation.clone().filter(|i| !i.is_empty());
let internal = vc.internal.as_ref().filter(|i| !i.is_empty());
let external = vc.external.as_ref().filter(|i| !i.is_empty());
let cmd = vc.cmd.as_ref().filter(|i| !i.is_empty());
let cmd_separator = vc.cmd_separator.as_ref().filter(|i| !i.is_empty());
let execution = vc.execution.as_ref().filter(|i| !i.is_empty());
let make_external_execution = |s| {
let working_dir = match (vc.set_working_dir, &vc.working_dir) {
(Some(false), _) => None,
(_, Some(s)) => Some(s.clone()),
(Some(true), None) => Some("{directory}".to_owned()),
(None, None) => None,
};
ExternalExecution::new(
s,
ExternalExecutionMode::from_conf(vc.from_shell, vc.leave_broot),
)
.with_working_dir(working_dir)
};
let execution = match (execution, internal, external, cmd) {
// old definition with "execution": we guess whether it's an internal or
// an external
(Some(ep), None, None, None) => {
if let Some(internal_pattern) = ep.as_internal_pattern() {
if let Some(previous_verb) = previous_verbs.iter().find(|&v| v.has_name(internal_pattern)) {
previous_verb.execution.clone()
} else {
VerbExecution::Internal(InternalExecution::try_from(internal_pattern)?)
}
} else {
VerbExecution::External(make_external_execution(ep.clone()))
}
}
// "internal": the leading `:` or ` ` is optional
(None, Some(s), None, None) => {
VerbExecution::Internal(if s.starts_with(':') || s.starts_with(' ') {
InternalExecution::try_from(&s[1..])?
} else {
InternalExecution::try_from(s)?
})
}
// "external": it can be about any form
(None, None, Some(ep), None) => {
VerbExecution::External(make_external_execution(ep.clone()))
}
// "cmd": it's a sequence
(None, None, None, Some(s)) => VerbExecution::Sequence(SequenceExecution {
sequence: Sequence::new(s, cmd_separator),
}),
_ => {
return Err(ConfError::InvalidVerbConf {
details: "You must define either internal, external or cmd".to_string(),
});
}
};
let description = vc
.description
.clone()
.map(VerbDescription::from_text)
.unwrap_or_else(|| VerbDescription::from_code(execution.to_string()));
let mut verb = Verb::new(
invocation.as_deref(),
execution,
description,
)?;
// we accept both key and keys. We merge both here
let mut unchecked_keys = vc.keys.clone();
if let Some(key) = &vc.key {
unchecked_keys.push(key.clone());
}
let mut checked_keys = Vec::new();
for key in &unchecked_keys {
let key = crokey::parse(key)?;
if keys::is_reserved(key) {
return Err(ConfError::ReservedKey {
key: keys::KEY_FORMAT.to_string(key)
});
}
checked_keys.push(key);
}
for extension in &self.extensions {
verb.file_extensions.push(extension.clone());
}
if !checked_keys.is_empty() {
verb.add_keys(checked_keys);
}
if let Some(shortcut) = &vc.shortcut {
verb.names.push(shortcut.clone());
}
if vc.auto_exec == Some(false) {
verb.auto_exec = false;
}
if !vc.panels.is_empty() {
verb.panels = vc.panels.clone();
}
verb.selection_condition = match vc.apply_to.as_deref() {
Some("file") => SelectionType::File,
Some("directory") => SelectionType::Directory,
Some("any") => SelectionType::Any,
None => SelectionType::Any,
Some(s) => {
return Err(ConfError::InvalidVerbConf {
details: format!("{:?} isn't a valid value of apply_to", s),
});
}
};
Ok(verb)
}
sourcepub fn from_text(content: String) -> Self
pub fn from_text(content: String) -> Self
Examples found in repository?
More examples
Trait Implementations§
source§impl Clone for VerbDescription
impl Clone for VerbDescription
source§fn clone(&self) -> VerbDescription
fn clone(&self) -> VerbDescription
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source
. Read more