feat(daemon): build configuration

src/daemon/bin.rs

@@ -40,11 +40,7 @@ async fn main() -> anyhow::Result<()> {
                     }
                     Ok(req) => {
                         if let Err(e) = req.message.handle(state.clone()).await {
-                            return tracing::error!(
-                                "[Failure]: Cause: ({:?}), Message: {:?}",
-                                e,
-                                req
-                            );
+                            return tracing::error!("[Failure]: Cause: ({:?})", e);
                         };
                     }
                 };

src/daemon/message.rs

@@ -25,7 +25,7 @@ pub enum Message {
 
 #[cfg(feature = "daemon")]
 impl Message {
-    pub async fn handle(&self, state: super::DaemonState) -> anyhow::Result<()> {
+    pub async fn handle(self, state: super::DaemonState) -> anyhow::Result<()> {
         match self {
             Self::Build(c) => Handler::handle(c, state).await,
             Self::Run(c) => Handler::handle(c, state).await,
@@ -40,16 +40,16 @@ impl Message {
 /// Requirement for daemon handling request
 #[cfg(feature = "daemon")]
 #[async_trait::async_trait]
-pub trait Handler: std::fmt::Debug {
-    async fn handle(&self, _state: super::DaemonState) -> anyhow::Result<()> {
+pub trait Handler: std::fmt::Debug + Sized {
+    async fn handle(self, _state: super::DaemonState) -> anyhow::Result<()> {
         tracing::error!("Not Implemented! {:#?}", self);
         Ok(())
     }
 }
 
 /// Requirement for daemon sending request
 #[cfg(feature = "lua")]
-pub trait Requestor<'a, M: Into<Request> + std::fmt::Debug + FromLua<'a>> {
+pub trait Requester<'a, M: Into<Request> + std::fmt::Debug + FromLua<'a>> {
     fn request(lua: &Lua, msg: M) -> LuaResult<()> {
         Self::pre(lua, &msg)?;
         Daemon::execute(lua, msg)

src/daemon/requests.rs

@@ -21,7 +21,7 @@ use crate::util::mlua::LuaExtension;
 use mlua::prelude::*;
 
 #[cfg(feature = "mlua")]
-use super::Requestor;
+use super::Requester;
 
 #[cfg(feature = "daemon")]
 use async_stream::stream;

src/daemon/requests/build.rs

@@ -1,29 +1,31 @@
 use super::*;
+use crate::types::BuildConfiguration;
 use std::fmt::Debug;
 
 /// Build a project.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Build {
-    pub pid: i32,
-    pub root: String,
-    pub target: Option<String>,
-    pub configuration: Option<String>,
-    pub scheme: Option<String>,
+    pub client: Client,
+    pub config: BuildConfiguration,
 }
 
 #[cfg(feature = "lua")]
-impl<'a> Requestor<'a, Build> for Build {}
+impl<'a> Requester<'a, Build> for Build {
+    fn pre(lua: &Lua, msg: &Build) -> LuaResult<()> {
+        lua.trace(&format!("{:?}", msg.config))
+    }
+}
 
 #[cfg(feature = "daemon")]
 #[async_trait]
 impl Handler for Build {
-    async fn handle(&self, state: DaemonState) -> Result<()> {
+    async fn handle(self, state: DaemonState) -> Result<()> {
         tracing::debug!("Handling build request..");
 
         let state = state.lock().await;
-        let ws = state.get_workspace(&self.root)?;
-        let nvim = ws.get_client(&self.pid)?;
-        let mut logs = ws.project.xcodebuild(&["build"]).await?;
+        let ws = state.get_workspace(&self.client.root)?;
+        let nvim = ws.get_client(&self.client.pid)?;
+        let mut logs = ws.project.xcodebuild(&["build"], self.config).await?;
         let stream = Box::pin(stream! {
             while let Some(step) = logs.next().await {
                 let line = match step {
@@ -50,11 +52,8 @@ impl<'a> FromLua<'a> for Build {
     fn from_lua(lua_value: LuaValue<'a>, _lua: &'a Lua) -> LuaResult<Self> {
         if let LuaValue::Table(table) = lua_value {
             Ok(Self {
-                pid: table.get("pid")?,
-                root: table.get("root")?,
-                target: table.get("target")?,
-                configuration: table.get("configuration")?,
-                scheme: table.get("scheme")?,
+                client: table.get("client")?,
+                config: table.get("config")?,
             })
         } else {
             Err(LuaError::external("Fail to deserialize Build"))

src/daemon/requests/drop.rs

@@ -9,7 +9,7 @@ pub struct Drop {
 #[cfg(feature = "daemon")]
 #[async_trait]
 impl Handler for Drop {
-    async fn handle(&self, state: DaemonState) -> Result<()> {
+    async fn handle(self, state: DaemonState) -> Result<()> {
         tracing::trace!("{:?}", self);
         let (root, pid) = (&self.client.root, self.client.pid);
         let mut state = state.lock().await;
@@ -18,7 +18,7 @@ impl Handler for Drop {
 }
 
 #[cfg(feature = "lua")]
-impl<'a> Requestor<'a, Drop> for Drop {
+impl<'a> Requester<'a, Drop> for Drop {
     fn pre(_lua: &Lua, _msg: &Drop) -> LuaResult<()> {
         Ok(())
     }

src/daemon/requests/project_info.rs

@@ -7,12 +7,12 @@ pub struct ProjectInfo {
 }
 
 #[cfg(feature = "lua")]
-impl<'a> Requestor<'a, ProjectInfo> for ProjectInfo {}
+impl<'a> Requester<'a, ProjectInfo> for ProjectInfo {}
 
 #[cfg(feature = "daemon")]
 #[async_trait]
 impl Handler for ProjectInfo {
-    async fn handle(&self, state: DaemonState) -> Result<()> {
+    async fn handle(self, state: DaemonState) -> Result<()> {
         let (root, pid) = (&self.client.root, self.client.pid);
         tracing::info!("Getting info for {}", root);
 

src/daemon/requests/register.rs

@@ -8,7 +8,7 @@ pub struct Register {
 }
 
 #[cfg(feature = "lua")]
-impl<'a> Requestor<'a, Register> for Register {
+impl<'a> Requester<'a, Register> for Register {
     fn pre(lua: &Lua, msg: &Register) -> LuaResult<()> {
         lua.trace(&format!("Registered client ({})", msg.client.pid))
     }
@@ -17,7 +17,7 @@ impl<'a> Requestor<'a, Register> for Register {
 #[cfg(feature = "daemon")]
 #[async_trait]
 impl Handler for Register {
-    async fn handle(&self, state: DaemonState) -> anyhow::Result<()> {
+    async fn handle(self, state: DaemonState) -> anyhow::Result<()> {
         tracing::trace!("{:?}", self);
         let mut state = state.lock().await;
         let client = &self.client;

src/daemon/requests/rename_file.rs

@@ -7,13 +7,13 @@ pub struct RenameFile {
 }
 
 #[cfg(feature = "lua")]
-impl<'a> Requestor<'a, RenameFile> for RenameFile {}
+impl<'a> Requester<'a, RenameFile> for RenameFile {}
 
 // TODO: Implement file rename along with it's main class if any.
 #[cfg(feature = "daemon")]
 #[async_trait]
 impl Handler for RenameFile {
-    async fn handle(&self, _state: DaemonState) -> Result<()> {
+    async fn handle(self, _state: DaemonState) -> Result<()> {
         tracing::info!("Reanmed command");
         Ok(())
     }

src/daemon/requests/run.rs

@@ -8,7 +8,7 @@ pub struct Run {
 }
 
 #[cfg(feature = "lua")]
-impl<'a> Requestor<'a, Run> for Run {}
+impl<'a> Requester<'a, Run> for Run {}
 
 // TODO: Implement run command
 //
@@ -18,7 +18,7 @@ impl<'a> Requestor<'a, Run> for Run {}
 #[cfg(feature = "daemon")]
 #[async_trait::async_trait]
 impl Handler for Run {
-    async fn handle(&self, _state: DaemonState) -> Result<()> {
+    async fn handle(self, _state: DaemonState) -> Result<()> {
         tracing::info!("Run command");
         Ok(())
     }

src/daemon/state/project.rs

@@ -1,6 +1,6 @@
+use crate::types::BuildConfiguration;
 #[cfg(feature = "serial")]
 use serde::{Deserialize, Serialize};
-
 use std::collections::HashMap;
 use std::path::PathBuf;
 
@@ -86,18 +86,20 @@ impl Project {
            ```
         */
 
-        self.xcodebuild(&["build"]).await
+        self.xcodebuild(&["build"], Default::default()).await
     }
 
     #[cfg(feature = "daemon")]
     pub async fn xcodebuild<'a, I: 'a, S: 'a>(
         &'a self,
         args: I,
+        _config: BuildConfiguration,
     ) -> anyhow::Result<impl tokio_stream::Stream<Item = xcodebuild::parser::Step> + 'a>
     where
         I: IntoIterator<Item = S>,
         S: AsRef<std::ffi::OsStr>,
     {
+        // TOOD: Process configuration
         xcodebuild::runner::spawn(&self.root, args).await
     }
 

src/lib.rs

@@ -10,4 +10,7 @@ pub mod xcodegen;
 #[cfg(any(feature = "daemon", feature = "mlua"))]
 pub mod daemon;
 
+#[cfg(feature = "serial")]
+pub mod types;
+
 pub mod util;

src/types.rs

@@ -0,0 +1,72 @@
+#[cfg(feature = "lua")]
+use mlua::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum XConfiguration {
+    #[default]
+    Debug,
+    Release,
+    Custom(String),
+}
+
+#[cfg(feature = "lua")]
+impl<'a> FromLua<'a> for XConfiguration {
+    fn from_lua(lua_value: LuaValue<'a>, _lua: &'a Lua) -> LuaResult<Self> {
+        if let LuaValue::String(config) = lua_value {
+            let value = config.to_str()?;
+            Ok(match value {
+                "debug" | "Debug" => Self::Debug,
+                "release" | "Release" => Self::Release,
+                _ => Self::Custom(value.to_string()),
+            })
+        } else if matches!(lua_value, LuaValue::Nil) {
+            Ok(Self::Debug)
+        } else {
+            Err(LuaError::external("Expected a table got XConfiguration"))
+        }
+    }
+}
+
+/// Xcode Scheme
+///
+/// An Xcode scheme defines a collection of targets to build, a configuration to use when building,
+/// and a collection of tests to execute.
+pub type XScheme = String;
+
+/// Xcode Target
+///
+/// A target specifies a product to build and contains the instructions for building the product
+/// from a set of files in a project or workspace.
+pub type XTarget = String;
+
+/// Fields required to build a project
+#[derive(Default, Debug, Serialize, Deserialize)]
+pub struct BuildConfiguration {
+    /// TODO(nvim): make build config sysroot default to tmp in auto-build
+    pub sysroot: Option<String>,
+    /// Target to build
+    pub target: Option<XTarget>,
+    /// Configuration to build with, default Debug
+    #[serde(default)]
+    pub configuration: XConfiguration,
+    /// Scheme to build with
+    pub scheme: Option<XScheme>,
+}
+
+#[cfg(feature = "lua")]
+impl<'a> FromLua<'a> for BuildConfiguration {
+    fn from_lua(lua_value: LuaValue<'a>, _lua: &'a Lua) -> LuaResult<Self> {
+        if let LuaValue::Table(table) = lua_value {
+            Ok(Self {
+                sysroot: table.get("sysroot")?,
+                target: table.get("target")?,
+                configuration: table.get("configuration")?,
+                scheme: table.get("scheme")?,
+            })
+        } else {
+            Ok(BuildConfiguration::default())
+        }
+    }
+}