Merge remote-tracking branch 'origin/main'

CHANGELOG.md

@@ -1,6 +1,9 @@
+### next
+- new syntax for special paths - Fix #687, #669
+
 ### v1.32.0 - 2024-01-02
 <a name="v1.32.0"></a>
-- whith "modal" enabled, `initial_mode` setting lets you choose whether to start in `input` mode or `command` mode (default) - Fix #708
+- with "modal" enabled, `initial_mode` setting lets you choose whether to start in `input` mode or `command` mode (default) - Fix #708
 
 ### v1.31.0 - 2023-12-30
 <a name="v1.31.0"></a>

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "broot"
-version = "1.32.0"
+version = "1.32.1-dev"
 authors = ["dystroy <[email protected]>"]
 repository = "https://github.com/Canop/broot"
 homepage = "https://dystroy.org/broot"
@@ -58,7 +58,7 @@ splitty = "1.0"
 strict = "0.1.4"
 syntect = { package = "syntect-no-panic", version = "4.6.1" } # see issue #485
 tempfile = "3.2"
-termimad = "0.26.1"
+termimad = "0.27.0"
 terminal-clipboard = { version = "0.4.1", optional = true }
 terminal-light = "1.1.1"
 toml = "0.8"

resources/default-conf/conf.hjson

@@ -99,12 +99,28 @@ show_selection_mark: true
 # Special paths
 # If some paths must be handled specially, uncomment (and change
 # this section as per the examples)
+# Setting "list":"never" on a dir prevents broot from looking at its 
+#  children when searching, unless the dir is the selected root.
+# Setting "sum":"never" on a dir prevents broot from looking at its
+#  children when computing the total size and count of files.
+# Setting "show":"always" makes a file visible even if its name
+#  starts with a dot.
+# Setting "list":"always" may be useful on a link to a directory
+#  (they're otherwise not entered by broot unless selected)
 #
 special_paths: {
-    "/media" : "no-enter" // comment it if desired
-    # "/media/slow-backup-disk"    : no-enter
-    # "/home/dys/useless"    : hide
-    # "/home/dys/my-link-I-want-to-explore"    : enter
+    "/media" : {
+        list: "never"
+        sum: "never"
+    }
+    "~/.config": { "show": "always" }
+    "trav": {
+        show: always
+        list: "always",
+        sum: "never"
+    }
+    # "~/useless": { "show": "never" }
+    # "~/my-link-I-want-to-explore": { "list": "always" }
 }
 
 ###############################################################

src/app/app_context.rs

