Rename worktree crate to project, pull in Project

Also, move the high-level fuzzy mathcing functions in
zed::fuzzy into the fuzzy crate so that project can
use them.

This required defining a 'PathMatchCandidateSet' trait
to avoid a circular dependency from fuzzy to worktree.

Co-Authored-By: Nathan Sobo <nathan@zed.dev>

crates/project/src/fs.rs

@@ -0,0 +1,428 @@
+use anyhow::{anyhow, Result};
+use buffer::Rope;
+use fsevent::EventStream;
+use futures::{Stream, StreamExt};
+use postage::prelude::Sink as _;
+use smol::io::{AsyncReadExt, AsyncWriteExt};
+use std::{
+    io,
+    os::unix::fs::MetadataExt,
+    path::{Path, PathBuf},
+    pin::Pin,
+    time::{Duration, SystemTime},
+};
+
+#[async_trait::async_trait]
+pub trait Fs: Send + Sync {
+    async fn load(&self, path: &Path) -> Result<String>;
+    async fn save(&self, path: &Path, text: &Rope) -> Result<()>;
+    async fn canonicalize(&self, path: &Path) -> Result<PathBuf>;
+    async fn is_file(&self, path: &Path) -> bool;
+    async fn metadata(&self, path: &Path) -> Result<Option<Metadata>>;
+    async fn read_dir(
+        &self,
+        path: &Path,
+    ) -> Result<Pin<Box<dyn Send + Stream<Item = Result<PathBuf>>>>>;
+    async fn watch(
+        &self,
+        path: &Path,
+        latency: Duration,
+    ) -> Pin<Box<dyn Send + Stream<Item = Vec<fsevent::Event>>>>;
+    fn is_fake(&self) -> bool;
+    #[cfg(any(test, feature = "test-support"))]
+    fn as_fake(&self) -> &FakeFs;
+}
+
+#[derive(Clone, Debug)]
+pub struct Metadata {
+    pub inode: u64,
+    pub mtime: SystemTime,
+    pub is_symlink: bool,
+    pub is_dir: bool,
+}
+
+pub struct RealFs;
+
+#[async_trait::async_trait]
+impl Fs for RealFs {
+    async fn load(&self, path: &Path) -> Result<String> {
+        let mut file = smol::fs::File::open(path).await?;
+        let mut text = String::new();
+        file.read_to_string(&mut text).await?;
+        Ok(text)
+    }
+
+    async fn save(&self, path: &Path, text: &Rope) -> Result<()> {
+        let buffer_size = text.summary().bytes.min(10 * 1024);
+        let file = smol::fs::File::create(path).await?;
+        let mut writer = smol::io::BufWriter::with_capacity(buffer_size, file);
+        for chunk in text.chunks() {
+            writer.write_all(chunk.as_bytes()).await?;
+        }
+        writer.flush().await?;
+        Ok(())
+    }
+
+    async fn canonicalize(&self, path: &Path) -> Result<PathBuf> {
+        Ok(smol::fs::canonicalize(path).await?)
+    }
+
+    async fn is_file(&self, path: &Path) -> bool {
+        smol::fs::metadata(path)
+            .await
+            .map_or(false, |metadata| metadata.is_file())
+    }
+
+    async fn metadata(&self, path: &Path) -> Result<Option<Metadata>> {
+        let symlink_metadata = match smol::fs::symlink_metadata(path).await {
+            Ok(metadata) => metadata,
+            Err(err) => {
+                return match (err.kind(), err.raw_os_error()) {
+                    (io::ErrorKind::NotFound, _) => Ok(None),
+                    (io::ErrorKind::Other, Some(libc::ENOTDIR)) => Ok(None),
+                    _ => Err(anyhow::Error::new(err)),
+                }
+            }
+        };
+
+        let is_symlink = symlink_metadata.file_type().is_symlink();
+        let metadata = if is_symlink {
+            smol::fs::metadata(path).await?
+        } else {
+            symlink_metadata
+        };
+        Ok(Some(Metadata {
+            inode: metadata.ino(),
+            mtime: metadata.modified().unwrap(),
+            is_symlink,
+            is_dir: metadata.file_type().is_dir(),
+        }))
+    }
+
+    async fn read_dir(
+        &self,
+        path: &Path,
+    ) -> Result<Pin<Box<dyn Send + Stream<Item = Result<PathBuf>>>>> {
+        let result = smol::fs::read_dir(path).await?.map(|entry| match entry {
+            Ok(entry) => Ok(entry.path()),
+            Err(error) => Err(anyhow!("failed to read dir entry {:?}", error)),
+        });
+        Ok(Box::pin(result))
+    }
+
+    async fn watch(
+        &self,
+        path: &Path,
+        latency: Duration,
+    ) -> Pin<Box<dyn Send + Stream<Item = Vec<fsevent::Event>>>> {
+        let (mut tx, rx) = postage::mpsc::channel(64);
+        let (stream, handle) = EventStream::new(&[path], latency);
+        std::mem::forget(handle);
+        std::thread::spawn(move || {
+            stream.run(move |events| smol::block_on(tx.send(events)).is_ok());
+        });
+        Box::pin(rx)
+    }
+
+    fn is_fake(&self) -> bool {
+        false
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    fn as_fake(&self) -> &FakeFs {
+        panic!("called `RealFs::as_fake`")
+    }
+}
+
+#[derive(Clone, Debug)]
+struct FakeFsEntry {
+    metadata: Metadata,
+    content: Option<String>,
+}
+
+#[cfg(any(test, feature = "test-support"))]
+struct FakeFsState {
+    entries: std::collections::BTreeMap<PathBuf, FakeFsEntry>,
+    next_inode: u64,
+    events_tx: postage::broadcast::Sender<Vec<fsevent::Event>>,
+}
+
+#[cfg(any(test, feature = "test-support"))]
+impl FakeFsState {
+    fn validate_path(&self, path: &Path) -> Result<()> {
+        if path.is_absolute()
+            && path
+                .parent()
+                .and_then(|path| self.entries.get(path))
+                .map_or(false, |e| e.metadata.is_dir)
+        {
+            Ok(())
+        } else {
+            Err(anyhow!("invalid path {:?}", path))
+        }
+    }
+
+    async fn emit_event(&mut self, paths: &[&Path]) {
+        let events = paths
+            .iter()
+            .map(|path| fsevent::Event {
+                event_id: 0,
+                flags: fsevent::StreamFlags::empty(),
+                path: path.to_path_buf(),
+            })
+            .collect();
+
+        let _ = self.events_tx.send(events).await;
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+pub struct FakeFs {
+    // Use an unfair lock to ensure tests are deterministic.
+    state: futures::lock::Mutex<FakeFsState>,
+}
+
+#[cfg(any(test, feature = "test-support"))]
+impl FakeFs {
+    pub fn new() -> Self {
+        let (events_tx, _) = postage::broadcast::channel(2048);
+        let mut entries = std::collections::BTreeMap::new();
+        entries.insert(
+            Path::new("/").to_path_buf(),
+            FakeFsEntry {
+                metadata: Metadata {
+                    inode: 0,
+                    mtime: SystemTime::now(),
+                    is_dir: true,
+                    is_symlink: false,
+                },
+                content: None,
+            },
+        );
+        Self {
+            state: futures::lock::Mutex::new(FakeFsState {
+                entries,
+                next_inode: 1,
+                events_tx,
+            }),
+        }
+    }
+
+    pub async fn insert_dir(&self, path: impl AsRef<Path>) -> Result<()> {
+        let mut state = self.state.lock().await;
+        let path = path.as_ref();
+        state.validate_path(path)?;
+
+        let inode = state.next_inode;
+        state.next_inode += 1;
+        state.entries.insert(
+            path.to_path_buf(),
+            FakeFsEntry {
+                metadata: Metadata {
+                    inode,
+                    mtime: SystemTime::now(),
+                    is_dir: true,
+                    is_symlink: false,
+                },
+                content: None,
+            },
+        );
+        state.emit_event(&[path]).await;
+        Ok(())
+    }
+
+    pub async fn insert_file(&self, path: impl AsRef<Path>, content: String) -> Result<()> {
+        let mut state = self.state.lock().await;
+        let path = path.as_ref();
+        state.validate_path(path)?;
+
+        let inode = state.next_inode;
+        state.next_inode += 1;
+        state.entries.insert(
+            path.to_path_buf(),
+            FakeFsEntry {
+                metadata: Metadata {
+                    inode,
+                    mtime: SystemTime::now(),
+                    is_dir: false,
+                    is_symlink: false,
+                },
+                content: Some(content),
+            },
+        );
+        state.emit_event(&[path]).await;
+        Ok(())
+    }
+
+    #[must_use]
+    pub fn insert_tree<'a>(
+        &'a self,
+        path: impl 'a + AsRef<Path> + Send,
+        tree: serde_json::Value,
+    ) -> futures::future::BoxFuture<'a, ()> {
+        use futures::FutureExt as _;
+        use serde_json::Value::*;
+
+        async move {
+            let path = path.as_ref();
+
+            match tree {
+                Object(map) => {
+                    self.insert_dir(path).await.unwrap();
+                    for (name, contents) in map {
+                        let mut path = PathBuf::from(path);
+                        path.push(name);
+                        self.insert_tree(&path, contents).await;
+                    }
+                }
+                Null => {
+                    self.insert_dir(&path).await.unwrap();
+                }
+                String(contents) => {
+                    self.insert_file(&path, contents).await.unwrap();
+                }
+                _ => {
+                    panic!("JSON object must contain only objects, strings, or null");
+                }
+            }
+        }
+        .boxed()
+    }
+
+    pub async fn remove(&self, path: &Path) -> Result<()> {
+        let mut state = self.state.lock().await;
+        state.validate_path(path)?;
+        state.entries.retain(|path, _| !path.starts_with(path));
+        state.emit_event(&[path]).await;
+        Ok(())
+    }
+
+    pub async fn rename(&self, source: &Path, target: &Path) -> Result<()> {
+        let mut state = self.state.lock().await;
+        state.validate_path(source)?;
+        state.validate_path(target)?;
+        if state.entries.contains_key(target) {
+            Err(anyhow!("target path already exists"))
+        } else {
+            let mut removed = Vec::new();
+            state.entries.retain(|path, entry| {
+                if let Ok(relative_path) = path.strip_prefix(source) {
+                    removed.push((relative_path.to_path_buf(), entry.clone()));
+                    false
+                } else {
+                    true
+                }
+            });
+
+            for (relative_path, entry) in removed {
+                let new_path = target.join(relative_path);
+                state.entries.insert(new_path, entry);
+            }
+
+            state.emit_event(&[source, target]).await;
+            Ok(())
+        }
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+#[async_trait::async_trait]
+impl Fs for FakeFs {
+    async fn load(&self, path: &Path) -> Result<String> {
+        let state = self.state.lock().await;
+        let text = state
+            .entries
+            .get(path)
+            .and_then(|e| e.content.as_ref())
+            .ok_or_else(|| anyhow!("file {:?} does not exist", path))?;
+        Ok(text.clone())
+    }
+
+    async fn save(&self, path: &Path, text: &Rope) -> Result<()> {
+        let mut state = self.state.lock().await;
+        state.validate_path(path)?;
+        if let Some(entry) = state.entries.get_mut(path) {
+            if entry.metadata.is_dir {
+                Err(anyhow!("cannot overwrite a directory with a file"))
+            } else {
+                entry.content = Some(text.chunks().collect());
+                entry.metadata.mtime = SystemTime::now();
+                state.emit_event(&[path]).await;
+                Ok(())
+            }
+        } else {
+            let inode = state.next_inode;
+            state.next_inode += 1;
+            let entry = FakeFsEntry {
+                metadata: Metadata {
+                    inode,
+                    mtime: SystemTime::now(),
+                    is_dir: false,
+                    is_symlink: false,
+                },
+                content: Some(text.chunks().collect()),
+            };
+            state.entries.insert(path.to_path_buf(), entry);
+            state.emit_event(&[path]).await;
+            Ok(())
+        }
+    }
+
+    async fn canonicalize(&self, path: &Path) -> Result<PathBuf> {
+        Ok(path.to_path_buf())
+    }
+
+    async fn is_file(&self, path: &Path) -> bool {
+        let state = self.state.lock().await;
+        state
+            .entries
+            .get(path)
+            .map_or(false, |entry| !entry.metadata.is_dir)
+    }
+
+    async fn metadata(&self, path: &Path) -> Result<Option<Metadata>> {
+        let state = self.state.lock().await;
+        Ok(state.entries.get(path).map(|entry| entry.metadata.clone()))
+    }
+
+    async fn read_dir(
+        &self,
+        abs_path: &Path,
+    ) -> Result<Pin<Box<dyn Send + Stream<Item = Result<PathBuf>>>>> {
+        use futures::{future, stream};
+        let state = self.state.lock().await;
+        let abs_path = abs_path.to_path_buf();
+        Ok(Box::pin(stream::iter(state.entries.clone()).filter_map(
+            move |(child_path, _)| {
+                future::ready(if child_path.parent() == Some(&abs_path) {
+                    Some(Ok(child_path))
+                } else {
+                    None
+                })
+            },
+        )))
+    }
+
+    async fn watch(
+        &self,
+        path: &Path,
+        _: Duration,
+    ) -> Pin<Box<dyn Send + Stream<Item = Vec<fsevent::Event>>>> {
+        let state = self.state.lock().await;
+        let rx = state.events_tx.subscribe();
+        let path = path.to_path_buf();
+        Box::pin(futures::StreamExt::filter(rx, move |events| {
+            let result = events.iter().any(|event| event.path.starts_with(&path));
+            async move { result }
+        }))
+    }
+
+    fn is_fake(&self) -> bool {
+        true
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    fn as_fake(&self) -> &FakeFs {
+        self
+    }
+}

crates/project/src/ignore.rs

@@ -0,0 +1,57 @@
+use ignore::gitignore::Gitignore;
+use std::{ffi::OsStr, path::Path, sync::Arc};
+
+pub enum IgnoreStack {
+    None,
+    Some {
+        base: Arc<Path>,
+        ignore: Arc<Gitignore>,
+        parent: Arc<IgnoreStack>,
+    },
+    All,
+}
+
+impl IgnoreStack {
+    pub fn none() -> Arc<Self> {
+        Arc::new(Self::None)
+    }
+
+    pub fn all() -> Arc<Self> {
+        Arc::new(Self::All)
+    }
+
+    pub fn is_all(&self) -> bool {
+        matches!(self, IgnoreStack::All)
+    }
+
+    pub fn append(self: Arc<Self>, base: Arc<Path>, ignore: Arc<Gitignore>) -> Arc<Self> {
+        match self.as_ref() {
+            IgnoreStack::All => self,
+            _ => Arc::new(Self::Some {
+                base,
+                ignore,
+                parent: self,
+            }),
+        }
+    }
+
+    pub fn is_path_ignored(&self, path: &Path, is_dir: bool) -> bool {
+        if is_dir && path.file_name() == Some(OsStr::new(".git")) {
+            return true;
+        }
+
+        match self {
+            Self::None => false,
+            Self::All => true,
+            Self::Some {
+                base,
+                ignore,
+                parent: prev,
+            } => match ignore.matched(path.strip_prefix(base).unwrap(), is_dir) {
+                ignore::Match::None => prev.is_path_ignored(path, is_dir),
+                ignore::Match::Ignore(_) => true,
+                ignore::Match::Whitelist(_) => false,
+            },
+        }
+    }
+}

crates/project/src/lib.rs

@@ -0,0 +1,413 @@
+pub mod fs;
+mod ignore;
+mod worktree;
+
+use anyhow::Result;
+use buffer::LanguageRegistry;
+use futures::Future;
+use fuzzy::{self, PathMatch, PathMatchCandidate, PathMatchCandidateSet};
+use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
+use rpc_client as rpc;
+use std::{
+    path::Path,
+    sync::{atomic::AtomicBool, Arc},
+};
+use util::TryFutureExt as _;
+
+pub use fs::*;
+pub use worktree::*;
+
+pub struct Project {
+    worktrees: Vec<ModelHandle<Worktree>>,
+    active_entry: Option<ProjectEntry>,
+    languages: Arc<LanguageRegistry>,
+    rpc: Arc<rpc::Client>,
+    fs: Arc<dyn Fs>,
+}
+
+pub enum Event {
+    ActiveEntryChanged(Option<ProjectEntry>),
+    WorktreeRemoved(usize),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct ProjectPath {
+    pub worktree_id: usize,
+    pub path: Arc<Path>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct ProjectEntry {
+    pub worktree_id: usize,
+    pub entry_id: usize,
+}
+
+impl Project {
+    pub fn new(languages: Arc<LanguageRegistry>, rpc: Arc<rpc::Client>, fs: Arc<dyn Fs>) -> Self {
+        Self {
+            worktrees: Default::default(),
+            active_entry: None,
+            languages,
+            rpc,
+            fs,
+        }
+    }
+
+    pub fn worktrees(&self) -> &[ModelHandle<Worktree>] {
+        &self.worktrees
+    }
+
+    pub fn worktree_for_id(&self, id: usize) -> Option<ModelHandle<Worktree>> {
+        self.worktrees
+            .iter()
+            .find(|worktree| worktree.id() == id)
+            .cloned()
+    }
+
+    pub fn add_local_worktree(
+        &mut self,
+        abs_path: &Path,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<ModelHandle<Worktree>>> {
+        let fs = self.fs.clone();
+        let rpc = self.rpc.clone();
+        let languages = self.languages.clone();
+        let path = Arc::from(abs_path);
+        cx.spawn(|this, mut cx| async move {
+            let worktree = Worktree::open_local(rpc, path, fs, languages, &mut cx).await?;
+            this.update(&mut cx, |this, cx| {
+                this.add_worktree(worktree.clone(), cx);
+            });
+            Ok(worktree)
+        })
+    }
+
+    pub fn add_remote_worktree(
+        &mut self,
+        remote_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<ModelHandle<Worktree>>> {
+        let rpc = self.rpc.clone();
+        let languages = self.languages.clone();
+        cx.spawn(|this, mut cx| async move {
+            rpc.authenticate_and_connect(&cx).await?;
+            let worktree =
+                Worktree::open_remote(rpc.clone(), remote_id, languages, &mut cx).await?;
+            this.update(&mut cx, |this, cx| {
+                cx.subscribe(&worktree, move |this, _, event, cx| match event {
+                    worktree::Event::Closed => {
+                        this.close_remote_worktree(remote_id, cx);
+                        cx.notify();
+                    }
+                })
+                .detach();
+                this.add_worktree(worktree.clone(), cx);
+            });
+            Ok(worktree)
+        })
+    }
+
+    fn add_worktree(&mut self, worktree: ModelHandle<Worktree>, cx: &mut ModelContext<Self>) {
+        cx.observe(&worktree, |_, _, cx| cx.notify()).detach();
+        self.worktrees.push(worktree);
+        cx.notify();
+    }
+
+    pub fn set_active_path(&mut self, entry: Option<ProjectPath>, cx: &mut ModelContext<Self>) {
+        let new_active_entry = entry.and_then(|project_path| {
+            let worktree = self.worktree_for_id(project_path.worktree_id)?;
+            let entry = worktree.read(cx).entry_for_path(project_path.path)?;
+            Some(ProjectEntry {
+                worktree_id: project_path.worktree_id,
+                entry_id: entry.id,
+            })
+        });
+        if new_active_entry != self.active_entry {
+            self.active_entry = new_active_entry;
+            cx.emit(Event::ActiveEntryChanged(new_active_entry));
+        }
+    }
+
+    pub fn active_entry(&self) -> Option<ProjectEntry> {
+        self.active_entry
+    }
+
+    pub fn share_worktree(&self, remote_id: u64, cx: &mut ModelContext<Self>) {
+        let rpc = self.rpc.clone();
+        cx.spawn(|this, mut cx| {
+            async move {
+                rpc.authenticate_and_connect(&cx).await?;
+
+                let task = this.update(&mut cx, |this, cx| {
+                    for worktree in &this.worktrees {
+                        let task = worktree.update(cx, |worktree, cx| {
+                            worktree.as_local_mut().and_then(|worktree| {
+                                if worktree.remote_id() == Some(remote_id) {
+                                    Some(worktree.share(cx))
+                                } else {
+                                    None
+                                }
+                            })
+                        });
+                        if task.is_some() {
+                            return task;
+                        }
+                    }
+                    None
+                });
+
+                if let Some(task) = task {
+                    task.await?;
+                }
+
+                Ok(())
+            }
+            .log_err()
+        })
+        .detach();
+    }
+
+    pub fn unshare_worktree(&mut self, remote_id: u64, cx: &mut ModelContext<Self>) {
+        for worktree in &self.worktrees {
+            if worktree.update(cx, |worktree, cx| {
+                if let Some(worktree) = worktree.as_local_mut() {
+                    if worktree.remote_id() == Some(remote_id) {
+                        worktree.unshare(cx);
+                        return true;
+                    }
+                }
+                false
+            }) {
+                break;
+            }
+        }
+    }
+
+    pub fn close_remote_worktree(&mut self, id: u64, cx: &mut ModelContext<Self>) {
+        self.worktrees.retain(|worktree| {
+            let keep = worktree.update(cx, |worktree, cx| {
+                if let Some(worktree) = worktree.as_remote_mut() {
+                    if worktree.remote_id() == id {
+                        worktree.close_all_buffers(cx);
+                        return false;
+                    }
+                }
+                true
+            });
+            if !keep {
+                cx.emit(Event::WorktreeRemoved(worktree.id()));
+            }
+            keep
+        });
+    }
+
+    pub fn match_paths<'a>(
+        &self,
+        query: &'a str,
+        include_ignored: bool,
+        smart_case: bool,
+        max_results: usize,
+        cancel_flag: &'a AtomicBool,
+        cx: &AppContext,
+    ) -> impl 'a + Future<Output = Vec<PathMatch>> {
+        let include_root_name = self.worktrees.len() > 1;
+        let candidate_sets = self
+            .worktrees
+            .iter()
+            .map(|worktree| CandidateSet {
+                snapshot: worktree.read(cx).snapshot(),
+                include_ignored,
+                include_root_name,
+            })
+            .collect::<Vec<_>>();
+
+        let background = cx.background().clone();
+        async move {
+            fuzzy::match_paths(
+                candidate_sets.as_slice(),
+                query,
+                smart_case,
+                max_results,
+                cancel_flag,
+                background,
+            )
+            .await
+        }
+    }
+}
+
+struct CandidateSet {
+    snapshot: Snapshot,
+    include_ignored: bool,
+    include_root_name: bool,
+}
+
+impl<'a> PathMatchCandidateSet<'a> for CandidateSet {
+    type Candidates = CandidateSetIter<'a>;
+
+    fn id(&self) -> usize {
+        self.snapshot.id()
+    }
+
+    fn len(&self) -> usize {
+        if self.include_ignored {
+            self.snapshot.file_count()
+        } else {
+            self.snapshot.visible_file_count()
+        }
+    }
+
+    fn prefix(&self) -> Arc<str> {
+        if self.snapshot.root_entry().map_or(false, |e| e.is_file()) {
+            self.snapshot.root_name().into()
+        } else if self.include_root_name {
+            format!("{}/", self.snapshot.root_name()).into()
+        } else {
+            "".into()
+        }
+    }
+
+    fn candidates(&'a self, start: usize) -> Self::Candidates {
+        CandidateSetIter {
+            traversal: self.snapshot.files(self.include_ignored, start),
+        }
+    }
+}
+
+struct CandidateSetIter<'a> {
+    traversal: Traversal<'a>,
+}
+
+impl<'a> Iterator for CandidateSetIter<'a> {
+    type Item = PathMatchCandidate<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.traversal.next().map(|entry| {
+            if let EntryKind::File(char_bag) = entry.kind {
+                PathMatchCandidate {
+                    path: &entry.path,
+                    char_bag,
+                }
+            } else {
+                unreachable!()
+            }
+        })
+    }
+}
+
+impl Entity for Project {
+    type Event = Event;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use buffer::LanguageRegistry;
+    use fs::RealFs;
+    use gpui::TestAppContext;
+    use serde_json::json;
+    use std::{os::unix, path::PathBuf};
+    use util::test::temp_tree;
+
+    #[gpui::test]
+    async fn test_populate_and_search(mut cx: gpui::TestAppContext) {
+        let dir = temp_tree(json!({
+            "root": {
+                "apple": "",
+                "banana": {
+                    "carrot": {
+                        "date": "",
+                        "endive": "",
+                    }
+                },
+                "fennel": {
+                    "grape": "",
+                }
+            }
+        }));
+
+        let root_link_path = dir.path().join("root_link");
+        unix::fs::symlink(&dir.path().join("root"), &root_link_path).unwrap();
+        unix::fs::symlink(
+            &dir.path().join("root/fennel"),
+            &dir.path().join("root/finnochio"),
+        )
+        .unwrap();
+
+        let project = build_project(&mut cx);
+
+        let tree = project
+            .update(&mut cx, |project, cx| {
+                project.add_local_worktree(&root_link_path, cx)
+            })
+            .await
+            .unwrap();
+
+        cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
+            .await;
+        cx.read(|cx| {
+            let tree = tree.read(cx);
+            assert_eq!(tree.file_count(), 5);
+            assert_eq!(
+                tree.inode_for_path("fennel/grape"),
+                tree.inode_for_path("finnochio/grape")
+            );
+        });
+
+        let cancel_flag = Default::default();
+        let results = project
+            .read_with(&cx, |project, cx| {
+                project.match_paths("bna", false, false, 10, &cancel_flag, cx)
+            })
+            .await;
+        assert_eq!(
+            results
+                .into_iter()
+                .map(|result| result.path)
+                .collect::<Vec<Arc<Path>>>(),
+            vec![
+                PathBuf::from("banana/carrot/date").into(),
+                PathBuf::from("banana/carrot/endive").into(),
+            ]
+        );
+    }
+
+    #[gpui::test]
+    async fn test_search_worktree_without_files(mut cx: gpui::TestAppContext) {
+        let dir = temp_tree(json!({
+            "root": {
+                "dir1": {},
+                "dir2": {
+                    "dir3": {}
+                }
+            }
+        }));
+
+        let project = build_project(&mut cx);
+        let tree = project
+            .update(&mut cx, |project, cx| {
+                project.add_local_worktree(&dir.path(), cx)
+            })
+            .await
+            .unwrap();
+
+        cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
+            .await;
+
+        let cancel_flag = Default::default();
+        let results = project
+            .read_with(&cx, |project, cx| {
+                project.match_paths("dir", false, false, 10, &cancel_flag, cx)
+            })
+            .await;
+
+        assert!(results.is_empty());
+    }
+
+    fn build_project(cx: &mut TestAppContext) -> ModelHandle<Project> {
+        let languages = Arc::new(LanguageRegistry::new());
+        let fs = Arc::new(RealFs);
+        let rpc = rpc::Client::new();
+        cx.add_model(|_| Project::new(languages, rpc, fs))
+    }
+}