Struct KeyValue 

pub struct KeyValue { /* private fields */ }

A list of aligned key-value pairs.

Examples

use sparcli::{KeyValue, Renderable};

let out = KeyValue::new()
    .add("name", "sparcli")
    .add("license", "MIT")
    .render(40);
assert!(out.plain().contains("sparcli"));

Implementations

impl KeyValue

pub fn new() -> Self

Creates an empty key-value list.

Examples found in repository

examples/output_gallery.rs (line 165)

fn key_values_and_badges() -> Result<()> {
    section("Key-value & badges")?;
    KeyValue::new()
        .add("Version", "0.1.0")
        .add("License", "MIT")
        .print()?;
    println!();
    Rendered::new(vec![Line::new(vec![
        Badge::new("PASS")
            .style(Style::new().fg(Color::Green).bold())
            .span(),
        Span::raw(" "),
        Badge::new("WARN")
            .style(Style::new().fg(Color::Yellow).bold())
            .span(),
        Span::raw(" "),
        Badge::new("v0.1").caps("(", ")").span(),
    ])])
    .print()?;
    Ok(())
}

examples/output-readme.rs (line 172)

fn right_column() -> Rendered {
    let kv = KeyValue::new()
        .key_style(Style::new().fg(Color::Cyan).bold())
        .value_style(Style::new())
        .add("host", "localhost")
        .add("port", "8080")
        .add("scheme", "https")
        .add("timeout", "30s")
        .render(24);

    let badge = |text: &str, color: Color| {
        Badge::new(text)
            .pad(1)
            .style(Style::new().fg(Color::Black).bg(color).bold())
            .span()
    };
    let badges = Rendered::new(vec![
        Line::new(vec![
            badge("DONE", Color::Green),
            Span::raw(" "),
            badge("INFO", Color::LightBlue),
        ]),
        Line::default(),
        Line::new(vec![
            badge("WARN", Color::Yellow),
            Span::raw(" "),
            badge("FAIL", Color::Red),
        ]),
    ]);

    let label = |text: &str| {
        Rendered::new(vec![Line::styled(
            text,
            Style::new().fg(Color::Cyan).bold(),
        )])
    };
    let staggered = Columns::new()
        .add_rendered(label("Col 1"))
        .add_rendered(vstack(&[blank(), label("Col 2")], 0))
        .add_rendered(vstack(&[blank(), blank(), label("Col 3")], 0))
        .gap(2)
        .separator(BorderType::Single)
        .render(40);

    vstack(&[kv, blank(), badges, blank(), staggered], 0)
}

pub fn add(self, key: impl Into<String>, value: impl Into<Text>) -> Self

Adds a key-value pair.

Examples found in repository

examples/output_gallery.rs (line 166)

fn key_values_and_badges() -> Result<()> {
    section("Key-value & badges")?;
    KeyValue::new()
        .add("Version", "0.1.0")
        .add("License", "MIT")
        .print()?;
    println!();
    Rendered::new(vec![Line::new(vec![
        Badge::new("PASS")
            .style(Style::new().fg(Color::Green).bold())
            .span(),
        Span::raw(" "),
        Badge::new("WARN")
            .style(Style::new().fg(Color::Yellow).bold())
            .span(),
        Span::raw(" "),
        Badge::new("v0.1").caps("(", ")").span(),
    ])])
    .print()?;
    Ok(())
}

examples/output-readme.rs (line 175)

fn right_column() -> Rendered {
    let kv = KeyValue::new()
        .key_style(Style::new().fg(Color::Cyan).bold())
        .value_style(Style::new())
        .add("host", "localhost")
        .add("port", "8080")
        .add("scheme", "https")
        .add("timeout", "30s")
        .render(24);

    let badge = |text: &str, color: Color| {
        Badge::new(text)
            .pad(1)
            .style(Style::new().fg(Color::Black).bg(color).bold())
            .span()
    };
    let badges = Rendered::new(vec![
        Line::new(vec![
            badge("DONE", Color::Green),
            Span::raw(" "),
            badge("INFO", Color::LightBlue),
        ]),
        Line::default(),
        Line::new(vec![
            badge("WARN", Color::Yellow),
            Span::raw(" "),
            badge("FAIL", Color::Red),
        ]),
    ]);

    let label = |text: &str| {
        Rendered::new(vec![Line::styled(
            text,
            Style::new().fg(Color::Cyan).bold(),
        )])
    };
    let staggered = Columns::new()
        .add_rendered(label("Col 1"))
        .add_rendered(vstack(&[blank(), label("Col 2")], 0))
        .add_rendered(vstack(&[blank(), blank(), label("Col 3")], 0))
        .gap(2)
        .separator(BorderType::Single)
        .render(40);

    vstack(&[kv, blank(), badges, blank(), staggered], 0)
}

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

