ref(build): include watch option instead of special request

Author: kkharji

lua/xbase/lib.rs

@@ -18,9 +18,8 @@ fn libxbase(l: &Lua) -> LuaResult<LuaTable> {
         ("ensure", l.create_function(ensure)?),
         ("register", fun!(Register, l)),
         ("drop", fun!(Drop, l)),
-        ("build", fun!(Build, l)),
+        ("build", fun!(BuildRequest, l)),
         ("run", fun!(RunRequest, l)),
-        ("watch_target", fun!(WatchTarget, l)),
     ])
 }
 

lua/xbase/pickers.lua

@@ -7,7 +7,6 @@ local picker = require("telescope.pickers").new
 local sorter = require("telescope.config").values.generic_sorter
 local maker = require("telescope.pickers.entry_display").create
 local xbase = require "xbase"
-local watch = require "xbase.watch"
 local themes = require "telescope.themes"
 local util = require "xbase.util"
 
@@ -19,8 +18,6 @@ local mappings = function(_, _)
 
     if entry.command == "Build" then
       xbase.build(entry)
-    elseif entry.command == "Watch" then
-      xbase.watch(entry)
     elseif entry.command == "Run" then
       xbase.run(entry)
     end
@@ -40,13 +37,11 @@ local insert_entry = function(acc, picker, command, target, configuration, devic
   end
 
   if picker == "Watch" then
-    item.command = "Watch"
-
-    if watch.is_watching(item.config, command) then
+    if util.is_watching(item.config, command) then
       item.ops = "Stop"
       item.kind = command
     else
-      item.ops = "Start"
+      item.ops = "Watch"
       item.kind = command
     end
   end

lua/xbase/util.lua

@@ -1,3 +1,4 @@
+local config = require("xbase.config").values
 local M = {}
 ---@param platform Platform
 local get_runners = function(platform)
@@ -43,4 +44,55 @@ M.get_targets_runners = function(project)
   return targets
 end
 
+M.is_watching = function(config, command)
+  local root = vim.loop.cwd()
+  local watching = vim.g.xbase.watcher[root]
+  local key = string.format("%s:%s:xcodebuild -configuration %s", root, command, config.configuration)
+
+  if config.sysroot then
+    key = key .. " -sysroot " .. config.sysroot
+  end
+
+  if config.scheme then
+    key = key .. " -scheme " .. config.scheme
+  end
+
+  key = key .. " -target " .. config.target
+
+  return watching[key] ~= nil
+end
+
+M.feline_provider = function()
+  return {
+    provider = function(_)
+      icon = {}
+      --- TODO(nvim): only show build status in xcode supported files?
+      local config = config.statusline
+      local status = vim.g.xbase_watch_build_status
+
+      if status == "running" then
+        icon.str = config.running.icon
+        icon.hl = { fg = config.running.color }
+      elseif status == "success" then
+        icon.str = config.success.icon
+        icon.hl = { fg = config.success.color }
+      elseif status == "failure" then
+        icon.str = config.failure.icon
+        icon.hl = { fg = config.failure.color }
+      else
+        icon.str = " "
+      end
+
+      if icon.str == " " then
+        return " ", icon
+      else
+        icon.str = " [" .. icon.str .. " xcode]"
+        return " ", icon
+      end
+    end,
+
+    hl = {},
+  }
+end
+
 return M

lua/xbase/watch.lua

@@ -20,24 +20,22 @@ impl Request {
 /// Daemon Message
 #[derive(Debug, Serialize, Deserialize)]
 pub enum Message {
-    Build(Build),
+    BuildRequest(BuildRequest),
     RunRequest(RunRequest),
     Register(Register),
     Drop(Drop),
     RenameFile(RenameFile),
-    WatchTarget(WatchTarget),
 }
 
 #[cfg(feature = "daemon")]
 impl Message {
     pub async fn handle(self) -> crate::Result<()> {
         match self {
-            Self::Build(c) => Handler::handle(c).await,
+            Self::BuildRequest(c) => Handler::handle(c).await,
             Self::RunRequest(c) => Handler::handle(c).await,
             Self::RenameFile(c) => Handler::handle(c).await,
             Self::Register(c) => Handler::handle(c).await,
             Self::Drop(c) => Handler::handle(c).await,
-            Self::WatchTarget(c) => Handler::handle(c).await,
         }
     }
 }

src/daemon/message.rs

@@ -3,14 +3,12 @@ mod drop;
 mod register;
 mod rename_file;
 mod run;
-mod watch_target;
 
 pub use build::*;
 pub use drop::*;
 pub use register::*;
 pub use rename_file::*;
 pub use run::*;
-pub use watch_target::*;
 
 #[cfg(feature = "mlua")]
 use crate::util::mlua::LuaExtension;
@@ -44,9 +42,58 @@ macro_rules! convertable {
         }
     };
 }
-convertable!(Build);
+convertable!(BuildRequest);
 convertable!(RunRequest);
 convertable!(Register);
 convertable!(RenameFile);
 convertable!(Drop);
-convertable!(WatchTarget);
+
+#[derive(
+    Default, Clone, Debug, serde::Serialize, serde::Deserialize, strum::Display, strum::EnumString,
+)]
+
+pub enum RequestOps {
+    Watch,
+    Stop,
+    #[default]
+    Once,
+}
+
+impl RequestOps {
+    /// Returns `true` if the request kind is [`Watch`].
+    ///
+    /// [`Watch`]: RequestKind::Watch
+    #[must_use]
+    pub fn is_watch(&self) -> bool {
+        matches!(self, Self::Watch)
+    }
+
+    /// Returns `true` if the request kind is [`WatchStop`].
+    ///
+    /// [`WatchStop`]: RequestKind::WatchStop
+    #[must_use]
+    pub fn is_stop(&self) -> bool {
+        matches!(self, Self::Stop)
+    }
+
+    /// Returns `true` if the request kind is [`Once`].
+    ///
+    /// [`Once`]: RequestKind::Once
+    #[must_use]
+    pub fn is_once(&self) -> bool {
+        matches!(self, Self::Once)
+    }
+}
+
+#[cfg(feature = "lua")]
+impl<'a> FromLua<'a> for RequestOps {
+    fn from_lua(lua_value: LuaValue<'a>, _lua: &'a Lua) -> LuaResult<Self> {
+        use std::str::FromStr;
+        if let LuaValue::String(value) = lua_value {
+            let value = value.to_string_lossy();
+            Self::from_str(&*value).to_lua_err()
+        } else {
+            Ok(Self::default())
+        }
+    }
+}