The .gitignore file is now searched for recursively.

Removed a warning if .gitignore is missing.

src/cmd/watch.rs

@@ -53,10 +53,33 @@ fn remove_ignored_files(book_root: &PathBuf, paths: &[PathBuf]) -> Vec<PathBuf>
         return vec![];
     }
 
-    let gitignore_path = book_root.join(".gitignore");
+    match find_gitignore(book_root) {
-
+        Some(gitignore_path) => {
             match gitignore::File::new(gitignore_path.as_path()) {
-        Ok(exclusion_checker) => paths
+                Ok(exclusion_checker) => filter_ignored_files(exclusion_checker, paths),
+                Err(_) => {
+                    // We're unable to read the .gitignore file, so we'll silently allow everything.
+                    // Please see discussion: https://github.com/rust-lang-nursery/mdBook/pull/1051
+                    paths.iter().map(|path| path.to_path_buf()).collect()
+                }
+            }
+        }
+        None => {
+            // There is no .gitignore file.
+            paths.iter().map(|path| path.to_path_buf()).collect()
+        }
+    }
+}
+
+fn find_gitignore(book_root: &PathBuf) -> Option<PathBuf> {
+    book_root
+        .ancestors()
+        .map(|p| p.join(".gitignore"))
+        .find(|p| p.exists())
+}
+
+fn filter_ignored_files(exclusion_checker: gitignore::File, paths: &[PathBuf]) -> Vec<PathBuf> {
+    paths
         .iter()
         .filter(|path| match exclusion_checker.is_excluded(path) {
             Ok(exclude) => !exclude,
@@ -69,15 +92,7 @@ fn remove_ignored_files(book_root: &PathBuf, paths: &[PathBuf]) -> Vec<PathBuf>
             }
         })
         .map(|path| path.to_path_buf())
-            .collect(),
+        .collect()
-        Err(error) => {
-            warn!(
-                "Unable to read gitignore file at {:?} file: {:?}. All files will be allowed.",
-                gitignore_path, error
-            );
-            paths.iter().map(|path| path.to_path_buf()).collect()
-        }
-    }
 }
 
 /// Calls the closure when a book source file is changed, blocking indefinitely.