fast-rich 0.3.2

A Rust port of Python's Rich library for beautiful terminal formatting
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
133
134
135
136
137
138
139
140
141

//! Padding wrapper for renderables.
//!
//! Adds configurable padding (spaces) around any renderable content.

use crate::console::RenderContext;
use crate::renderable::{BoxedRenderable, Renderable, Segment};
use crate::text::Span;

/// Padding specification.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PaddingSpec {
    /// Top padding (lines)
    pub top: usize,
    /// Right padding (spaces)
    pub right: usize,
    /// Bottom padding (lines)
    pub bottom: usize,
    /// Left padding (spaces)
    pub left: usize,
}

impl PaddingSpec {
    /// Create padding with all sides equal.
    pub fn all(size: usize) -> Self {
        PaddingSpec {
            top: size,
            right: size,
            bottom: size,
            left: size,
        }
    }

    /// Create padding with vertical and horizontal values.
    pub fn symmetric(vertical: usize, horizontal: usize) -> Self {
        PaddingSpec {
            top: vertical,
            right: horizontal,
            bottom: vertical,
            left: horizontal,
        }
    }

    /// Create padding for each side individually.
    pub fn new(top: usize, right: usize, bottom: usize, left: usize) -> Self {
        PaddingSpec {
            top,
            right,
            bottom,
            left,
        }
    }

    /// No padding.
    pub fn none() -> Self {
        PaddingSpec::all(0)
    }
}

/// A renderable that adds padding around its child.
pub struct Padding {
    child: BoxedRenderable,
    spec: PaddingSpec,
}

impl Padding {
    /// Create a new padding wrapper.
    pub fn new(child: impl Renderable + Send + Sync + 'static, spec: PaddingSpec) -> Self {
        Padding {
            child: Box::new(child),
            spec,
        }
    }

    /// Create padding with all sides equal.
    pub fn all(child: impl Renderable + Send + Sync + 'static, size: usize) -> Self {
        Padding::new(child, PaddingSpec::all(size))
    }

    /// Create padding with vertical and horizontal values.
    pub fn symmetric(
        child: impl Renderable + Send + Sync + 'static,
        vertical: usize,
        horizontal: usize,
    ) -> Self {
        Padding::new(child, PaddingSpec::symmetric(vertical, horizontal))
    }
}

impl Renderable for Padding {
    fn render(&self, context: &RenderContext) -> Vec<Segment> {
        // Calculate available width for child after horizontal padding
        let child_width = context
            .width
            .saturating_sub(self.spec.left + self.spec.right);
        let child_context = RenderContext {
            width: child_width,
            height: None,
        };

        // Render child
        let child_segments = self.child.render(&child_context);

        let mut result = Vec::new();

        // Top padding (empty lines)
        for _ in 0..self.spec.top {
            result.push(Segment::line(vec![Span::raw(" ".repeat(context.width))]));
        }

        // Add left/right padding to each child segment
        for segment in child_segments {
            let mut padded_spans = Vec::new();

            // Left padding
            if self.spec.left > 0 {
                padded_spans.push(Span::raw(" ".repeat(self.spec.left)));
            }

            // Child content
            padded_spans.extend(segment.spans);

            // Right padding
            if self.spec.right > 0 {
                padded_spans.push(Span::raw(" ".repeat(self.spec.right)));
            }

            if segment.newline {
                result.push(Segment::line(padded_spans));
            } else {
                result.push(Segment::new(padded_spans));
            }
        }

        // Bottom padding (empty lines)
        for _ in 0..self.spec.bottom {
            result.push(Segment::line(vec![Span::raw(" ".repeat(context.width))]));
        }

        result
    }
}