ctl-layout 0.7.5

Terminal widgets built on ctl-text: tables, records, rules, stacks, and indents
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

//! A record: key and value rows.

use ctl_text::{Context, Line, Measurement, Renderable, Text};

use crate::align::Align;
use crate::column::Column;
use crate::frame::{Frame, RecordStyle};
use crate::table::Table;

/// Labelled values, one pair to a row.
///
/// Two rows draw as:
///
/// ```text
/// version  1.4.0
/// channel  stable
/// ```
///
/// A record is a two-column [`Table`] with no header. It shares the table's
/// column widths, so a long value wraps under its own column and a long word
/// keeps its line. A record with no rows draws nothing.
#[derive(Clone, Debug)]
pub struct Record {
    table: Table,
}

impl Record {
    /// A record with no rows, drawn in the default [`RecordStyle`]: keys
    /// right-aligned and no frame.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets how the record is drawn, replacing the default
    /// [`RecordStyle::KeysRight`].
    #[must_use]
    pub fn style(self, style: RecordStyle) -> Self {
        Self {
            table: Self::table(style).rows(self.table.into_rows()),
        }
    }

    /// Adds `key` and its `value` as the last row. Either may span several
    /// lines, and the row is as tall as the taller of the two.
    #[must_use]
    pub fn row(self, key: impl Into<Text>, value: impl Into<Text>) -> Self {
        self.push(key.into(), value.into())
    }

    fn push(mut self, key: Text, value: Text) -> Self {
        self.table = self.table.row([key, value]);
        self
    }

    fn table(style: RecordStyle) -> Table {
        let (frame, keys) = match style {
            RecordStyle::KeysRight => (Frame::Plain, Align::Right),
            RecordStyle::KeysLeft => (Frame::Plain, Align::Left),
            RecordStyle::Boxed => (Frame::Grid, Align::Left),
        };
        Table::new([Column::untitled().align(keys), Column::untitled()]).frame(frame)
    }
}

impl Default for Record {
    fn default() -> Self {
        Self {
            table: Self::table(RecordStyle::default()),
        }
    }
}

impl Renderable for Record {
    fn measure(&self, context: &Context) -> Measurement {
        self.table.measure(context)
    }

    fn render(&self, context: &Context) -> Vec<Line> {
        self.table.render(context)
    }
}