powerliners 0.0.8

1:1 Rust port of powerline/powerline. The ultimate statusline/prompt utility.
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

// vim:fileencoding=utf-8:noet
//! Port of `powerline/bindings/lemonbar/powerline-lemonbar.py`.
//!
//! lemonbar driver script: spawns one `lemonbar` subprocess per
//! connected xrandr output, then re-renders the statusline at the
//! configured interval and pipes it into each lemonbar's stdin.
//!
//! Upstream is a Python binary script (`__main__`). The Rust analog
//! is a binary at `src/bin/powerline-lemonbar.rs` (TBD). This module
//! exports the assembly pieces the future binary will use.

// #!/usr/bin/env python                            // py:1
// from __future__ import (unicode_literals, division, absolute_import, print_function)  // py:3
// import time                                      // py:5
// import re                                        // py:6
// import subprocess                                // py:7
// from threading import Lock, Timer                // py:9
// from powerline.lemonbar import LemonbarPowerline                                          // py:11
// from powerline.commands.lemonbar import get_argparser                                     // py:12
// from powerline.bindings.wm import get_connected_xrandr_outputs                            // py:13

use crate::ported::bindings::wm::{get_connected_xrandr_outputs, XrandrOutput};
use crate::ported::commands::lemonbar::get_argparser;

/// One lemonbar instance: the connected output it shows, the spawned
/// subprocess writing into it, and the per-screen segment width
/// (`width / 5` per upstream py:23).
pub struct LemonbarInstance {
    pub screen_name: String,
    pub width: i64,
    // Process handle: in the real binary this is a `Child` with
    // captured stdin. The library-side carries the metadata only.
}

/// Build the lemonbar command line for one xrandr output.
///
/// Mirrors py:21:
/// ```python
/// command = [args.bar_command, '-g', '{0}x{1}+{2}+{3}'.format(
///     screen['width'], args.height, screen['x'], screen['y']
/// )] + args.args[1:]
/// ```
pub fn build_bar_command(
    bar_command: &str,
    screen: &XrandrOutput,
    height: &str,
    extra: &[String],
) -> Vec<String> {
    let mut cmd = vec![
        bar_command.to_string(),
        "-g".to_string(),
        format!("{}x{}+{}+{}", screen.width, height, screen.x, screen.y),
    ];
    cmd.extend_from_slice(extra);
    cmd
}

/// Port of the `if __name__ == '__main__':` block from
/// `powerline/bindings/lemonbar/powerline-lemonbar.py:16`.
///
/// Status: stub. Powerline.render() + i3-ipc loop deferred until
/// orchestrator + i3 integration lands. Returns immediately after
/// printing the arg-spec it would have parsed.
pub fn main() {
    // py:17-18  parser = get_argparser(); args = parser.parse_args()
    let parser = get_argparser();
    let _ = parser; // arg-spec is data-only without a CLI runner

    // py:20  powerline = LemonbarPowerline(); powerline.update_renderer()
    // (Powerline class not ported — skipped.)

    // py:22-25  for screen in get_connected_xrandr_outputs(pl):
    //              build command, spawn process, track instance
    let _outputs = get_connected_xrandr_outputs(&());

    // py:27-46  Timer + render + i3-ipc loop — deferred.
}

#[cfg(test)]
mod tests {
    use super::*;

    fn fake_screen() -> XrandrOutput {
        XrandrOutput {
            name: "HDMI-1".to_string(),
            primary: true,
            width: 1920,
            height: 1080,
            x: 0,
            y: 0,
        }
    }

    #[test]
    fn build_bar_command_assembles_geometry() {
        let s = fake_screen();
        let cmd = build_bar_command("lemonbar", &s, "24", &[]);
        assert_eq!(cmd, vec![
            "lemonbar".to_string(),
            "-g".to_string(),
            "1920x24+0+0".to_string(),
        ]);
    }

    #[test]
    fn build_bar_command_appends_extra_args() {
        let s = fake_screen();
        let extra = vec!["-B".to_string(), "#000000".to_string()];
        let cmd = build_bar_command("lemonbar", &s, "30", &extra);
        assert_eq!(cmd, vec![
            "lemonbar".to_string(),
            "-g".to_string(),
            "1920x30+0+0".to_string(),
            "-B".to_string(),
            "#000000".to_string(),
        ]);
    }
}