11 files changed, 135 insertions, 142 deletions

diff --git a/crates/ra_batch/Cargo.toml b/crates/ra_batch/Cargo.toml
index 0ee94c445..8e23826a4 100644
--- a/crates/ra_batch/Cargo.toml
+++ b/crates/ra_batch/Cargo.toml
@@ -9,6 +9,7 @@ log = "0.4.5"
 rustc-hash = "1.0"
 
 ra_vfs = "0.2.0"
+ra_vfs_glob = { path = "../ra_vfs_glob" }
 ra_db = { path = "../ra_db" }
 ra_ide_api = { path = "../ra_ide_api" }
 ra_hir = { path = "../ra_hir" }
diff --git a/crates/ra_batch/src/lib.rs b/crates/ra_batch/src/lib.rs
index c01574fbc..0db751465 100644
--- a/crates/ra_batch/src/lib.rs
+++ b/crates/ra_batch/src/lib.rs
@@ -1,5 +1,3 @@
-mod vfs_filter;
-
 use std::{collections::HashSet, error::Error, path::Path};
 
 use rustc_hash::FxHashMap;
@@ -7,8 +5,8 @@ use rustc_hash::FxHashMap;
 use ra_db::{CrateGraph, FileId, SourceRootId};
 use ra_ide_api::{AnalysisChange, AnalysisHost};
 use ra_project_model::{PackageRoot, ProjectWorkspace};
-use ra_vfs::{Vfs, VfsChange};
-use vfs_filter::IncludeRustFiles;
+use ra_vfs::{RootEntry, Vfs, VfsChange};
+use ra_vfs_glob::RustPackageFilterBuilder;
 
 type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 
@@ -23,7 +21,19 @@ pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId,
     let root = std::env::current_dir()?.join(root);
     let ws = ProjectWorkspace::discover(root.as_ref())?;
     let project_roots = ws.to_roots();
