From e32462c6d56592acd22f1aab64f627636a476d6c Mon Sep 17 00:00:00 2001
From: Ville Penttinen <villem.penttinen@gmail.com>
Date: Tue, 19 Mar 2019 15:14:16 +0200
Subject: Improve filtering of file roots

`ProjectWorkspace::to_roots` now returns a new `ProjectRoot` which contains
information regarding whether or not the given path is part of the current
workspace or an external dependency. This information can then be used in
`ra_batch` and `ra_lsp_server` to implement more advanced filtering. This allows
us to filter some unnecessary folders from external dependencies such as tests,
examples and benches.
---
 crates/ra_batch/src/lib.rs        | 36 +++++-------------------
 crates/ra_batch/src/vfs_filter.rs | 59 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 66 insertions(+), 29 deletions(-)
 create mode 100644 crates/ra_batch/src/vfs_filter.rs

(limited to 'crates/ra_batch')

diff --git a/crates/ra_batch/src/lib.rs b/crates/ra_batch/src/lib.rs
index a054d0da3..deb9f95d7 100644
--- a/crates/ra_batch/src/lib.rs
+++ b/crates/ra_batch/src/lib.rs
@@ -1,5 +1,7 @@
+mod vfs_filter;
+
 use std::sync::Arc;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::collections::HashSet;
 
 use rustc_hash::FxHashMap;
@@ -9,7 +11,8 @@ use ra_db::{
 };
 use ra_hir::{db, HirInterner};
 use ra_project_model::ProjectWorkspace;
-use ra_vfs::{Vfs, VfsChange, RootEntry, Filter, RelativePath};
+use ra_vfs::{Vfs, VfsChange};
+use vfs_filter::IncludeRustFiles;
 
 type Result<T> = std::result::Result<T, failure::Error>;
 
@@ -43,30 +46,6 @@ fn vfs_root_to_id(r: ra_vfs::VfsRoot) -> SourceRootId {
     SourceRootId(r.0.into())
 }
 
-struct IncludeRustFiles;
-
-impl IncludeRustFiles {
-    fn to_entry(path: PathBuf) -> RootEntry {
-        RootEntry::new(path, Box::new(Self {}))
-    }
-}
-
-impl Filter for IncludeRustFiles {
-    fn include_dir(&self, dir_path: &RelativePath) -> bool {
-        const IGNORED_FOLDERS: &[&str] = &["node_modules", "target", ".git"];
-
-        let is_ignored = dir_path.components().any(|c| IGNORED_FOLDERS.contains(&c.as_str()));
-
-        let hidden = dir_path.components().any(|c| c.as_str().starts_with("."));
-
-        !is_ignored && !hidden
-    }
-
-    fn include_file(&self, file_path: &RelativePath) -> bool {
-        file_path.extension() == Some("rs")
-    }
-}
-
 impl BatchDatabase {
     pub fn load(crate_graph: CrateGraph, vfs: &mut Vfs) -> BatchDatabase {
         let mut db =
@@ -122,9 +101,8 @@ impl BatchDatabase {
         let root = std::env::current_dir()?.join(root);
         let ws = ProjectWorkspace::discover(root.as_ref())?;
         let mut roots = Vec::new();
-        roots.push(root.clone());
-        roots.extend(ws.to_roots());
-        let roots = roots.into_iter().map(IncludeRustFiles::to_entry).collect::<Vec<_>>();
+        roots.push(IncludeRustFiles::member(root.clone()));
+        roots.extend(IncludeRustFiles::from_roots(ws.to_roots()));
         let (mut vfs, roots) = Vfs::new(roots);
         let mut load = |path: &Path| {
             let vfs_file = vfs.load(path);
diff --git a/crates/ra_batch/src/vfs_filter.rs b/crates/ra_batch/src/vfs_filter.rs
new file mode 100644
index 000000000..290aec172
--- /dev/null
+++ b/crates/ra_batch/src/vfs_filter.rs
@@ -0,0 +1,59 @@
+use std::path::PathBuf;
+use ra_project_model::ProjectRoot;
+use ra_vfs::{RootEntry, Filter, RelativePath};
+
+pub struct IncludeRustFiles {
+    /// Is a member of the current workspace
+    is_member: bool,
+}
+
+impl IncludeRustFiles {
+    pub fn from_roots<R>(roots: R) -> impl Iterator<Item = RootEntry>
+    where
+        R: IntoIterator<Item = ProjectRoot>,
+    {
+        roots.into_iter().map(IncludeRustFiles::from_root)
+    }
+
+    pub fn from_root(root: ProjectRoot) -> RootEntry {
+        let is_member = root.is_member();
+        IncludeRustFiles::into_entry(root.into_path(), is_member)
+    }
+
+    #[allow(unused)]
+    pub fn external(path: PathBuf) -> RootEntry {
+        IncludeRustFiles::into_entry(path, false)
+    }
+
+    pub fn member(path: PathBuf) -> RootEntry {
+        IncludeRustFiles::into_entry(path, true)
+    }
+
+    fn into_entry(path: PathBuf, is_member: bool) -> RootEntry {
+        RootEntry::new(path, Box::new(Self { is_member }))
+    }
+}
+
+impl Filter for IncludeRustFiles {
+    fn include_dir(&self, dir_path: &RelativePath) -> bool {
+        const COMMON_IGNORED_DIRS: &[&str] = &["node_modules", "target", ".git"];
+        const EXTERNAL_IGNORED_DIRS: &[&str] = &["examples", "tests", "benches"];
+
+        let is_ignored = if self.is_member {
+            dir_path.components().any(|c| COMMON_IGNORED_DIRS.contains(&c.as_str()))
+        } else {
+            dir_path.components().any(|c| {
+                let path = c.as_str();
+                COMMON_IGNORED_DIRS.contains(&path) || EXTERNAL_IGNORED_DIRS.contains(&path)
+            })
+        };
+
+        let hidden = dir_path.components().any(|c| c.as_str().starts_with("."));
+
+        !is_ignored && !hidden
+    }
+
+    fn include_file(&self, file_path: &RelativePath) -> bool {
+        file_path.extension() == Some("rs")
+    }
+}
-- 
cgit v1.2.3