zed/crates/worktree/src/worktree_settings.rs

use std::path::Path;

use anyhow::Context as _;
use settings::{RegisterSetting, Settings};
use util::{
    ResultExt,
    paths::{PathMatcher, PathStyle},
    rel_path::RelPath,
};

#[derive(Clone, PartialEq, Eq, RegisterSetting)]
pub struct WorktreeSettings {
    pub project_name: Option<String>,
    /// Whether to prevent this project from being shared in public channels.
    pub prevent_sharing_in_public_channels: bool,
    pub file_scan_exclusions: PathMatcher,
    pub file_scan_inclusions: PathMatcher,
    /// This field contains all ancestors of the `file_scan_inclusions`. It's used to
    /// determine whether to terminate worktree scanning for a given dir.
    pub parent_dir_scan_inclusions: PathMatcher,
    pub private_files: PathMatcher,
    pub hidden_files: PathMatcher,
    pub read_only_files: PathMatcher,
}

impl WorktreeSettings {
    pub fn is_path_private(&self, path: &RelPath) -> bool {
        path.ancestors()
            .any(|ancestor| self.private_files.is_match(ancestor))
    }

    pub fn is_path_excluded(&self, path: &RelPath) -> bool {
        path.ancestors()
            .any(|ancestor| self.file_scan_exclusions.is_match(ancestor))
    }

    pub fn is_path_always_included(&self, path: &RelPath, is_dir: bool) -> bool {
        if is_dir {
            self.parent_dir_scan_inclusions.is_match(path)
        } else {
            self.file_scan_inclusions.is_match(path)
        }
    }

    pub fn is_path_hidden(&self, path: &RelPath) -> bool {
        path.ancestors()
            .any(|ancestor| self.hidden_files.is_match(ancestor))
    }

    pub fn is_path_read_only(&self, path: &RelPath) -> bool {
        self.read_only_files.is_match(path)
    }

    pub fn is_std_path_read_only(&self, path: &Path) -> bool {
        self.read_only_files.is_match_std_path(path)
    }
}

impl Settings for WorktreeSettings {
    fn from_settings(content: &settings::SettingsContent) -> Self {
        let worktree = content.project.worktree.clone();
        let file_scan_exclusions = worktree.file_scan_exclusions.unwrap();
        let file_scan_inclusions = worktree.file_scan_inclusions.unwrap();
        let private_files = worktree.private_files.unwrap().0;
        let hidden_files = worktree.hidden_files.unwrap();
        let read_only_files = worktree.read_only_files.unwrap_or_default();
        let parsed_file_scan_inclusions: Vec<String> = file_scan_inclusions
            .iter()
            .flat_map(|glob| {
                Path::new(glob)
                    .ancestors()
                    .skip(1)
                    .map(|a| a.to_string_lossy().into())
            })
            .filter(|p: &String| !p.is_empty())
            .collect();

        Self {
            project_name: worktree.project_name,
            prevent_sharing_in_public_channels: worktree.prevent_sharing_in_public_channels,
            file_scan_exclusions: path_matchers(file_scan_exclusions, "file_scan_exclusions")
                .log_err()
                .unwrap_or_default(),
            parent_dir_scan_inclusions: path_matchers(
                parsed_file_scan_inclusions,
                "file_scan_inclusions",
            )
            .unwrap(),
            file_scan_inclusions: path_matchers(file_scan_inclusions, "file_scan_inclusions")
                .unwrap(),
            private_files: path_matchers(private_files, "private_files")
                .log_err()
                .unwrap_or_default(),
            hidden_files: path_matchers(hidden_files, "hidden_files")
                .log_err()
                .unwrap_or_default(),
            read_only_files: path_matchers(read_only_files, "read_only_files")
                .log_err()
                .unwrap_or_default(),
        }
    }
}