-    let (mut vfs, roots) = Vfs::new(IncludeRustFiles::from_roots(project_roots.clone()).collect());
+    let (mut vfs, roots) = Vfs::new(
+        project_roots
+            .iter()
+            .map(|pkg_root| {
+                RootEntry::new(
+                    pkg_root.path().clone(),
+                    RustPackageFilterBuilder::default()
+                        .set_member(pkg_root.is_member())
+                        .into_vfs_filter(),
+                )
+            })
+            .collect(),
+    );
     let crate_graph = ws.to_crate_graph(&mut |path: &Path| {
         let vfs_file = vfs.load(path);
         log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
diff --git a/crates/ra_batch/src/vfs_filter.rs b/crates/ra_batch/src/vfs_filter.rs
deleted file mode 100644
index 63bf77704..000000000
--- a/crates/ra_batch/src/vfs_filter.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use ra_project_model::PackageRoot;
-use ra_vfs::{Filter, RelativePath, RootEntry};
-use std::path::PathBuf;
-
-/// `IncludeRustFiles` is used to convert
-/// from `PackageRoot` to `RootEntry` for VFS
-pub struct IncludeRustFiles {
-    root: PackageRoot,
-}
-
-impl IncludeRustFiles {
-    pub fn from_roots<R>(roots: R) -> impl Iterator<Item = RootEntry>
-    where
-        R: IntoIterator<Item = PackageRoot>,
-    {
-        roots.into_iter().map(IncludeRustFiles::from_root)
-    }
-
-    pub fn from_root(root: PackageRoot) -> RootEntry {
-        IncludeRustFiles::from(root).into()
-    }
-
-    #[allow(unused)]
-    pub fn external(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(PackageRoot::new(path, false))
-    }
-
-    pub fn member(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(PackageRoot::new(path, true))
-    }
-}
-
-impl Filter for IncludeRustFiles {
-    fn include_dir(&self, dir_path: &RelativePath) -> bool {
-        self.root.include_dir(dir_path)
-    }
-
-    fn include_file(&self, file_path: &RelativePath) -> bool {
-        self.root.include_file(file_path)
-    }
-}
-
-impl From<PackageRoot> for IncludeRustFiles {
-    fn from(v: PackageRoot) -> IncludeRustFiles {
-        IncludeRustFiles { root: v }
-    }
-}
-
-impl From<IncludeRustFiles> for RootEntry {
-    fn from(v: IncludeRustFiles) -> RootEntry {
-        let path = v.root.path().clone();
-        RootEntry::new(path, Box::new(v))
-    }
-}
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index cec360667..c282d6db8 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -25,6 +25,7 @@ ra_ide_api = { path = "../ra_ide_api" }
 gen_lsp_server = { path = "../gen_lsp_server" }
 ra_project_model = { path = "../ra_project_model" }
 ra_prof = { path = "../ra_prof" }
+ra_vfs_glob = { path = "../ra_vfs_glob" }
 
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 56a263aa5..2ae6300c8 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -4,7 +4,6 @@ mod conv;
 mod main_loop;
 mod markdown;
 mod project_model;
-mod vfs_filter;
 pub mod req;
 pub mod init;
 mod world;
diff --git a/crates/ra_lsp_server/src/vfs_filter.rs b/crates/ra_lsp_server/src/vfs_filter.rs
deleted file mode 100644
index abdc8dbad..000000000
--- a/crates/ra_lsp_server/src/vfs_filter.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use ra_project_model::PackageRoot;

-use ra_vfs::{Filter, RelativePath, RootEntry};

-use std::path::PathBuf;

-

-/// `IncludeRustFiles` is used to convert

-/// from `PackageRoot` to `RootEntry` for VFS

-pub struct IncludeRustFiles {

-    root: PackageRoot,

-}

-

-impl IncludeRustFiles {

-    pub fn from_roots<R>(roots: R) -> impl Iterator<Item = RootEntry>

-    where

-        R: IntoIterator<Item = PackageRoot>,

-    {

-        roots.into_iter().map(IncludeRustFiles::from_root)

-    }

-

-    pub fn from_root(root: PackageRoot) -> RootEntry {

-        IncludeRustFiles::from(root).into()

-    }

-

-    #[allow(unused)]

-    pub fn external(path: PathBuf) -> RootEntry {

-        IncludeRustFiles::from_root(PackageRoot::new(path, false))

-    }

-

-    pub fn member(path: PathBuf) -> RootEntry {

-        IncludeRustFiles::from_root(PackageRoot::new(path, true))

-    }

-}

-

-impl Filter for IncludeRustFiles {

-    fn include_dir(&self, dir_path: &RelativePath) -> bool {

-        self.root.include_dir(dir_path)

-    }

-

-    fn include_file(&self, file_path: &RelativePath) -> bool {

-        self.root.include_file(file_path)

-    }

-}

-

-impl std::convert::From<PackageRoot> for IncludeRustFiles {

-    fn from(v: PackageRoot) -> IncludeRustFiles {

-        IncludeRustFiles { root: v }

-    }

-}

-

-impl std::convert::From<IncludeRustFiles> for RootEntry {

-    fn from(v: IncludeRustFiles) -> RootEntry {

-        let path = v.root.path().clone();

-        RootEntry::new(path, Box::new(v))

-    }

-}

diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index b57cdf925..a8aafe5cb 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -9,13 +9,13 @@ use parking_lot::RwLock;
 use ra_ide_api::{
     Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
 };
-use ra_vfs::{Vfs, VfsChange, VfsFile, VfsRoot};
+use ra_vfs::{RootEntry, Vfs, VfsChange, VfsFile, VfsRoot};
+use ra_vfs_glob::RustPackageFilterBuilder;
 use relative_path::RelativePathBuf;
 
 use crate::{
     main_loop::pending_requests::{CompletedRequest, LatestRequests},
     project_model::ProjectWorkspace,
-    vfs_filter::IncludeRustFiles,
     LspError, Result,
 };
 
@@ -61,9 +61,21 @@ impl WorldState {
         let mut change = AnalysisChange::new();
 
         let mut roots = Vec::new();
-        roots.extend(folder_roots.iter().cloned().map(IncludeRustFiles::member));
+        roots.extend(folder_roots.iter().map(|path| {
+            RootEntry::new(
+                path.clone(),
+                RustPackageFilterBuilder::default().set_member(true).into_vfs_filter(),
+            )
+        }));
         for ws in workspaces.iter() {
-            roots.extend(IncludeRustFiles::from_roots(ws.to_roots()));
+            roots.extend(ws.to_roots().into_iter().map(|pkg_root| {
+                RootEntry::new(
+                    pkg_root.path().clone(),
+                    RustPackageFilterBuilder::default()
+                        .set_member(pkg_root.is_member())
+                        .into_vfs_filter(),
+                )
+            }));
         }
 
         let (mut vfs, vfs_roots) = Vfs::new(roots);
diff --git a/crates/ra_project_model/Cargo.toml b/crates/ra_project_model/Cargo.toml
index 3545d23c9..4fd6c75ef 100644
--- a/crates/ra_project_model/Cargo.toml
+++ b/crates/ra_project_model/Cargo.toml
@@ -7,7 +7,6 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 log = "0.4.5"
 rustc-hash = "1.0"
-relative-path = "0.4.0"
 
 cargo_metadata = "0.8.0"
 
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index c7167046b..55b94b911 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -10,7 +10,6 @@ use std::{
 };
 
 use ra_db::{CrateGraph, Edition, FileId};
-use relative_path::RelativePath;
 use rustc_hash::FxHashMap;
 use serde_json::from_reader;
 
@@ -54,28 +53,6 @@ impl PackageRoot {
     pub fn is_member(&self) -> bool {
         self.is_member
     }
-
-    pub 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
-    }
-
-    pub fn include_file(&self, file_path: &RelativePath) -> bool {
-        file_path.extension() == Some("rs")
-    }
 }
 
 impl ProjectWorkspace {
diff --git a/crates/ra_vfs_glob/Cargo.toml b/crates/ra_vfs_glob/Cargo.toml
new file mode 100644
index 000000000..0390d7da1
--- /dev/null
+++ b/crates/ra_vfs_glob/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+edition = "2018"
+name = "ra_vfs_glob"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+
+[dependencies]
+ra_vfs = "0.2.0"
+globset = "0.4.4"
diff --git a/crates/ra_vfs_glob/src/lib.rs b/crates/ra_vfs_glob/src/lib.rs
new file mode 100644
index 000000000..3e54da5fe
--- /dev/null
+++ b/crates/ra_vfs_glob/src/lib.rs
@@ -0,0 +1,93 @@
+//! `ra_vfs_glob` crate implements exclusion rules for vfs.
+//!
+//! By default, we include only `.rs` files, and skip some know offenders like
+//! `/target` or `/node_modules` altogether.
+//!
+//! It's also possible to add custom exclusion globs.
+
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use ra_vfs::{Filter, RelativePath};
+
+const ALWAYS_IGNORED: &[&str] = &["target/**", "**/node_modules/**", "**/.git/**"];
+const IGNORED_FOR_NON_MEMBERS: &[&str] = &["examples/**", "tests/**", "benches/**"];
+
+pub struct RustPackageFilterBuilder {
+    is_member: bool,
+    exclude: GlobSetBuilder,
+}
+
+impl Default for RustPackageFilterBuilder {
+    fn default() -> RustPackageFilterBuilder {
+        RustPackageFilterBuilder { is_member: false, exclude: GlobSetBuilder::new() }
+    }
+}
+
+impl RustPackageFilterBuilder {
+    pub fn set_member(mut self, is_member: bool) -> RustPackageFilterBuilder {
+        self.is_member = is_member;
+        self
+    }
+    pub fn exclude(mut self, glob: &str) -> Result<RustPackageFilterBuilder, globset::Error> {
+        self.exclude.add(Glob::new(glob)?);
+        Ok(self)
+    }
+    pub fn into_vfs_filter(self) -> Box<dyn Filter> {
+        let RustPackageFilterBuilder { is_member, mut exclude } = self;
+        for &glob in ALWAYS_IGNORED {
+            exclude.add(Glob::new(glob).unwrap());
+        }
+        if !is_member {
+            for &glob in IGNORED_FOR_NON_MEMBERS {
+                exclude.add(Glob::new(glob).unwrap());
+            }
+        }
+        Box::new(RustPackageFilter { exclude: exclude.build().unwrap() })
+    }
+}
+
+struct RustPackageFilter {
+    exclude: GlobSet,
+}
+
+impl Filter for RustPackageFilter {
+    fn include_dir(&self, dir_path: &RelativePath) -> bool {
+        !self.exclude.is_match(dir_path.as_str())
+    }
+
+    fn include_file(&self, file_path: &RelativePath) -> bool {
+        file_path.extension() == Some("rs")
+    }
+}
+
+#[test]
+fn test_globs() {
+    let filter = RustPackageFilterBuilder::default().set_member(true).into_vfs_filter();
+
+    assert!(filter.include_dir(RelativePath::new("src/tests")));
+    assert!(filter.include_dir(RelativePath::new("src/target")));
+    assert!(filter.include_dir(RelativePath::new("tests")));
+    assert!(filter.include_dir(RelativePath::new("benches")));
+
+    assert!(!filter.include_dir(RelativePath::new("target")));
+    assert!(!filter.include_dir(RelativePath::new("src/foo/.git")));
+    assert!(!filter.include_dir(RelativePath::new("foo/node_modules")));
+
+    let filter = RustPackageFilterBuilder::default().set_member(false).into_vfs_filter();
+
+    assert!(filter.include_dir(RelativePath::new("src/tests")));
+    assert!(filter.include_dir(RelativePath::new("src/target")));
+
+    assert!(!filter.include_dir(RelativePath::new("target")));
+    assert!(!filter.include_dir(RelativePath::new("src/foo/.git")));
+    assert!(!filter.include_dir(RelativePath::new("foo/node_modules")));
+    assert!(!filter.include_dir(RelativePath::new("tests")));
+    assert!(!filter.include_dir(RelativePath::new("benches")));
+
+    let filter = RustPackageFilterBuilder::default()
+        .set_member(true)
+        .exclude("src/llvm-project/**")
+        .unwrap()
+        .into_vfs_filter();
+
+    assert!(!filter.include_dir(RelativePath::new("src/llvm-project/clang")));
+}