Struct Style 

pub struct Style { /* private fields */ }

A terminal text style with colors, attributes, and links.

Implementations

impl Style

pub fn new( color: Option<&str>, bgcolor: Option<&str>, bold: Option<bool>, dim: Option<bool>, italic: Option<bool>, underline: Option<bool>, blink: Option<bool>, blink2: Option<bool>, reverse: Option<bool>, conceal: Option<bool>, strike: Option<bool>, underline2: Option<bool>, frame: Option<bool>, encircle: Option<bool>, overline: Option<bool>, link: Option<&str>, ) -> Result<Self, StyleError>

Creates a new style with specified attributes.

pub fn null() -> Self

Creates an empty null style with no attributes set.

pub fn from_color(color: Option<Color>, bgcolor: Option<Color>) -> Self

Creates a style from optional colors.

pub fn parse(definition: &str) -> Self

Parses a style definition string. Lossy: returns Style::null on any parse error.

This is the recommended entry point for the common case of literal style strings ("bold red", "on blue", …) where a parse failure indicates a programming bug, not a recoverable runtime condition. For static literals there is nothing meaningful to do with an error at the callsite — the lossy form removes the boilerplate unwrap_or_else(|_| Style::null()) that wrapped almost every previous use.

When to use parse_strict instead

• You’re parsing user-supplied style strings (config files, CLI flags) and want to surface a syntax error.
• You want to write a unit test that verifies a particular input fails to parse.

Examples

use gilt::style::Style;

let bold_red = Style::parse("bold red");          // no `?`, no `.unwrap()`
let same     = Style::parse("BOLD RED");          // case-insensitive keywords
let null     = Style::parse("not a real style");  // returns Style::null(), no panic
assert!(null.is_null());

pub fn parse_strict(definition: &str) -> Result<Self, StyleError>

Parses a style definition string. Strict: returns the parse error if the input is malformed.

Prefer parse for the common case where a parse failure indicates a programming bug, not a recoverable runtime condition.

Grammar

• Words are split by whitespace
• "on" keyword: next word is background color
• "not" keyword: next word is attribute name, set to false
• "link" keyword: next word is URL
• Known attribute names with aliases
• Anything else: try as foreground color

pub fn bold(&self) -> Option<bool>

Returns the bold attribute.

pub fn dim(&self) -> Option<bool>

Returns the dim attribute.

pub fn italic(&self) -> Option<bool>

Returns the italic attribute.

pub fn underline(&self) -> Option<bool>

Returns the underline attribute.

pub fn blink(&self) -> Option<bool>

Returns the blink attribute.

pub fn blink2(&self) -> Option<bool>

Returns the blink2 attribute.

pub fn reverse(&self) -> Option<bool>

Returns the reverse attribute.

pub fn conceal(&self) -> Option<bool>

Returns the conceal attribute.

pub fn strike(&self) -> Option<bool>

Returns the strike attribute.

pub fn underline2(&self) -> Option<bool>

Returns the underline2 attribute.

pub fn frame(&self) -> Option<bool>

Returns the frame attribute.

pub fn encircle(&self) -> Option<bool>

Returns the encircle attribute.

pub fn overline(&self) -> Option<bool>

Returns the overline attribute.

pub fn color(&self) -> Option<&Color>

Returns the foreground color.

pub fn bgcolor(&self) -> Option<&Color>

Returns the background color.

pub fn link(&self) -> Option<&str>

Returns the link URL.

pub fn underline_color(&self) -> Option<&Color>

Returns the underline color.

pub fn underline_style(&self) -> Option<UnderlineStyle>

Returns the underline style.

pub fn set_bold(&mut self, value: Option<bool>)

Sets the bold attribute.

pub fn set_dim(&mut self, value: Option<bool>)

Sets the dim attribute.

pub fn set_italic(&mut self, value: Option<bool>)

Sets the italic attribute.

pub fn set_underline(&mut self, value: Option<bool>)

Sets the underline attribute.

pub fn set_blink(&mut self, value: Option<bool>)

Sets the blink attribute.

pub fn set_reverse(&mut self, value: Option<bool>)

Sets the reverse attribute.

pub fn set_conceal(&mut self, value: Option<bool>)

Sets the conceal attribute.

pub fn set_strike(&mut self, value: Option<bool>)

Sets the strike attribute.

pub fn set_underline_color(&mut self, color: Option<Color>)

Sets the underline color.

pub fn set_underline_style(&mut self, style: Option<UnderlineStyle>)

Sets the underline style.

pub fn combine(styles: &[Style]) -> Style

Combines multiple styles into one (left-to-right merge).

Prefer Style::combine_refs in hot paths — combine clones each input on the way through Add<Style>. The reference-based variant avoids the per-step clone.

pub fn chain(styles: &[Style]) -> Style

Alias for Style::combine matching Python rich’s Style.chain.

Applies each style left-to-right; later styles override earlier ones for conflicting attributes.

pub fn normalize(&self) -> String

Returns the canonical string form of this style.

Equivalent to formatting and re-parsing: Style::parse(&format!("{}", self)). Useful for normalising user-supplied style strings (config, CLI flags) to a canonical representation.

Mirrors Python rich’s Style.normalize(definition).

pub fn combine_refs<'a, I>(styles: I) -> Style

where I: IntoIterator<Item = &'a Style>,

Like Style::combine but iterates over references — avoids the per-step Style.clone() that the by-value Add<Style> impl forces.

Used by the per-segment span-rendering loop in Text where the same active span set is consulted thousands of times per render.

pub fn render_no_link( &self, text: &str, color_system: Option<ColorSystem>, ) -> String

Renders text with this style as ANSI escape sequences. Render text with this style’s SGR codes (color, bold, etc.) but without wrapping in an OSC 8 hyperlink even if self.link is set.

Used by Console::render_buffer when it has decided to coalesce a run of consecutive same-link segments under a single OSC 8 wrapper.

Returns plain text when color_system is None or text is empty.

pub fn render(&self, text: &str, color_system: Option<ColorSystem>) -> String

pub fn pick_first(candidates: &[Option<&Style>]) -> Style

Pick the first non-null style from the candidate list, or Style::null if every candidate is null/None.

Mirrors rich’s Style.pick_first(*candidates) — useful in render pipelines that select among theme / row / column / cell style overrides.

pub fn is_null(&self) -> bool

Returns true if this is a null style (nothing set).

pub fn without_color(&self) -> Style

Returns a copy of this style without colors.

pub fn background_style(&self) -> Style

Returns a style with only the background color.

pub fn clear_meta_and_links(&self) -> Style

Returns a copy without metadata and links.

pub fn with_link(url: &str) -> Style

Returns a copy of this style with the given hyperlink URL.

pub fn update_link(&self, link: Option<&str>) -> Style

Returns a copy with an updated link.

pub fn get_html_style(&self, theme: Option<&TerminalTheme>) -> String

Returns a CSS style string for HTML rendering.

Trait Implementations

impl Add for Style

type Output = Style

The resulting type after applying the + operator.

fn add(self, rhs: Style) -> Style

Performs the + operation.

impl Add<Option<Style>> for Style

type Output = Style

The resulting type after applying the + operator.

fn add(self, rhs: Option<Style>) -> Style

Performs the + operation.

impl Clone for Style

fn clone(&self) -> Style

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Style

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

Formats the value using the given formatter.

impl Display for Style

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

Formats the value using the given formatter.

impl Eq for Style

impl Hash for Style

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Style

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.