Struct biome_formatter::RemoveSoftLinesBuffer

pub struct RemoveSoftLinesBuffer<'a, Context> { /* private fields */ }

A Buffer that removes any soft line breaks.

• Removes lines with the mode Soft.
• Replaces lines with the mode Soft with a Space

Examples

use biome_formatter::prelude::*;
use biome_formatter::{format, write};

use biome_formatter::{RemoveSoftLinesBuffer, SimpleFormatContext, VecBuffer};
use biome_formatter::prelude::format_with;
let formatted = format!(
    SimpleFormatContext::default(),
    [format_with(|f| {
        let mut buffer = RemoveSoftLinesBuffer::new(f);

        write!(
            buffer,
            [
                text("The next soft line or space gets replaced by a space"),
                soft_line_break_or_space(),
                text("and the line here"),
                soft_line_break(),
                text("is removed entirely.")
            ]
        )
    })]
)?;

assert_eq!(
    formatted.document().as_ref(),
    &[
        FormatElement::StaticText { text: "The next soft line or space gets replaced by a space" },
        FormatElement::Space,
        FormatElement::StaticText { text: "and the line here" },
        FormatElement::StaticText { text: "is removed entirely." }
    ]
);

Implementations

impl<'a, Context> RemoveSoftLinesBuffer<'a, Context>

pub fn new(inner: &'a mut dyn Buffer<Context = Context>) -> Self

Creates a new buffer that removes the soft line breaks before writing them into buffer.

Trait Implementations

impl<Context> Buffer for RemoveSoftLinesBuffer<'_, Context>

type Context = Context

The context used during formatting

fn write_element(&mut self, element: FormatElement) -> FormatResult<()>

Writes a crate::FormatElement into this buffer, returning whether the write succeeded.

fn state(&self) -> &FormatState<Self::Context>

Returns the formatting state relevant for this formatting session.

fn state_mut(&mut self) -> &mut FormatState<Self::Context>

Returns the mutable formatting state relevant for this formatting session.

fn snapshot(&self) -> BufferSnapshot

Takes a snapshot of the Buffers state, excluding the formatter state.

fn restore_snapshot(&mut self, snapshot: BufferSnapshot)

Restores the snapshot buffer

fn write_fmt( &mut self, arguments: Arguments<'_, Self::Context> ) -> FormatResult<()>

Glue for usage of the write! macro with implementors of this trait.