feat(core): ignore files/directories in .gitignore

Author: kkharji

Cargo.lock

@@ -28,3 +28,8 @@ tracing-appender = "0.2.1"
 notify = "5.0.0-pre.13"
 dirs = "4.0"
 wax = "0.4.0"
+
+# WARN: api totally changed on later versions.
+# It would make sense to create custom function
+gitignore = "1.0.7"
+

shared/Cargo.toml

@@ -1,4 +1,3 @@
-use crate::tracing::info;
 use crate::workspace::Workspace;
 use anyhow::{Ok, Result};
 use libproc::libproc::proc_pid;

shared/src/state.rs

@@ -1,12 +1,11 @@
 use crate::state::SharedState;
 use crate::Command;
-use notify::{Error, Event, RecommendedWatcher, RecursiveMode, Watcher};
+use notify::{recommended_watcher, Error, Event, RecursiveMode, Watcher};
 use std::path::Path;
 use std::result::Result;
-use std::sync::Arc;
-use tokio::sync::{mpsc, Mutex};
-use tracing::{debug, info, trace};
-use wax::{Glob, Pattern};
+use std::sync::{Arc, Mutex};
+use tokio::sync::mpsc;
+use tracing::{debug, trace};
 
 // TODO: Stop handle
 
@@ -42,9 +41,9 @@ pub async fn update(state: SharedState, _msg: Command) {
 ///
 /// This will compare last_seen with path, updates `last_seen` if not match,
 /// else returns true.
-async fn should_ignore(last_seen: Arc<Mutex<String>>, path: &str) -> bool {
+fn is_seen(last_seen: Arc<Mutex<String>>, path: &str) -> bool {
     let path = path.to_string();
-    let mut last_seen = last_seen.lock().await;
+    let mut last_seen = last_seen.lock().unwrap();
     if last_seen.to_string() == path {
         return true;
     } else {
@@ -54,34 +53,51 @@ async fn should_ignore(last_seen: Arc<Mutex<String>>, path: &str) -> bool {
 }
 
 fn new(state: SharedState, root: String) -> tokio::task::JoinHandle<anyhow::Result<()>> {
-    // NOTE: should watch for registerd directories?
-    let ignore = wax::any::<Glob, _>(["**/.git/**", "**/*.xcodeproj/**", "**/.*"]).unwrap();
+    type NotifyResult = Result<Event, Error>;
+    use gitignore::File;
+    use wax::{any, Glob, Pattern};
 
     tokio::spawn(async move {
         let (tx, mut rx) = mpsc::channel(100);
 
-        let mut watcher = RecommendedWatcher::new(move |res: Result<Event, Error>| {
+        let custom_ignore = any::<Glob, _>(["**/.git/**", "**/*.xcodeproj/**", "**/.*"]).unwrap();
+        let root_path = Path::new(&root);
+        let gitignore_path = root_path.join(".gitignore");
+
+        // HACK: To ignore seen paths.
+        let last_seen = Arc::new(Mutex::new(String::default()));
+
+        // NOTE: outdate API
+        let gitignore = Arc::new(Mutex::new(File::new(&gitignore_path).unwrap()));
+
+        recommended_watcher(move |res: NotifyResult| {
             if res.is_ok() {
                 tx.blocking_send(res.unwrap()).unwrap()
             };
-        })?;
-
-        watcher.watch(Path::new(&root), RecursiveMode::Recursive)?;
-
-        // HACK: ignore seen paths.
-        let last_seen = Arc::new(Mutex::new(String::default()));
+        })?
+        .watch(root_path, RecursiveMode::Recursive)?;
 
         while let Some(event) = rx.recv().await {
             let state = state.clone();
             let path = match event.paths.get(0) {
-                Some(p) => match p.clone().to_str() {
-                    Some(s) => s.to_string(),
-                    None => continue,
-                },
+                Some(p) => p.clone(),
+                None => continue,
+            };
+
+            let path_string = match path.to_str() {
+                Some(s) => s.to_string(),
                 None => continue,
             };
 
-            if should_ignore(last_seen.clone(), &path).await || ignore.is_match(&*path) {
+            if is_seen(last_seen.clone(), &path_string)
+                || custom_ignore.is_match(&*path_string)
+                || !gitignore
+                    .lock()
+                    .unwrap()
+                    .included_files()
+                    .unwrap()
+                    .contains(&path)
+            {
                 continue;
             }
 

shared/src/watch.rs

@@ -1,8 +1,7 @@
 use crate::project::{Project, Target, TargetMap};
 use anyhow::{bail, Ok, Result};
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
-use ::tracing::{debug, info, trace};
 use libproc::libproc::proc_pid;
 use notify::EventKind;
 use std::process::Stdio;
@@ -34,7 +33,7 @@ impl Workspace {
             Project::new_from_project_yml(path).await?
         };
 
-        info!("[New::{}]: {:?}", project.name(), root);
+        tracing::info!("[New::{}]: {:?}", project.name(), root);
 
         Ok(Self {
             root,
@@ -53,7 +52,7 @@ impl Workspace {
         let name = self.project.name();
         self.clients.retain(|&pid| {
             if proc_pid::name(pid).is_err() {
-                debug!("[Update::{}]: Remove Client: {pid}", name);
+                tracing::debug!("[Update::{}]: Remove Client: {pid}", name);
                 false
             } else {
                 true
@@ -66,7 +65,7 @@ impl Workspace {
         // Remove no longer active clients
         self.update_clients();
         // NOTE: Implicitly assuming that pid is indeed a valid pid
-        debug!("[Update::{}] Add Client: {pid}", self.name());
+        tracing::debug!("[Update::{}] Add Client: {pid}", self.name());
         self.clients.push(pid)
     }
 
@@ -98,7 +97,7 @@ impl Workspace {
     }
 
     /// Regenerate compiled commands and xcodeGen if project.yml exists
-    pub async fn on_dirctory_change(&self, _path: String, _event: EventKind) -> Result<()> {
+    pub async fn on_dirctory_change(&self, _path: PathBuf, _event: EventKind) -> Result<()> {
         if self.is_xcodegen_project() {
             /*
                 FIXME: make xCodeGen binary path configurable.
@@ -119,7 +118,7 @@ impl Workspace {
                 .expect("Failed to run xcodeGen.");
 
             if xcodegen.success() {
-                info!("Generated {}.xcodeproj", self.name());
+                tracing::info!("Generated {}.xcodeproj", self.name());
             }
         }