feat(core): generate compile commands on dir change

Author: kkharji

Cargo.lock

@@ -9,6 +9,7 @@ anyhow = "^1.0.42"
 
 # Serialization
 serde = { version = "1.0", features = ["derive"]}
+serde_json = "1.0.79"
 serde_yaml = "0.8.23"
 
 # Get processes, processors, disks, components and networks
@@ -28,6 +29,9 @@ tracing-appender = "0.2.1"
 notify = "5.0.0-pre.13"
 dirs = "4.0"
 wax = "0.4.0"
+regex = "1.5"
+lazy_static = "1.4.0"
+shell-words = "1.1.0"
 
 # WARN: api totally changed on later versions.
 # It would make sense to create custom function

shared/Cargo.toml

@@ -4,6 +4,7 @@ pub mod state;
 
 mod command;
 mod project;
+mod xcode;
 pub use command::*;
 pub mod tracing;
 pub mod watch;

shared/src/lib.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
-use anyhow::Context;
+use crate::xcode;
+use anyhow::{Context, Result};
 use serde::Deserialize;
 use std::path::PathBuf;
 use tokio::fs;
@@ -30,20 +31,24 @@ pub struct Project {
     /// XcodeBase local configuration
     #[serde(rename(deserialize = "XcodeBase"))]
     xcode_base: LocalConfig,
+    /// Root directory
+    #[serde(skip)]
+    root: PathBuf,
 }
 
 impl Project {
-    pub async fn new_from_project_yml(path: PathBuf) -> anyhow::Result<Self> {
+    pub async fn new_from_project_yml(root: PathBuf, path: PathBuf) -> Result<Self> {
         let content = fs::read_to_string(path).await?;
-        serde_yaml::from_str(&content).context("Unable to parse project.yaml")
+        let mut project: Project =
+            serde_yaml::from_str(&content).context("Unable to parse project.yaml")?;
+        project.root = root;
+        Ok(project)
     }
 
     pub fn config(&self) -> &LocalConfig {
         &self.xcode_base
     }
-}
 
-impl Project {
     /// Get a reference to the project's name.
     pub fn name(&self) -> &str {
         self.name.as_ref()
@@ -53,4 +58,34 @@ impl Project {
     pub fn targets(&self) -> &TargetMap {
         &self.targets
     }
+
+    /// Build project with clean and return build log
+    pub async fn fresh_build(&self) -> Result<Vec<String>> {
+        /*
+           TODO: Find away to get commands ran without doing xcodebuild clean
+
+           Right now, in order to produce compiled commands and for `xcodebuild build` to spit out ran
+           commands, we need to first run xcodebuild clean.
+
+           NOTE: This far from possilbe after some research
+        */
+        xcode::clean(&self.root, &["-verbose"]).await?;
+
+        /*
+           TODO: Support overriding xcodebuild arguments
+
+           Not sure how important is this, but ideally I'd like to be able to add extra arguments for
+           when generating compiled commands, as well as doing actual builds and runs.
+
+           ```yaml
+           XcodeBase:
+           buildArguments: [];
+           compileArguments: [];
+           runArguments: [];
+           ```
+        */
+        xcode::build(&self.root, &["-verbose"]).await
+    }
 }
+
+impl Project {}

shared/src/project.rs

@@ -174,13 +174,15 @@ fn new(state: SharedState, root: String) -> tokio::task::JoinHandle<anyhow::Resu
 
             trace!("[NewEvent] {:#?}", &event);
 
-            let state = state.lock().await;
-            let workspace = match state.workspaces.get(&root) {
-                Some(w) => w,
+            // let mut state = state.lock().await;
+
+            match state.lock().await.workspaces.get_mut(&root) {
+                Some(w) => {
+                    w.on_dirctory_change(path, event.kind).await?;
+                }
+                // NOTE: should stop watch here
                 None => continue,
             };
-
-            workspace.on_dirctory_change(path, event.kind).await?;
         }
         Ok(())
     })

shared/src/watch.rs

@@ -2,9 +2,13 @@ use crate::project::{Project, Target, TargetMap};
 use anyhow::{bail, Ok, Result};
 use std::path::PathBuf;
 
+use crate::xcode;
 use libproc::libproc::proc_pid;
 use notify::EventKind;
+use serde_json::json;
 use std::process::Stdio;
+use tokio::fs;
+use tokio::io::AsyncWriteExt;
 use tokio::process::Command;
 
 /// Managed Workspace
@@ -20,7 +24,7 @@ pub struct Workspace {
 
 impl Workspace {
     /// Create new workspace from a path representing project root.
-    /// TODO: Support setting up projects with .xproj as well as xcworkspace
+    /// TODO: Support projects with .xproj as well as xcworkspace
     pub async fn new(root: &str) -> Result<Self> {
         let root = PathBuf::from(root);
 
@@ -30,10 +34,10 @@ impl Workspace {
                 bail!("project.yaml doesn't exist in '{:?}'", root)
             }
 
-            Project::new_from_project_yml(path).await?
+            Project::new_from_project_yml(root.clone(), path).await?
         };
 
-        tracing::info!("[New::{}]: {:?}", project.name(), root);
+        tracing::info!("Managing [{}] {:?}", project.name(), root);
 
         Ok(Self {
             root,
@@ -52,7 +56,7 @@ impl Workspace {
         let name = self.project.name();
         self.clients.retain(|&pid| {
             if proc_pid::name(pid).is_err() {
-                tracing::debug!("[Update::{}]: Remove Client: {pid}", name);
+                tracing::debug!("[{}]: Remove Client: {pid}", name);
                 false
             } else {
                 true
@@ -65,7 +69,7 @@ impl Workspace {
         // Remove no longer active clients
         self.update_clients();
         // NOTE: Implicitly assuming that pid is indeed a valid pid
-        tracing::debug!("[Update::{}] Add Client: {pid}", self.name());
+        tracing::debug!("[{}] Add Client: {pid}", self.name());
         self.clients.push(pid)
     }
 
@@ -86,45 +90,65 @@ impl Workspace {
         self.project.targets().get(target_name)
     }
 
-    /// Checks whether current workspace is xcodegen project.
-    pub fn is_xcodegen_project(&self) -> bool {
-        /*
-            TODO: support otherways to identify xcodegen project
-            Some would have xcodegen config as json file or
-            have different location to where they store xcodegen project config.
-        */
-        self.root.join("project.yml").exists()
-    }
-
     /// Regenerate compiled commands and xcodeGen if project.yml exists
-    pub async fn on_dirctory_change(&self, _path: PathBuf, _event: EventKind) -> Result<()> {
+    pub async fn on_dirctory_change(&mut self, path: PathBuf, _event: EventKind) -> Result<()> {
         if self.is_xcodegen_project() {
-            /*
-                FIXME: make xCodeGen binary path configurable.
-
-                Current implementation will not work unless the user has xcodeGen located in
-                `~/.mint/bin/xcodegen`. Should either make it configurable as well as support a
-                number of paths by default.
-            */
-            let xcodegen_path = dirs::home_dir().unwrap().join(".mint/bin/xcodegen");
-            let xcodegen = Command::new(xcodegen_path)
-                .current_dir(self.root.clone())
-                .stdout(Stdio::null())
-                .arg("generate")
-                .spawn()
-                .expect("Failed to start xcodeGen.")
-                .wait()
-                .await
-                .expect("Failed to run xcodeGen.");
-
-            if xcodegen.success() {
-                tracing::info!("Generated {}.xcodeproj", self.name());
+            let is_config_file = path.file_name().unwrap().eq("project");
+            self.update_xcodeproj(is_config_file).await?;
+        }
+
+        xcode::ensure_server_config_file(&self.root).await?;
+        xcode::update_compiled_commands(&self.root, self.project.fresh_build().await?).await?;
+
+        Ok(())
+    }
+
+    /// Update .compile commands
+    pub async fn update_xcodeproj(&mut self, update_config: bool) -> Result<()> {
+        /*
+           FIXME: make xCodeGen binary path configurable.
+
+           Current implementation will not work unless the user has xcodeGen located in
+           `~/.mint/bin/xcodegen`. Should either make it configurable as well as support a
+           number of paths by default.
+        */
+        let xcodegen_path = dirs::home_dir().unwrap().join(".mint/bin/xcodegen");
+        let xcodegen = Command::new(xcodegen_path)
+            .current_dir(self.root.clone())
+            .stdout(Stdio::null())
+            .arg("generate")
+            .spawn()
+            .expect("Failed to start xcodeGen.")
+            .wait()
+            .await
+            .expect("Failed to run xcodeGen.");
+
+        if xcodegen.success() {
+            tracing::info!("Updated {}.xcodeproj", self.name());
+            if update_config {
+                tracing::debug!("Updated internal state.{}.project", self.name());
+                let path = self.xcodegen_config_path();
+                self.project = Project::new_from_project_yml(self.root.clone(), path).await?;
             }
         }
 
         Ok(())
     }
 
+    /// Checks whether current workspace is xcodegen project.
+    pub fn is_xcodegen_project(&self) -> bool {
+        self.xcodegen_config_path().exists()
+    }
+
+    pub fn xcodegen_config_path(&self) -> PathBuf {
+        /*
+           TODO: support otherways to identify xcodegen project
+
+           Some would have xcodegen config as json file or
+           have different location to where they store xcodegen project config.
+        */
+        self.root.join("project.yml")
+    }
     pub fn get_ignore_patterns(&self) -> Option<Vec<String>> {
         if self.is_xcodegen_project() {
             return Some(self.project.config().ignore.clone());