Refactor: Make it possible to share a remote worktree (#12775)

This PR is an internal refactor in preparation for remote editing. It
restructures the public interface of `Worktree`, reducing the number of
call sites that assume that a worktree is local or remote.

* The Project no longer calls `worktree.as_local_mut().unwrap()` in code
paths related to basic file operations
* Fewer code paths in the app rely on the worktree's `LocalSnapshot`
* Worktree-related RPC message handling is more fully encapsulated by
the `Worktree` type.

to do:
* [x] file manipulation operations
* [x] sending worktree updates when sharing

for later
* opening buffers
* updating open buffers upon worktree changes

Release Notes:

- N/A

crates/worktree/Cargo.toml

@@ -31,7 +31,6 @@ fuzzy.workspace = true
 git.workspace = true
 gpui.workspace = true
 ignore.workspace = true
-itertools.workspace = true
 language.workspace = true
 log.workspace = true
 parking_lot.workspace = true

crates/worktree/src/worktree_settings.rs

@@ -1,10 +1,37 @@
+use std::{path::Path, sync::Arc};
+
 use gpui::AppContext;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
+use util::paths::PathMatcher;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct WorktreeSettings {
+    pub file_scan_exclusions: Arc<[PathMatcher]>,
+    pub private_files: Arc<[PathMatcher]>,
+}
+
+impl WorktreeSettings {
+    pub fn is_path_private(&self, path: &Path) -> bool {
+        path.ancestors().any(|ancestor| {
+            self.private_files
+                .iter()
+                .any(|matcher| matcher.is_match(&ancestor))
+        })
+    }
+
+    pub fn is_path_excluded(&self, path: &Path) -> bool {
+        path.ancestors().any(|ancestor| {
+            self.file_scan_exclusions
+                .iter()
+                .any(|matcher| matcher.is_match(&ancestor))
+        })
+    }
+}
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct WorktreeSettings {
+pub struct WorktreeSettingsContent {
     /// Completely ignore files matching globs from `file_scan_exclusions`
     ///
     /// Default: [
@@ -28,12 +55,37 @@ pub struct WorktreeSettings {
 impl Settings for WorktreeSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = Self;
+    type FileContent = WorktreeSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
         _: &mut AppContext,
     ) -> anyhow::Result<Self> {
-        sources.json_merge()
+        let result: WorktreeSettingsContent = sources.json_merge()?;
+        let mut file_scan_exclusions = result.file_scan_exclusions.unwrap_or_default();
+        let mut private_files = result.private_files.unwrap_or_default();
+        file_scan_exclusions.sort();
+        private_files.sort();
+        Ok(Self {
+            file_scan_exclusions: path_matchers(&file_scan_exclusions, "file_scan_exclusions"),
+            private_files: path_matchers(&private_files, "private_files"),
+        })
     }
 }
+
+fn path_matchers(values: &[String], context: &'static str) -> Arc<[PathMatcher]> {
+    values
+        .iter()
+        .filter_map(|pattern| {
+            PathMatcher::new(pattern)
+                .map(Some)
+                .unwrap_or_else(|e| {
+                    log::error!(
+                        "Skipping pattern {pattern} in `{}` project settings due to parsing error: {e:#}", context
+                    );
+                    None
+                })
+        })
+        .collect::<Vec<_>>()
+        .into()
+}

crates/worktree/src/worktree_tests.rs

@@ -453,11 +453,9 @@ async fn test_open_gitignored_files(cx: &mut TestAppContext) {
     // Open a file that is nested inside of a gitignored directory that
     // has not yet been expanded.
     let prev_read_dir_count = fs.read_dir_call_count();
-    let (file, _, _) = tree
+    let loaded = tree
         .update(cx, |tree, cx| {
-            tree.as_local_mut()
-                .unwrap()
-                .load_file("one/node_modules/b/b1.js".as_ref(), cx)
+            tree.load_file("one/node_modules/b/b1.js".as_ref(), cx)
         })
         .await
         .unwrap();
@@ -483,7 +481,10 @@ async fn test_open_gitignored_files(cx: &mut TestAppContext) {
             ]
         );
 
-        assert_eq!(file.path.as_ref(), Path::new("one/node_modules/b/b1.js"));
+        assert_eq!(
+            loaded.file.path.as_ref(),
+            Path::new("one/node_modules/b/b1.js")
+        );
 
         // Only the newly-expanded directories are scanned.
         assert_eq!(fs.read_dir_call_count() - prev_read_dir_count, 2);
@@ -492,11 +493,9 @@ async fn test_open_gitignored_files(cx: &mut TestAppContext) {
     // Open another file in a different subdirectory of the same
     // gitignored directory.
     let prev_read_dir_count = fs.read_dir_call_count();
-    let (file, _, _) = tree
+    let loaded = tree
         .update(cx, |tree, cx| {
-            tree.as_local_mut()
-                .unwrap()
-                .load_file("one/node_modules/a/a2.js".as_ref(), cx)
+            tree.load_file("one/node_modules/a/a2.js".as_ref(), cx)
         })
         .await
         .unwrap();
@@ -524,7 +523,10 @@ async fn test_open_gitignored_files(cx: &mut TestAppContext) {
             ]
         );
 
-        assert_eq!(file.path.as_ref(), Path::new("one/node_modules/a/a2.js"));
+        assert_eq!(
+            loaded.file.path.as_ref(),
+            Path::new("one/node_modules/a/a2.js")
+        );
 
         // Only the newly-expanded directory is scanned.
         assert_eq!(fs.read_dir_call_count() - prev_read_dir_count, 1);
@@ -844,7 +846,7 @@ async fn test_write_file(cx: &mut TestAppContext) {
     tree.flush_fs_events(cx).await;
 
     tree.update(cx, |tree, cx| {
-        tree.as_local().unwrap().write_file(
+        tree.write_file(
             Path::new("tracked-dir/file.txt"),
             "hello".into(),
             Default::default(),
@@ -854,7 +856,7 @@ async fn test_write_file(cx: &mut TestAppContext) {
     .await
     .unwrap();
     tree.update(cx, |tree, cx| {
-        tree.as_local().unwrap().write_file(
+        tree.write_file(
             Path::new("ignored-dir/file.txt"),
             "world".into(),
             Default::default(),