repalce globset to ignore

- fix from_ignore_list
- remove dir from ignore_list
- add test
- ! and is_none => is_ignore

Author: rchaser53

Cargo.lock

@@ -57,12 +57,12 @@ bytecount = "0.5"
 unicode-width = "0.1.5"
 unicode_categories = "0.1.1"
 dirs = "1.0.4"
-globset = "0.4"
 
 # A noop dependency that changes in the Rust repository, it's a bit of a hack.
 # See the `src/tools/rustc-workspace-hack/README.md` file in `rust-lang/rust`
 # for more information.
 rustc-workspace-hack = "1.0.0"
+ignore = "0.4.6"
 
 [dev-dependencies]
 lazy_static = "1.0.0"

Cargo.toml

@@ -141,7 +141,7 @@ macro_rules! create_config {
                 ConfigWasSet(self)
             }
 
-            fn fill_from_parsed_config(mut self, parsed: PartialConfig, dir: &Path) -> Config {
+            fn fill_from_parsed_config(mut self, parsed: PartialConfig) -> Config {
             $(
                 if let Some(val) = parsed.$i {
                     if self.$i.3 {
@@ -160,7 +160,6 @@ macro_rules! create_config {
             )+
                 self.set_heuristics();
                 self.set_license_template();
-                self.set_ignore(dir);
                 self
             }
 
@@ -287,9 +286,6 @@ macro_rules! create_config {
                 }
             }
 
-            fn set_ignore(&mut self, dir: &Path) {
-                self.ignore.2.add_prefix(dir);
-            }
 
             /// Returns `true` if the config key was explicitly set and is the default value.
             pub fn is_default(&self, key: &str) -> bool {

src/config/config_type.rs

@@ -190,8 +190,7 @@ impl Config {
         let mut file = File::open(&file_path)?;
         let mut toml = String::new();
         file.read_to_string(&mut toml)?;
-        Config::from_toml(&toml, file_path.parent().unwrap())
-            .map_err(|err| Error::new(ErrorKind::InvalidData, err))
+        Config::from_toml(&toml).map_err(|err| Error::new(ErrorKind::InvalidData, err))
     }
 
     /// Resolves the config for input in `dir`.
@@ -253,7 +252,7 @@ impl Config {
         }
     }
 
-    pub(crate) fn from_toml(toml: &str, dir: &Path) -> Result<Config, String> {
+    pub(crate) fn from_toml(toml: &str) -> Result<Config, String> {
         let parsed: ::toml::Value = toml
             .parse()
             .map_err(|e| format!("Could not parse TOML: {}", e))?;
@@ -272,7 +271,7 @@ impl Config {
                 if !err.is_empty() {
                     eprint!("{}", err);
                 }
-                Ok(Config::default().fill_from_parsed_config(parsed_config, dir))
+                Ok(Config::default().fill_from_parsed_config(parsed_config))
             }
             Err(e) => {
                 err.push_str("Error: Decoding config file failed:\n");
@@ -426,8 +425,7 @@ mod test {
 
     #[test]
     fn test_was_set() {
-        use std::path::Path;
-        let config = Config::from_toml("hard_tabs = true", Path::new("")).unwrap();
+        let config = Config::from_toml("hard_tabs = true").unwrap();
 
         assert_eq!(config.was_set().hard_tabs(), true);
         assert_eq!(config.was_set().verbose(), false);

src/config/mod.rs

@@ -14,7 +14,7 @@ use syntax::source_map::{FilePathMapping, SourceMap, Span, DUMMY_SP};
 
 use crate::comment::{CharClasses, FullCodeCharKind};
 use crate::config::{Config, FileName, Verbosity};
-use crate::ignore::IgnorePathSet;
+use crate::ignore_path::IgnorePathSet;
 use crate::issues::BadIssueSeeker;
 use crate::utils::{count_newlines, get_skip_macro_names};
 use crate::visitor::{FmtVisitor, SnippetProvider};
@@ -104,7 +104,8 @@ fn format_project<T: FormatHandler>(
     .visit_crate(&krate)
     .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
     for (path, (module, _)) in files {
-        if (config.skip_children() && path != main_file) || ignore_path_set.is_match(&path) {
+        let should_ignore = !input_is_stdin && ignore_path_set.is_match(&path);
+        if (config.skip_children() && path != main_file) || should_ignore {
             continue;
         }
         should_emit_verbose(input_is_stdin, config, || println!("Formatting {}", path));

src/formatting.rs

@@ -0,0 +1,55 @@
+use ignore::{self, gitignore};
+use std::path::PathBuf;
+
+use crate::config::{FileName, IgnoreList};
+
+pub struct IgnorePathSet {
+    ignore_set: gitignore::Gitignore,
+}
+
+impl IgnorePathSet {
+    pub fn from_ignore_list(ignore_list: &IgnoreList) -> Result<Self, ignore::Error> {
+        let mut ignore_builder = gitignore::GitignoreBuilder::new(PathBuf::from(""));
+
+        for ignore_path in ignore_list {
+            ignore_builder.add_line(None, ignore_path.to_str().unwrap())?;
+        }
+
+        Ok(IgnorePathSet {
+            ignore_set: ignore_builder.build()?,
+        })
+    }
+
+    pub fn is_match(&self, file_name: &FileName) -> bool {
+        match file_name {
+            FileName::Stdin => false,
+            FileName::Real(p) => self
+                .ignore_set
+                .matched_path_or_any_parents(p, false)
+                .is_ignore(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::config::{Config, FileName};
+    use crate::ignore_path::IgnorePathSet;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_ignore_path_set() {
+        let config = Config::from_toml(
+            "ignore = [
+            \"foo.rs\",
+            \"bar_dir/*\",
+        ]",
+        )
+        .unwrap();
+        let ignore_path_set = IgnorePathSet::from_ignore_list(&config.ignore()).unwrap();
+
+        assert!(ignore_path_set.is_match(&FileName::Real(PathBuf::from("src/foo.rs"))));
+        assert!(ignore_path_set.is_match(&FileName::Real(PathBuf::from("bar_dir/baz.rs"))));
+        assert!(!ignore_path_set.is_match(&FileName::Real(PathBuf::from("src/bar.rs"))));
+    }
+}

src/ignore.rs

@@ -20,6 +20,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 
 use failure::Fail;
+use ignore;
 use syntax::{ast, parse::DirectoryOwnership};
 
 use crate::comment::LineClasses;
@@ -46,7 +47,7 @@ mod comment;
 pub(crate) mod config;
 mod expr;
 pub(crate) mod formatting;
-mod ignore;
+mod ignore_path;
 mod imports;
 mod issues;
 mod items;
@@ -113,7 +114,7 @@ pub enum ErrorKind {
     LostComment,
     /// Invalid glob pattern in `ignore` configuration option.
     #[fail(display = "Invalid glob pattern found in ignore list: {}", _0)]
-    InvalidGlobPattern(globset::Error),
+    InvalidGlobPattern(ignore::Error),
 }
 
 impl ErrorKind {

src/ignore_path.rs

@@ -560,7 +560,7 @@ fn get_config(config_file: Option<&Path>) -> Config {
         .read_to_string(&mut def_config)
         .expect("Couldn't read config");
 
-    Config::from_toml(&def_config, Path::new("tests/config/")).expect("invalid TOML")
+    Config::from_toml(&def_config).expect("invalid TOML")
 }
 
 // Reads significant comments of the form: `// rustfmt-key: value` into a hash map.