fn path_matchers(mut values: Vec<String>, context: &'static str) -> anyhow::Result<PathMatcher> {
    values.sort();
    PathMatcher::new(values, PathStyle::local())
        .with_context(|| format!("Failed to parse globs from {}", context))
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::Path;

    fn make_settings_with_read_only(patterns: &[&str]) -> WorktreeSettings {
        WorktreeSettings {
            project_name: None,
            prevent_sharing_in_public_channels: false,
            file_scan_exclusions: PathMatcher::default(),
            file_scan_inclusions: PathMatcher::default(),
            parent_dir_scan_inclusions: PathMatcher::default(),
            private_files: PathMatcher::default(),
            hidden_files: PathMatcher::default(),
            read_only_files: PathMatcher::new(
                patterns.iter().map(|s| s.to_string()),
                PathStyle::local(),
            )
            .unwrap(),
        }
    }

    #[test]
    fn test_is_path_read_only_with_glob_patterns() {
        let settings = make_settings_with_read_only(&["**/generated/**", "**/*.gen.rs"]);

        let generated_file =
            RelPath::new(Path::new("src/generated/schema.rs"), PathStyle::local()).unwrap();
        assert!(
            settings.is_path_read_only(&generated_file),
            "Files in generated directory should be read-only"
        );

        let gen_rs_file = RelPath::new(Path::new("src/types.gen.rs"), PathStyle::local()).unwrap();
        assert!(
            settings.is_path_read_only(&gen_rs_file),
            "Files with .gen.rs extension should be read-only"
        );

        let regular_file = RelPath::new(Path::new("src/main.rs"), PathStyle::local()).unwrap();
        assert!(
            !settings.is_path_read_only(&regular_file),
            "Regular files should not be read-only"
        );

        let similar_name = RelPath::new(Path::new("src/generator.rs"), PathStyle::local()).unwrap();
        assert!(
            !settings.is_path_read_only(&similar_name),
            "Files with 'generator' in name but not in generated dir should not be read-only"
        );
    }

    #[test]
    fn test_is_path_read_only_with_specific_paths() {
        let settings = make_settings_with_read_only(&["vendor/**", "node_modules/**"]);

        let vendor_file =
            RelPath::new(Path::new("vendor/lib/package.js"), PathStyle::local()).unwrap();
        assert!(
            settings.is_path_read_only(&vendor_file),
            "Files in vendor directory should be read-only"
        );

        let node_modules_file = RelPath::new(
            Path::new("node_modules/lodash/index.js"),
            PathStyle::local(),
        )
        .unwrap();
        assert!(
            settings.is_path_read_only(&node_modules_file),
            "Files in node_modules should be read-only"
        );

        let src_file = RelPath::new(Path::new("src/app.js"), PathStyle::local()).unwrap();
        assert!(
            !settings.is_path_read_only(&src_file),
            "Files in src should not be read-only"
        );
    }

    #[test]
    fn test_is_path_read_only_empty_patterns() {
        let settings = make_settings_with_read_only(&[]);

        let any_file = RelPath::new(Path::new("src/main.rs"), PathStyle::local()).unwrap();
        assert!(
            !settings.is_path_read_only(&any_file),
            "No files should be read-only when patterns are empty"
        );
    }

    #[test]
    fn test_is_path_read_only_with_extension_pattern() {
        let settings = make_settings_with_read_only(&["**/*.lock", "**/*.min.js"]);

        let lock_file = RelPath::new(Path::new("Cargo.lock"), PathStyle::local()).unwrap();
        assert!(
            settings.is_path_read_only(&lock_file),
            "Lock files should be read-only"
        );

        let nested_lock =
            RelPath::new(Path::new("packages/app/yarn.lock"), PathStyle::local()).unwrap();
        assert!(
            settings.is_path_read_only(&nested_lock),
            "Nested lock files should be read-only"
        );

        let minified_js =
            RelPath::new(Path::new("dist/bundle.min.js"), PathStyle::local()).unwrap();
        assert!(
            settings.is_path_read_only(&minified_js),
            "Minified JS files should be read-only"
        );

        let regular_js = RelPath::new(Path::new("src/app.js"), PathStyle::local()).unwrap();
        assert!(
            !settings.is_path_read_only(&regular_js),
            "Regular JS files should not be read-only"
        );
    }
}