Implement layouts and fix a bug

Author: Dlurak

src/cli.rs

@@ -1,4 +1,5 @@
 use clap::{Parser, Subcommand};
+use std::path::PathBuf;
 
 // TODO: Make a `cli`directory with multiple files
 
@@ -16,11 +17,15 @@ pub enum Commands {
     ///
     /// This command will initialize your config directories.
     Init,
-    /// Manage tmux sessions related to directories
+    /// Manage directories in the context of muxmate and tmux
     ///
     /// This command provides functionalities to interact with tmux sessions based on directories.
     #[command(alias = "dir", alias = "dirs", alias = "directories")]
     Directory(DirectoryCli),
+    /// Manage templates in the context of muxmate and tmux
+    ///
+    /// This command provides functionalities to interact with tmux sessions based on templates
+    #[command(alias = "temp", alias = "templ")]
     Template(TemplateCli),
 }
 
@@ -75,5 +80,19 @@ pub enum TemplateCommands {
 
 #[derive(Parser, Debug)]
 pub struct StartTemplateArgs {
-    pub name: String,
+    pub template_name: String,
+
+    /// Start the session detached
+    #[arg(short, long, default_value_t = false)]
+    pub detached: bool,
+
+    /// The directory to start it in
+    #[arg(long, alias = "dir")]
+    pub directory: Option<PathBuf>,
+
+    /// Specify the name of the tmux session
+    ///
+    /// Optionally provide a name for the session. If not provided, it will be either the name from the configuration or from the directory
+    #[arg(short, long)]
+    pub name: Option<String>,
 }

src/commands/directory.rs

@@ -1,7 +1,7 @@
 use crate::{
     cli::{DirectoryCli, DirectoryCommands, ListArgs, StartDirectoryArgs},
     directories::{self, Directory},
-    helpers::{absolute_path, Exit},
+    helpers::{absolute_path, dir_name, Exit},
     tmux::{attach, session_exists},
     widgets::{heading::Heading, table::fmt_table},
 };
@@ -81,12 +81,7 @@ fn resolve_dir_path(cli_args: &StartDirectoryArgs) -> (String, PathBuf) {
         None => {
             let relative_path = PathBuf::from(&cli_args.directory);
             let path = absolute_path(&relative_path).exit(1, "The path could not be generated");
-            let name = user_name.unwrap_or(
-                path.file_name()
-                    .and_then(|os_string| os_string.to_str())
-                    .map(|str| str.to_string())
-                    .unwrap_or("".to_string()),
-            );
+            let name = user_name.unwrap_or(dir_name(&path));
 
             (name, path)
         }

src/commands/template.rs

@@ -1,10 +1,12 @@
 use crate::{
+    apply_if,
     cli::{ListArgs, StartTemplateArgs, TemplateCli, TemplateCommands},
-    helpers::Exit,
-    templates::{parse_template_config, Template},
+    helpers::{absolute_path, dir_name, Exit},
+    templates::{apply_template, parse_template_config},
     tmux::{attach, session_exists},
     widgets::{heading::Heading, table::fmt_table},
 };
+use std::path::PathBuf;
 use tmux_interface::{NewSession, Tmux, TmuxCommand};
 
 pub fn template_handler(args: TemplateCli) {
@@ -30,51 +32,54 @@ fn list_handler(args: ListArgs) {
 fn start_handler(args: StartTemplateArgs) {
     let templates = parse_template_config();
     let template = templates
-        .iter()
-        .find(|&temp| temp.name == args.name)
+        .into_iter()
+        .find(|temp| temp.name == args.template_name)
         .exit(1, "No template found");
 
+    let detached = args.detached;
     let name = &template.name;
+
     if session_exists(name).unwrap_or(false) {
-        Tmux::new()
-            .add_command(attach(name))
+        apply_if!(!detached, Tmux::new(), add_command, attach(name))
             .output()
             .exit(1, "Could not attach to the Tmux-session");
         return;
     }
 
-    let initial_tmux = Tmux::new()
-        .add_command(NewSession::new().detached().session_name(name))
-        .add_command(attach(name));
-    let tmux = apply_template(initial_tmux, template);
+    let resolved_path = args.directory.and_then(|p| absolute_path(&p).ok());
+    let (new_session_cmd, name) = resolve_cmd_name(&resolved_path, args.name, name.to_string());
 
-    tmux.output().exit(1, "Could not start Tmux-session");
-}
+    let initial_tmux = Tmux::new().add_command(new_session_cmd);
+    let initial_tmux = apply_if!(!detached, initial_tmux, add_command, attach(&name));
 
-fn apply_template<'a>(tmux: Tmux<'a>, template: &'a Template) -> Tmux<'a> {
-    let enumerated = template.windows.iter().enumerate();
-    enumerated.fold(tmux, |tmux, (window_idx, window)| {
-        let cmd = match (window_idx, &window.name) {
-            (0, Some(name)) => TmuxCommand::rename_window().new_name(name).into(),
-            (0, None) => TmuxCommand::new(),
-            (_, Some(name)) => TmuxCommand::new_window().window_name(name).into(),
-            (_, None) => TmuxCommand::new_window().into(),
-        };
+    let tmux = apply_template(initial_tmux, &template, &resolved_path);
 
-        let tmux = tmux.add_command(cmd);
-        add_panes_to_tmux(tmux, &window.panes)
-    })
+    tmux.output().exit(1, "Could not start Tmux-session");
 }
 
-fn add_panes_to_tmux<'a>(tmux: Tmux<'a>, panes: &[String]) -> Tmux<'a> {
-    let enumerated = panes.iter().enumerate();
+fn resolve_cmd_name(
+    path: &Option<PathBuf>,
+    name: Option<String>,
+    template_name: String,
+) -> (TmuxCommand<'static>, String) {
+    if let Some(p) = path {
+        let session_name = name.unwrap_or_else(|| dir_name(p));
+        return (
+            NewSession::new()
+                .detached()
+                .session_name(session_name.clone())
+                .start_directory(p.to_string_lossy().into_owned())
+                .into(),
+            session_name,
+        );
+    }
 
-    enumerated.fold(tmux, |tmux, (pane_idx, command)| {
-        let tmux = if pane_idx > 0 {
-            tmux.add_command(TmuxCommand::split_window())
-        } else {
-            tmux
-        };
-        tmux.add_command(TmuxCommand::send_keys().key(format!("{}\r", command)))
-    })
+    let session_name = name.unwrap_or(template_name);
+    (
+        NewSession::new()
+            .detached()
+            .session_name(session_name.clone())
+            .into(),
+        session_name,
+    )
 }

src/helpers.rs

@@ -57,6 +57,13 @@ pub fn runs_in_tmux() -> bool {
     env::var("TMUX").is_ok()
 }
 
+pub fn dir_name(path: &Path) -> String {
+    path.file_name()
+        .and_then(|os_string| os_string.to_str())
+        .map(|str| str.to_string())
+        .unwrap_or("".to_string())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/macros.rs

@@ -5,3 +5,14 @@ macro_rules! exit {
         std::process::exit($code);
     }};
 }
+
+#[macro_export]
+macro_rules! apply_if {
+    ($condition:expr, $obj:expr, $method:ident $(, $args:expr)*) => {
+        if $condition {
+            $obj.$method($($args),*)
+        } else {
+            $obj
+        }
+    };
+}

src/templates.rs

@@ -3,7 +3,8 @@ use crate::{
     widgets::table::Table,
 };
 use serde::Deserialize;
-use std::fs;
+use std::{fs, path::PathBuf};
+use tmux_interface::{Tmux, TmuxCommand};
 
 #[derive(Deserialize, Debug)]
 pub struct Template {
@@ -14,6 +15,7 @@ pub struct Template {
 #[derive(Deserialize, Debug)]
 pub struct Window {
     pub name: Option<String>,
+    pub layout: Option<String>,
     pub panes: Vec<String>,
 }
 
@@ -40,3 +42,61 @@ pub fn parse_template_config() -> Vec<Template> {
         .filter_map(|x| serde_yaml::from_str::<Template>(x).ok())
         .collect()
 }
+
+pub fn apply_template<'a>(
+    tmux: Tmux<'a>,
+    template: &'a Template,
+    dir: &'a Option<PathBuf>,
+) -> Tmux<'a> {
+    let enumerated = template.windows.iter().enumerate();
+    enumerated.fold(tmux, |tmux, (window_idx, window)| {
+        let cmd = build_tmux_command(window_idx, window, dir);
+
+        let layout_cmd: TmuxCommand = match &window.layout {
+            Some(layout) => TmuxCommand::select_layout().layout_name(layout).into(),
+            None => TmuxCommand::select_layout().into(),
+        };
+
+        let tmux = tmux.add_command(cmd);
+        add_panes_to_tmux(tmux, &window.panes, dir).add_command(layout_cmd)
+    })
+}
+
+fn add_panes_to_tmux<'a>(tmux: Tmux<'a>, panes: &[String], dir: &'a Option<PathBuf>) -> Tmux<'a> {
+    let enumerated = panes.iter().enumerate();
+
+    enumerated.fold(tmux, |tmux, (pane_idx, command)| {
+        let cmd: TmuxCommand = match (pane_idx, dir) {
+            (0, _) => TmuxCommand::new(),
+            (_, Some(d)) => TmuxCommand::split_window()
+                .start_directory(d.to_string_lossy())
+                .into(),
+            (_, None) => TmuxCommand::split_window().into(),
+        };
+
+        tmux.add_command(cmd)
+            .add_command(TmuxCommand::send_keys().key(format!("{}\r", command)))
+    })
+}
+
+fn build_tmux_command<'a>(
+    window_idx: usize,
+    window: &'a Window,
+    dir: &'a Option<PathBuf>,
+) -> TmuxCommand<'a> {
+    if window_idx == 0 {
+        match &window.name {
+            Some(name) => TmuxCommand::rename_window().new_name(name).into(),
+            None => TmuxCommand::new(),
+        }
+    } else {
+        let new_win = match &window.name {
+            Some(name) => TmuxCommand::new_window().window_name(name),
+            None => TmuxCommand::new_window(),
+        };
+        match dir {
+            Some(d) => new_win.start_directory(d.to_string_lossy()).into(),
+            None => new_win.into(),
+        }
+    }
+}