Struct pretty_assertions::Style

pub struct Style {
    pub foreground: Option<Colour>,
    pub background: Option<Colour>,
    pub is_bold: bool,
    pub is_dimmed: bool,
    pub is_italic: bool,
    pub is_underline: bool,
    pub is_blink: bool,
    pub is_reverse: bool,
    pub is_hidden: bool,
    pub is_strikethrough: bool,
}

A style is a collection of properties that can format a string using ANSI escape codes.

Fields

foreground: Option<Colour>

The style's foreground colour, if it has one.

background: Option<Colour>

The style's background colour, if it has one.

is_bold: bool

Whether this style is bold.

is_dimmed: bool

Whether this style is dimmed.

is_italic: bool

Whether this style is italic.

is_underline: bool

Whether this style is underlined.

is_blink: bool

Whether this style is blinking.

is_reverse: bool

Whether this style has reverse colours.

is_hidden: bool

Whether this style is hidden.

is_strikethrough: bool

Whether this style is struckthrough.

Methods

impl Style

pub fn prefix(self) -> Prefix

The prefix for this style.

pub fn infix(self, other: Style) -> Infix

The infix between this style and another.

pub fn suffix(self) -> Suffix

The suffix for this style.

impl Style

pub fn new() -> Style

Creates a new Style with no differences.

pub fn bold(&self) -> Style

Returns a Style with the bold property set.

pub fn dimmed(&self) -> Style

Returns a Style with the dimmed property set.

pub fn italic(&self) -> Style

Returns a Style with the italic property set.

pub fn underline(&self) -> Style

Returns a Style with the underline property set.

pub fn blink(&self) -> Style

Returns a Style with the blink property set.

pub fn reverse(&self) -> Style

Returns a Style with the reverse property set.

pub fn hidden(&self) -> Style

Returns a Style with the hidden property set.

pub fn strikethrough(&self) -> Style

Returns a Style with the hidden property set.

pub fn fg(&self, foreground: Colour) -> Style

Returns a Style with the foreground colour property set.

pub fn on(&self, background: Colour) -> Style

Returns a Style with the background colour property set.

pub fn is_plain(self) -> bool

Return true if this Style has no actual styles, and can be written without any control characters.

impl Style

pub fn paint<'a, I, S>(self, input: I) -> ANSIGenericString<'a, S> where
    I: Into<Cow<'a, S>>,
    S: 'a + ToOwned + ?Sized,
    <S as ToOwned>::Owned: Debug, 

Paints the given text with this colour, returning an ANSI string.

Trait Implementations

impl Clone for Style

fn clone(&self) -> Style

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Style

impl Default for Style

fn default() -> Style

Returns a style with no properties set. Formatting text using this style returns the exact same text.

use ansi_term::Style;
assert_eq!(None,  Style::default().foreground);
assert_eq!(None,  Style::default().background);
assert_eq!(false, Style::default().is_bold);
assert_eq!("txt", Style::default().paint("txt").to_string());

impl From<Colour> for Style

fn from(colour: Colour) -> Style

You can turn a Colour into a Style with the foreground colour set with the From trait.

use ansi_term::{Style, Colour};
let green_foreground = Style::default().fg(Colour::Green);
assert_eq!(green_foreground, Colour::Green.normal());
assert_eq!(green_foreground, Colour::Green.into());
assert_eq!(green_foreground, Style::from(Colour::Green));

impl PartialEq<Style> for Style

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Debug for Style

Styles have a special Debug implementation that only shows the fields that are set. Fields that haven’t been touched aren’t included in the output.

This behaviour gets bypassed when using the alternate formatting mode format!("{:#?}").

use ansi_term::Colour::{Red, Blue};
assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
           format!("{:?}", Red.on(Blue).bold().italic()));

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.