Struct Timeline 

pub struct Timeline { /* private fields */ }

Labelled ranges on a numeric scale, such as the steps of a build in seconds: a Gantt strip when every range has its own row, a timeline of lanes when ranges share a row.

• Each row is labelled on the left. Ranges on the same row that overlap are stacked onto extra lines under it, so none hides another.
• Ranges are drawn █, or ▓ when one follows another on the same line (# and = in ASCII), in their row’s chart.series.N colour. A range covers every column whose centre value is inside it, and at least one.
• Each range’s length is written after it when there is room before the next one (durations, on by default), so the chart reads without the axis.
• milestone marks a point with ◆ (*) on a line under the ranges, its label beside it when it fits.
• The axis runs along the bottom. Its labels sit on evenly spaced columns and name each column’s exact value, as on a LineChart; unit is written after each value (20s).
• Compression: when the range is wider than the plot, so that the shortest range would get less than a column of its own, idle gaps longer than four times the shortest range, and longer than three columns’ worth of the uncut scale, are cut out (compress, on by default). Each cut is three columns with ≈ (~) on the axis, and the axis labels each stretch at its start and end.
• It fills the width given, or width. Given less, the row labels are cut so the plot keeps 8 columns.

use rich::Console;
use rich_ext::chart::Timeline;

let console = Console::builder().width(40).color_system(None).build();
let build = Timeline::new()
    .span("fetch", 0.0, 4.0)
    .span("compile", 4.0, 26.0)
    .span("test", 12.0, 30.0)
    .span("test", 20.0, 34.0)
    .milestone("ship", 36.0)
    .unit("s")
    .width(40);
assert_eq!(
    console.render_export(&build),
    concat!(
        "fetch   ████ 4s                         \n",
        "compile     █████████████████ 22s       \n",
        "test              ███████████████ 18s   \n",
        "                        ████████████ 14s\n",
        "                                ship ◆  \n",
        "        ┬───────┬───────┬───────┬───────\n",
        "        0s     10s     20s     30s      \n",
    )
);

Implementations

impl Timeline

pub fn new() -> Self

An empty timeline; add ranges with span.

pub fn span(self, row: impl Into<String>, start: f64, end: f64) -> Self

Add a range on row row from start to end.

pub fn push(self, span: Span) -> Self

Add a Span built with its own style.

pub fn milestone(self, label: impl Into<String>, at: f64) -> Self

Add a milestone at at.

pub fn range(self, min: f64, max: f64) -> Self

Fix the scale instead of fitting it to the ranges (no compression).

pub fn charset(self, charset: Charset) -> Self

Glyphs to draw with: Charset::Ascii asks for ASCII; anything else draws blocks (ASCII on an ASCII-only console).

pub fn format(self, format: ValueFormat) -> Self

How values are written (default ValueFormat::Compact).

pub fn unit(self, unit: impl Into<String>) -> Self

Written after every value on the axis and every length, such as s.

pub fn compress(self, compress: bool) -> Self

Cut long idle gaps when the range is wider than the plot (default on).

pub fn durations(self, show: bool) -> Self

Write each range’s length after it (default on).

pub fn width(self, width: usize) -> Self

Fix the width (default: the width given).

pub fn rows(&self) -> Vec<&str>

The row labels, in the order they first appear.

Trait Implementations

impl AccessibleText for Timeline

Timeline, 3 rows, 4 ranges, 1 milestone, from 0s to 95s, then each range (compile from 0s to 12s, 12s), twenty at most, and each milestone (Milestone release at 90s).

fn accessible_text(&self, _width: usize) -> String

The content as plain lines, laid out for width where layout matters.

impl Clone for Timeline

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Timeline

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Timeline

fn default() -> Self

Returns the “default value” for a type.

impl Draw for Timeline

fn draw( &self, console: &Console, options: &ConsoleOptions, screen: &mut Screen, rect: Rect, )

Draw into rect of screen, rendered with options (its width and height are the rectangle’s): the cells screen.write_lines(rect, &console.render_lines(self, options, false)) would give.

impl PartialEq for Timeline

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Renderable for Timeline

fn rich_render( &self, console: &Console, options: &ConsoleOptions, ) -> Vec<Segment>

fn measure(&self, _console: &Console, options: &ConsoleOptions) -> Measurement

The (minimum, maximum) cell width this renderable wants. Port of __rich_measure__. The default is what upstream’s Measurement.get returns for a renderable without one: anything from nothing to the whole width, (0, max_width).

fn fit_to_measurement(&self) -> bool

Whether a top-level Console::print shrinks this renderable to its measured width. Upstream renders every top-level renderable at the full console width, so the default is false; an extension may opt in.

fn vertical(&self) -> Option<VerticalAlign>

The vertical alignment a Table cell holding this renderable uses in place of its column’s. Upstream reads getattr(renderable, "vertical", None); Align sets it.

fn print_end_line(&self, _options: &ConsoleOptions) -> bool

Whether a top-level print ends this renderable’s last line. This port’s renderables separate lines, where upstream’s end each line with "\n", so a print adds the final line break. A renderable whose upstream output stops without one (Screen, LiveRender, a Rule whose end has no newline) returns false, and the next output continues its last line. options are the print’s options.

impl StructuralPartialEq for Timeline