tmuxship 0.1.3

A Starship-to-tmux adapter that renders tmux-ready status lines from Starship JSON output
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use anyhow::{anyhow, Result};
use serde::Serialize;
use shellexpand::tilde;
use std::collections::HashMap;
use std::path::{Path, PathBuf};

#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize)]
pub enum Side {
    Left,
    Right,
    Full,
    Center,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ConfigResolution {
    pub side: Side,
    pub config_path: PathBuf,
    pub source: String,
}

impl ConfigResolution {
    fn new(side: Side, path: PathBuf, source: impl Into<String>) -> Self {
        Self {
            side,
            config_path: path,
            source: source.into(),
        }
    }
}

fn expand_user(path: &Path) -> PathBuf {
    let as_str = path.to_string_lossy();
    let expanded = tilde(&as_str);
    PathBuf::from(expanded.as_ref())
}

fn ensure_file(path: PathBuf, context: &str) -> Result<PathBuf> {
    if path.is_file() {
        Ok(path)
    } else {
        Err(anyhow!("{}: {}", context, path.display()))
    }
}

pub fn resolve_config(
    side: Side,
    override_path: Option<PathBuf>,
    env: &HashMap<String, String>,
) -> Result<ConfigResolution> {
    let normalized_side = match side {
        Side::Left => "LEFT",
        Side::Right => "RIGHT",
        Side::Full => "FULL",
        Side::Center => "CENTER",
    };

    if let Some(path) = override_path {
        let expanded = ensure_file(expand_user(&path), "Config override does not exist")?;
        return Ok(ConfigResolution::new(side, expanded, "override"));
    }

    let side_env_var = format!("TMUX_SHIP_{}_CONFIG", normalized_side);
    if let Some(value) = env.get(&side_env_var) {
        let expanded = ensure_file(
            expand_user(Path::new(value)),
            "Environment-specified config does not exist",
        )?;
        return Ok(ConfigResolution::new(side, expanded, side_env_var));
    }

    if let Some(value) = env.get("STARSHIP_CONFIG") {
        let expanded = ensure_file(
            expand_user(Path::new(value)),
            "STARSHIP_CONFIG points to missing file",
        )?;
        return Ok(ConfigResolution::new(side, expanded, "STARSHIP_CONFIG"));
    }

    let mut candidate_dirs: Vec<(PathBuf, &str)> = Vec::new();
    if let Some(xdg_config) = env.get("XDG_CONFIG_HOME") {
        let xdg = expand_user(Path::new(xdg_config));
        candidate_dirs.push((xdg.join("tmux"), "tmux"));
        candidate_dirs.push((xdg.join("starship"), "starship"));
    }
    if let Some(home) = env.get("HOME") {
        let home = expand_user(Path::new(home));
        candidate_dirs.push((home.join(".config/tmux"), "tmux"));
        candidate_dirs.push((home.join(".tmux"), "tmux"));
        candidate_dirs.push((home.join(".config/starship"), "starship"));
    } else if let Some(home_dir) = dirs::home_dir() {
        candidate_dirs.push((home_dir.join(".config/tmux"), "tmux"));
        candidate_dirs.push((home_dir.join(".tmux"), "tmux"));
        candidate_dirs.push((home_dir.join(".config/starship"), "starship"));
    }

    let side_filename = match side {
        Side::Left => ".left.toml",
        Side::Right => ".right.toml",
        Side::Full => ".full.toml",
        Side::Center => ".center.toml",
    };

    for (base, kind) in candidate_dirs {
        if !base.exists() {
            continue;
        }
        let side_path = base.join(side_filename);
        if side_path.is_file() {
            let source = if kind == "tmux" {
                "tmux-side"
            } else {
                "default-side"
            };
            return Ok(ConfigResolution::new(side, side_path, source));
        }
        let global_path = base.join("starship.toml");
        if global_path.is_file() {
            let source = if kind == "tmux" {
                "tmux-global"
            } else {
                "default-global"
            };
            return Ok(ConfigResolution::new(side, global_path, source));
        }
    }

    Err(anyhow!(
        "Unable to locate a Starship config file for tmuxship (side={:?})",
        side
    ))
}