Sets the separator between key and value.

pub fn key_width(self, width: u16) -> Self

Sets a fixed key column width.

pub fn key_style(self, style: Style) -> Self

Sets the key style.

Examples found in repository

examples/output-readme.rs (line 173)

fn right_column() -> Rendered {
    let kv = KeyValue::new()
        .key_style(Style::new().fg(Color::Cyan).bold())
        .value_style(Style::new())
        .add("host", "localhost")
        .add("port", "8080")
        .add("scheme", "https")
        .add("timeout", "30s")
        .render(24);

    let badge = |text: &str, color: Color| {
        Badge::new(text)
            .pad(1)
            .style(Style::new().fg(Color::Black).bg(color).bold())
            .span()
    };
    let badges = Rendered::new(vec![
        Line::new(vec![
            badge("DONE", Color::Green),
            Span::raw(" "),
            badge("INFO", Color::LightBlue),
        ]),
        Line::default(),
        Line::new(vec![
            badge("WARN", Color::Yellow),
            Span::raw(" "),
            badge("FAIL", Color::Red),
        ]),
    ]);

    let label = |text: &str| {
        Rendered::new(vec![Line::styled(
            text,
            Style::new().fg(Color::Cyan).bold(),
        )])
    };
    let staggered = Columns::new()
        .add_rendered(label("Col 1"))
        .add_rendered(vstack(&[blank(), label("Col 2")], 0))
        .add_rendered(vstack(&[blank(), blank(), label("Col 3")], 0))
        .gap(2)
        .separator(BorderType::Single)
        .render(40);

    vstack(&[kv, blank(), badges, blank(), staggered], 0)
}

pub fn value_style(self, style: Style) -> Self

Sets the value style.

Examples found in repository

examples/output-readme.rs (line 174)

fn right_column() -> Rendered {
    let kv = KeyValue::new()
        .key_style(Style::new().fg(Color::Cyan).bold())
        .value_style(Style::new())
        .add("host", "localhost")
        .add("port", "8080")
        .add("scheme", "https")
        .add("timeout", "30s")
        .render(24);

    let badge = |text: &str, color: Color| {
        Badge::new(text)
            .pad(1)
            .style(Style::new().fg(Color::Black).bg(color).bold())
            .span()
    };
    let badges = Rendered::new(vec![
        Line::new(vec![
            badge("DONE", Color::Green),
            Span::raw(" "),
            badge("INFO", Color::LightBlue),
        ]),
        Line::default(),
        Line::new(vec![
            badge("WARN", Color::Yellow),
            Span::raw(" "),
            badge("FAIL", Color::Red),
        ]),
    ]);

    let label = |text: &str| {
        Rendered::new(vec![Line::styled(
            text,
            Style::new().fg(Color::Cyan).bold(),
        )])
    };
    let staggered = Columns::new()
        .add_rendered(label("Col 1"))
        .add_rendered(vstack(&[blank(), label("Col 2")], 0))
        .add_rendered(vstack(&[blank(), blank(), label("Col 3")], 0))
        .gap(2)
        .separator(BorderType::Single)
        .render(40);

    vstack(&[kv, blank(), badges, blank(), staggered], 0)
}

pub fn item_gap(self, gap: u16) -> Self

Sets the number of blank lines between pairs.

pub fn wrap_values(self, wrap: bool) -> Self

Enables wrapping of long values.

pub fn margin(self, margin: Edges) -> Self

Sets the outer margin.

Trait Implementations

impl Default for KeyValue

fn default() -> Self

Returns the “default value” for a type.

impl Renderable for KeyValue

fn render(&self, max_width: u16) -> Rendered

Lays the value out for a terminal at most max_width columns wide.

fn print(&self) -> Result<()>

Renders at the current terminal width and prints to standard output.

fn print_to<W: Write>(&self, writer: &mut W) -> Result<()>

Renders at the current terminal width and writes to writer.