libtmux 0.1.0-alpha.17

Async typed tmux client and object model (alpha)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Operations that make or address a session.

use crate::escape_format;
use std::ffi::OsString;

use super::SESSION_FORMAT;
use super::{Effects, Op, Operation, Safety, Scope, SessionSlot, Slot};
use crate::Command;

/// Create a session.
///
/// # Examples
///
/// ```
/// use libtmux::plan::{NewSession, Plan};
///
/// let mut plan = Plan::new();
/// let session = plan.add(NewSession::new("work"));
/// // The session, its first window, and that window's pane all come from one
/// // command, so none of them costs a second round trip.
/// let _ = (session, session.window(), session.pane());
/// ```
#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
pub struct NewSession {
    #[cfg_attr(
        feature = "serde",
        serde(
            serialize_with = "crate::plan::wire::argument",
            deserialize_with = "crate::plan::wire::parse_argument"
        )
    )]
    #[cfg_attr(feature = "schema", schemars(with = "crate::plan::wire::Argument"))]
    name: OsString,
    #[cfg_attr(
        feature = "serde",
        serde(
            serialize_with = "crate::plan::wire::optional_argument",
            deserialize_with = "crate::plan::wire::parse_optional_argument"
        )
    )]
    #[cfg_attr(
        feature = "schema",
        schemars(with = "Option<crate::plan::wire::Argument>")
    )]
    start_directory: Option<OsString>,
    #[cfg_attr(
        feature = "serde",
        serde(
            serialize_with = "crate::plan::wire::optional_argument",
            deserialize_with = "crate::plan::wire::parse_optional_argument"
        )
    )]
    #[cfg_attr(
        feature = "schema",
        schemars(with = "Option<crate::plan::wire::Argument>")
    )]
    window_name: Option<OsString>,
}

impl NewSession {
    /// Create a detached session with this name.
    #[must_use]
    pub fn new(name: impl Into<OsString>) -> Self {
        Self {
            name: name.into(),
            start_directory: None,
            window_name: None,
        }
    }

    /// Start the session's first window in this directory.
    ///
    /// tmux expands this as a format, so [`crate::escape_format`] belongs
    /// around text a program did not write.
    #[must_use]
    pub fn start_directory(mut self, directory: impl Into<OsString>) -> Self {
        self.start_directory = Some(directory.into());
        self
    }

    /// Name the session's first window.
    #[must_use]
    pub fn window_name(mut self, name: impl Into<OsString>) -> Self {
        self.window_name = Some(name.into());
        self
    }

    pub(crate) fn render(&self) -> Command {
        let mut command = Command::new("new-session")
            .arg("-d")
            .arg("-P")
            .arg("-F")
            .arg(SESSION_FORMAT)
            .arg("-s")
            .arg(escape_format(&self.name));
        if let Some(directory) = &self.start_directory {
            command = command.arg("-c").arg(escape_format(directory));
        }
        if let Some(name) = &self.window_name {
            command = command.arg("-n").arg(escape_format(name));
        }
        command
    }
}

operation!(
    NewSession,
    creates = Slot<SessionSlot>,
    effects = Effects {
        creates: Some(Scope::Session),
        ..Effects::MUTATING
    },
    safety = Safety::Mutating
);