@@ -8,8 +8,8 @@ use {
         errors::*,
         file_sum,
         icon::*,
-        path,
         pattern::SearchModeMap,
+        path::SpecialPaths,
         skin::ExtColorMap,
         syntactic::SyntaxTheme,
         tree::TreeOptions,
@@ -50,7 +50,7 @@ pub struct AppContext {
     pub verb_store: VerbStore,
 
     /// the paths for which there's a special behavior to follow (comes from conf)
-    pub special_paths: Vec<path::SpecialPath>,
+    pub special_paths: SpecialPaths,
 
     /// the map between search prefixes and the search mode to apply
     pub search_modes: SearchModeMap,
@@ -130,11 +130,8 @@ impl AppContext {
         };
         let icons = config.icon_theme.as_ref()
             .and_then(|itn| icon_plugin(itn));
-        let mut special_paths = config.special_paths
-            .iter()
-            .map(|(k, v)| path::SpecialPath::new(k.clone(), *v))
-            .collect();
-        path::add_defaults(&mut special_paths);
+        let mut special_paths: SpecialPaths = (&config.special_paths).try_into()?;
+        special_paths.add_defaults();
         let search_modes = config
             .search_modes
             .as_ref()

src/conf/conf.rs

@@ -8,8 +8,6 @@ use {
         display::ColsConf,
         errors::{ConfError, ProgramError},
         path::{
-            Glob,
-            SpecialHandling,
             path_from,
             PathAnchor,
         },
@@ -21,6 +19,7 @@ use {
     crokey::crossterm::style::Attribute,
     fnv::FnvHashMap,
     serde::Deserialize,
+    std::collections::HashMap,
     std::path::PathBuf,
 };
 
@@ -59,7 +58,7 @@ pub struct Conf {
     pub skin: Option<AHashMap<String, SkinEntry>>,
 
     #[serde(default, alias="special-paths")]
-    pub special_paths: AHashMap<Glob, SpecialHandling>,
+    pub special_paths: HashMap<GlobConf, SpecialHandlingConf>,
 
     #[serde(alias="search-modes")]
     pub search_modes: Option<FnvHashMap<String, String>>,

src/conf/mod.rs

@@ -11,6 +11,7 @@ mod default_flags;
 mod format;
 pub mod file_size;
 mod import;
+mod special_handling_conf;
 mod verb_conf;
 
 pub use {
@@ -19,6 +20,7 @@ pub use {
     default_flags::*,
     format::*,
     import::*,
+    special_handling_conf::*,
     verb_conf::VerbConf,
 };
 

src/conf/special_handling_conf.rs

@@ -0,0 +1,101 @@
+use {
+    crate::{
+        errors::ConfError,
+        path::*,
+    },
+    directories::UserDirs,
+    lazy_regex::*,
+    serde::Deserialize,
+    std::collections::HashMap,
+};
+
+
+type SpecialPathsConf = HashMap<GlobConf, SpecialHandlingConf>;
+
+#[derive(Clone, Debug, Deserialize, Hash, PartialEq, Eq)]
+#[serde(transparent)]
+pub struct GlobConf {
+    pub pattern: String,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(untagged)]
+pub enum SpecialHandlingConf {
+    Shortcut(SpecialHandlingShortcut),
+    Detailed(SpecialHandling),
+}
+
+#[derive(Clone, Debug, Copy, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum SpecialHandlingShortcut {
+    None,
+    Enter,
+    #[serde(alias = "no-enter")]
+    NoEnter,
+    Hide,
+    #[serde(alias = "no-hide")]
+    NoHide,
+}
+
+impl From<SpecialHandlingShortcut> for SpecialHandling {
+    fn from(shortcut: SpecialHandlingShortcut) -> Self {
+        use Directive::*;
+        match shortcut {
+            SpecialHandlingShortcut::None => SpecialHandling {
+                show: Default, list: Default, sum: Default,
+            },
+            SpecialHandlingShortcut::Enter => SpecialHandling {
+                show: Always, list: Always, sum: Always,
+            },
+            SpecialHandlingShortcut::NoEnter => SpecialHandling {
+                show: Default, list: Never, sum: Never,
+            },
+            SpecialHandlingShortcut::Hide => SpecialHandling {
+                show: Never, list: Default, sum: Never,
+            },
+            SpecialHandlingShortcut::NoHide => SpecialHandling {
+                show: Always, list: Default, sum: Default,
+            },
+        }
+    }
+}
+
+impl From<SpecialHandlingConf> for SpecialHandling {
+    fn from(conf: SpecialHandlingConf) -> Self {
+        match conf {
+            SpecialHandlingConf::Shortcut(shortcut) => shortcut.into(),
+            SpecialHandlingConf::Detailed(handling) => handling,
+        }
+    }
+}
+
+impl TryFrom<&SpecialPathsConf> for SpecialPaths {
+    type Error = ConfError;
+    fn try_from(map: &SpecialPathsConf) -> Result<Self, ConfError> {
+        let mut entries = Vec::new();
+        for (k, v) in map {
+            entries.push(SpecialPath::new(k.to_glob()?, (*v).into()));
+        }
+        Ok(Self { entries })
+    }
+}
+
+impl GlobConf {
+    pub fn to_glob(&self) -> Result<glob::Pattern, ConfError> {
+        let s = regex_replace!(r"^~(/|$)", &self.pattern, |_, sep| {
+            match UserDirs::new() {
+                Some(dirs) => format!("{}{}", dirs.home_dir().to_string_lossy(), sep),
+                None => "~/".to_string(),
+            }
+        });
+        let glob = if s.starts_with('/') || s.starts_with('~') {
+            glob::Pattern::new(&s)
+        } else {
+            let pattern = format!("**/{}", &s);
+            glob::Pattern::new(&pattern)
+        };
+        glob.map_err(|_| ConfError::InvalidGlobPattern {
+            pattern: self.pattern.to_string(),
+        })
+    }
+}

src/errors.rs

@@ -87,6 +87,7 @@ custom_error! {pub ConfError
     InvalidThreadsCount { count: usize }            = "invalid threads count: {count}",
     InvalidDefaultFlags { flags: String }           = "invalid default flags: {flags:?}",
     InvalidSyntaxTheme { name: String }             = "invalid syntax theme: {name:?}",
+    InvalidGlobPattern { pattern: String }          = "invalid glob pattern: {pattern:?}",
 }
 
 // error which can be raised when parsing a pattern the user typed

src/file_sum/sum_computation.rs

@@ -43,14 +43,6 @@ struct NodeId {
     dev: u64,
 }
 
-#[inline(always)]
-fn is_ignored(path: &Path, special_paths: &[SpecialPath]) -> bool {
-    match special_paths.find(path) {
-        SpecialHandling::NoEnter | SpecialHandling::Hide => true,
-        SpecialHandling::None | SpecialHandling::Enter | SpecialHandling::NoHide => false,
-    }
-}
-
 impl DirSummer {
     pub fn new(thread_count: usize) -> Self {
         let thread_pool = ThreadPoolBuilder::new()
@@ -75,7 +67,7 @@ impl DirSummer {
     ) -> Option<FileSum> {
         let threads_count = self.thread_count;
 
-        if is_ignored(path, &con.special_paths) {
+        if con.special_paths.sum(path) == Directive::Never {
             return Some(FileSum::zero());
         }
 
@@ -102,10 +94,7 @@ impl DirSummer {
         // A None means there's nothing left and the thread may send its result and stop
         let (dirs_sender, dirs_receiver) = channel::unbounded();
 
-        let special_paths: Vec<SpecialPath> = con.special_paths.iter()
-            .filter(|sp| sp.can_have_matches_in(path))
-            .cloned()
-            .collect();
+        let special_paths = con.special_paths.reduce(path);
 
         // the first level is managed a little differently: we look at the cache
         // before adding. This enables faster computations in two cases:
@@ -117,7 +106,7 @@ impl DirSummer {
                     if md.is_dir() {
                         let entry_path = e.path();
 
-                        if is_ignored(&entry_path, &special_paths) {
+                        if con.special_paths.sum(&entry_path) == Directive::Never {
                             debug!("not summing special path {:?}", entry_path);
                             continue;
                         }
@@ -188,7 +177,7 @@ impl DirSummer {
 
                                         let path = e.path();
 
-                                        if is_ignored(&path, &special_paths) {
+                                        if special_paths.sum(&path) == Directive::Never {
                                             debug!("not summing (deep) special path {:?}", path);
                                             continue;
                                         }