refactor(tui): use paths.rs in tui

Author: Madman10K

src/tui/Cargo.lock

@@ -19,7 +19,6 @@ serde_repr = "0.1"
 notify = "6.1.1"
 futures = "0.3.30"
 futures-timer = "3.0.3"
-tempfile = "3.20.0"
 ratatui = "0.29.0"
 log = "0.4.27"
 env_logger = "0.11.8"

src/tui/Cargo.toml

@@ -13,8 +13,7 @@ use crate::task::{gen_task_id, to_event_kind, to_task_kind_text, EventId, TaskId
 use serde::Serialize;
 use tokio;
 use tokio::sync::mpsc;
-
-pub const CODETRACER_TMP_PATH: &str = "/tmp/codetracer";
+use crate::paths::CODETRACER_PATHS;
 
 #[derive(Debug, Default)]
 pub struct Core {
@@ -44,7 +43,8 @@ impl Core {
     }
 
     fn run_dir(&self) -> PathBuf {
-        PathBuf::from(CODETRACER_TMP_PATH).join(format!("run-{}", self.caller_process_pid))
+        let tmp_path = CODETRACER_PATHS.lock().unwrap().tmp_path.clone();
+        tmp_path.join(format!("run-{}", self.caller_process_pid))
     }
 
     fn ensure_arg_path_for(&self, task_id: TaskId) -> Result<PathBuf, Box<dyn Error>> {

src/tui/src/core.rs

@@ -6,6 +6,9 @@ use std::os::unix::net::UnixStream;
 use std::process::{Child, Command};
 use tokio::sync::mpsc;
 
+//mod paths;
+use crate::paths::CODETRACER_PATHS;
+
 pub struct DapClient {
     child: Child,
     reader: BufReader<UnixStream>,
@@ -16,7 +19,12 @@ pub struct DapClient {
 impl DapClient {
     pub fn start(server_bin: &str) -> Result<Self, Box<dyn Error>> {
         let pid = std::process::id();
-        let socket_path = format!("/tmp/ct_dap_socket_{pid}");
+        let tmp_path =
+        {
+            CODETRACER_PATHS.lock()?.tmp_path.clone()
+        };
+        let tmp_path_str = tmp_path.display();
+        let socket_path = format!("{tmp_path_str}/ct_dap_socket_{pid}");
         let _ = std::fs::remove_file(&socket_path);
 
         let child = if server_bin.ends_with("dlv") {

src/tui/src/dap_client.rs

@@ -35,18 +35,19 @@ mod status_component;
 mod task;
 mod value;
 mod window;
+mod paths;
 
 use crate::dap_client::DapClient;
 use component::Component;
-use core::{caller_process_pid, Core, CODETRACER_TMP_PATH};
+use core::{caller_process_pid, Core};
 use editor_component::EditorComponent;
 use event::{CtEvent, Event};
 use lang::Lang;
 use panel::{coord, panel, size};
-use serde_json::Value;
 use state_component::StateComponent;
 use status_component::StatusComponent;
 use task::{Action, EventId, EventKind, FlowUpdate, Location, MoveState, StepArg, TaskKind};
+use paths::CODETRACER_PATHS;
 
 #[derive(Debug, Default)]
 pub struct Trace {
@@ -99,9 +100,6 @@ impl Default for App {
     }
 }
 
-const CT_SOCKET_PATH: &str = "/tmp/ct_socket";
-const CT_CLIENT_SOCKET_PATH: &str = "/tmp/ct_client_socket";
-
 const EDITOR_COMPONENT: usize = 0;
 
 impl App {
@@ -274,8 +272,18 @@ impl App {
     fn process_incoming_messages(&mut self) {}
 
     fn start_core(&mut self) -> Result<(), Box<dyn Error>> {
-        let last_start_pid_path = format!("{CODETRACER_TMP_PATH}/last-start-pid");
-        let _ = std::fs::create_dir(CODETRACER_TMP_PATH);
+        let tmp_path: PathBuf;
+        let socket_path_tmp: PathBuf;
+        {
+            let paths = CODETRACER_PATHS.lock()?;
+            tmp_path = paths.tmp_path.clone();
+            socket_path_tmp = paths.socket_path.clone();
+        }
+
+        let tmp_socket_path_str = socket_path_tmp.display();
+
+        let last_start_pid_path = format!("{tmp_socket_path_str}/last-start-pid");
+        let _ = std::fs::create_dir(tmp_path);
         std::fs::write(
             last_start_pid_path,
             format!("{}\n", self.caller_process_pid),
@@ -286,13 +294,9 @@ impl App {
         env::set_var("CODETRACER_DISPATCHER_READ_CLIENT", "STDIN");
         env::set_var("CODETRACER_DISPATCHER_SEND_CLIENT", "FILE");
 
-        // https://stackoverflow.com/a/73224567/438099
-        // let file = std::fs::File::create("/tmp/codetracer/out.txt").unwrap();
-        // let file_out_stdio = Stdio::from(file);
-
         let caller_pid = self.caller_process_pid;
 
-        let socket_path = format!("{CT_SOCKET_PATH}_{caller_pid}");
+        let socket_path = format!("{tmp_socket_path_str}_{caller_pid}");
         eprintln!("{socket_path:?}");
         let socket = UnixStream::connect(&socket_path)?;
         eprintln!("{socket:?}");
@@ -648,7 +652,11 @@ mod tests {
 
     #[test]
     fn register_trace_in_db() {
-        let base = env::temp_dir().join("ct_tui_test_db");
+        let tmp_path =
+        {
+            CODETRACER_PATHS.lock()?.tmp_path.clone()
+        };
+        let base = tmp_path.join("ct_tui_test_db");
         let _ = fs::remove_dir_all(&base);
         fs::create_dir_all(&base).unwrap();
         let temp_home = base.join("home");

src/tui/src/main.rs

@@ -0,0 +1,24 @@
+use std::env;
+use std::path::PathBuf;
+use std::sync::{LazyLock, Mutex};
+
+pub struct Paths {
+    pub tmp_path: PathBuf,
+    pub socket_path: PathBuf,
+}
+
+impl Default for Paths {
+    fn default() -> Self {
+        let tmpdir: PathBuf = if cfg!(target_os = "macos") {
+            PathBuf::from(env::var("HOME").unwrap_or("/".to_string())).join("Library/Caches/com.codetracer.CodeTracer/")
+        } else {
+            PathBuf::from(env::temp_dir()).join("codetracer/")
+        };
+        Self {
+            tmp_path: PathBuf::from(&tmpdir),
+            socket_path: PathBuf::from(&tmpdir).join("ct_socket"),
+        }
+    }
+}
+
+pub static CODETRACER_PATHS: LazyLock<Mutex<Paths>> = LazyLock::new(|| Mutex::new(Paths::default()));

src/tui/src/paths.rs

@@ -28,6 +28,7 @@ fn with_line_numbers(lines: &[String]) -> Vec<String> {
 }
 
 mod dap_client;
+mod paths;
 use dap_client::DapClient;
 
 #[derive(Debug)]