shep 0.18.1

The shep binary: a process manager that keeps a flock of long-running processes alive on macOS, Linux and Windows, with logs, watch and cron restarts, and webhook alerts
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

//! Reading a finished frame back.
//!
//! [`super::super::fixtures`] builds what goes into a scene; this reads
//! what came out. Both halves are shared, so neither lives in a test
//! module of its own.

use ratatui::buffer::Buffer;

use crate::lookout::frames::coloured_palette;

/// The table row for `name`, or `None` if the table does not draw one.
///
/// Strips the leading `>` selection marker first, so a marked and
/// unmarked row share the same token index.
///
/// The numeric-id guard on token 0 is load bearing: the status bar's
/// own lines also open `{verb} {name} (id {id})`, so without it this
/// could match the bar line instead of a table row.
// Dead on Windows: only the cfg(unix) tests call it.
#[cfg_attr(windows, allow(dead_code))]
pub(super) fn row_for<'a>(frame: &'a str, name: &str) -> Option<&'a str> {
    frame.lines().find(|line| {
        let mut tokens = line.trim_start_matches('>').split_whitespace();
        tokens.next().is_some_and(|id| id.parse::<u32>().is_ok()) && tokens.next() == Some(name)
    })
}

/// [`coloured_palette`] always paints a ground, so every pinned
/// snapshot's selected row is a painted gutter rather than a `>` glyph
/// ([`crate::lookout::view::flock::gutter`]).
pub(super) fn gallery_ground() -> ratatui::style::Color {
    coloured_palette()
        .ground()
        .bg
        .expect("the gallery's coloured palette always paints a ground")
}

/// Whether row `y` of `buffer` is the selected one: its gutter cell
/// (column 0) carries [`gallery_ground`].
pub(super) fn row_is_selected(buffer: &Buffer, y: u16) -> bool {
    buffer
        .cell((0, y))
        .is_some_and(|cell| cell.bg == gallery_ground())
}

/// The rendered text of whichever row of `buffer` is selected, or
/// `None` if none is (a section header, for instance, is never
/// selected).
// Dead on Windows: only the cfg(unix) tests call it.
#[cfg_attr(windows, allow(dead_code))]
pub(super) fn selected_line<'a>(text: &'a str, buffer: &Buffer) -> Option<&'a str> {
    (0..buffer.area.height)
        .find(|&y| row_is_selected(buffer, y))
        .and_then(|y| text.lines().nth(usize::from(y)))
}

/// How many rows of `buffer`, EXCLUDING the status bar, are painted as
/// selected: a scene invariant is exactly one, the same invariant a `>`
/// glyph count used to check.
///
/// The status bar is always the buffer's last row and now carries the
/// same [`gallery_ground`] the selected row's gutter does
/// (`Palette::ground`, painted by `view::status` in this task); it is
/// chrome, not a candidate row, so it is excluded rather than counted.
pub(super) fn selected_row_count(buffer: &Buffer) -> usize {
    (0..buffer.area.height.saturating_sub(1))
        .filter(|&y| row_is_selected(buffer, y))
        .count()
}

/// The dogs table's own row lookup: unlike [`row_for`], a dog row opens
/// with `mark` and a name, never a numeric id, so the same "first two
/// tokens" shape does not apply.
pub(super) fn dog_row_for<'a>(frame: &'a str, name: &str) -> Option<&'a str> {
    frame
        .lines()
        .find(|line| line.trim_start_matches('>').split_whitespace().next() == Some(name))
}

/// A sheep's `dogs` tab row for `name`: [`dog_row_for`] with the open or
/// closed glyph that precedes the name skipped.
// Dead on Windows: only the cfg(unix) tests call it.
#[cfg_attr(windows, allow(dead_code))]
pub(super) fn tab_dog_row_for<'a>(frame: &'a str, name: &str) -> Option<&'a str> {
    frame.lines().find(|line| {
        let mut tokens = line.trim_start_matches('>').split_whitespace();
        matches!(tokens.next(), Some("\u{25b8}" | "\u{25be}")) && tokens.next() == Some(name)
    })
}

/// Whether the selected row's name starts with `prefix`.
///
/// Handles truncation: the NAME column's truncated string depends on
/// terminal width, so `prefix` only needs to fit the eight-column
/// floor `name_width` never shrinks below. Selection is read off
/// `buffer`'s own painted gutter ([`row_is_selected`]), not a `>`
/// glyph the gallery's palette no longer draws.
// Dead on Windows: only the cfg(unix) tests call it.
#[cfg_attr(windows, allow(dead_code))]
pub(super) fn marked_row_name_starts_with(text: &str, buffer: &Buffer, prefix: &str) -> bool {
    selected_line(text, buffer).is_some_and(|line| {
        line.trim_start_matches('>')
            .split_whitespace()
            .nth(1)
            .is_some_and(|name| name.starts_with(prefix))
    })
}