pinel 0.8.0

A lightweight editor built with rust
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
118
119
120
121
122
123
124
125
126
127
128

use std::{
    path::{Path, PathBuf},
    process::Command,
};

/// External terminal launcher - opens the OS-native terminal
/// in the current working directory or last opened directory.
#[derive(Default)]
pub struct Terminal {
    last_opened_directory: Option<PathBuf>,
}

impl Terminal {
    /// Toggle/open the system's default terminal
    pub fn toggle(&mut self) {
        self.open_system_terminal();
    }

    /// Set the directory that should be opened when launching the terminal
    pub fn set_directory(&mut self, directory: PathBuf) {
        self.last_opened_directory = Some(directory);
    }

    fn open_system_terminal(&mut self) {
        let directory = self
            .last_opened_directory
            .clone()
            .or_else(|| std::env::current_dir().ok())
            .unwrap_or_else(|| PathBuf::from("."));

        let result = if cfg!(target_os = "macos") {
            self.open_macos_terminal(&directory)
        } else if cfg!(target_os = "windows") {
            self.open_windows_terminal(&directory)
        } else {
            self.open_linux_terminal(&directory)
        };

        if let Err(e) = result {
            eprintln!("Failed to open terminal: {}", e);
        }
    }

    fn open_macos_terminal(&self, directory: &Path) -> std::io::Result<()> {
        let dir_str = directory.display().to_string();

        // Try iTerm2 first
        if let Ok(output) = Command::new("osascript")
            .arg("-e")
            .arg(format!(
                r#"tell application "iTerm"
                    create window with default profile
                    tell current session of current window
                        write text "cd '{}'"
                    end tell
                end tell"#,
                dir_str
            ))
            .output()
        {
            if output.status.success() {
                return Ok(());
            }
        }

        // Fallback to Terminal.app
        Command::new("osascript")
            .arg("-e")
            .arg(format!(
                r#"tell application "Terminal"
                    activate
                    do script "cd '{}'"
                end tell"#,
                dir_str
            ))
            .spawn()?;

        Ok(())
    }

    fn open_windows_terminal(&self, directory: &Path) -> std::io::Result<()> {
        let dir_str = directory.display().to_string();

        if Command::new("wt.exe").args(["-d", &dir_str]).spawn().is_ok() {
            return Ok(());
        }

        if Command::new("powershell.exe")
            .args(["-NoExit", "-Command", &format!("cd '{}'", dir_str)])
            .spawn()
            .is_ok()
        {
            return Ok(());
        }

        Command::new("cmd.exe").args(["/K", "cd", "/D", &dir_str]).spawn()?;

        Ok(())
    }

    fn open_linux_terminal(&self, directory: &Path) -> std::io::Result<()> {
        let dir_str = directory.display().to_string();
        let xterm_cmd = format!("cd '{}' && exec $SHELL", dir_str);

        let terminals = vec![
            ("gnome-terminal", vec!["--working-directory", &dir_str]),
            ("konsole", vec!["--workdir", &dir_str]),
            ("xfce4-terminal", vec!["--working-directory", &dir_str]),
            ("alacritty", vec!["--working-directory", &dir_str]),
            ("kitty", vec!["--directory", &dir_str]),
            ("terminator", vec!["--working-directory", &dir_str]),
            ("tilix", vec!["--working-directory", &dir_str]),
            ("urxvt", vec!["-cd", &dir_str]),
            ("xterm", vec!["-e", &xterm_cmd]),
        ];

        for (terminal, args) in terminals {
            if Command::new(terminal).args(args).spawn().is_ok() {
                return Ok(());
            }
        }

        Err(std::io::Error::new(
            std::io::ErrorKind::NotFound,
            "No supported terminal emulator found",
        ))
    }
}