Struct biome_formatter::PreambleBuffer

pub struct PreambleBuffer<'buf, Preamble, Context> { /* private fields */ }

This struct wraps an existing buffer and emits a preamble text when the first text is written.

This can be useful if you, for example, want to write some content if what gets written next isn’t empty.

Examples

use biome_formatter::{FormatState, Formatted, PreambleBuffer, SimpleFormatContext, VecBuffer, write};
use biome_formatter::prelude::*;

struct Preamble;

impl Format<SimpleFormatContext> for Preamble {
    fn fmt(&self, f: &mut Formatter<SimpleFormatContext>) -> FormatResult<()> {
        write!(f, [text("# heading"), hard_line_break()])
    }
}

let mut state = FormatState::new(SimpleFormatContext::default());
let mut buffer = VecBuffer::new(&mut state);

{
    let mut with_preamble = PreambleBuffer::new(&mut buffer, Preamble);

    write!(&mut with_preamble, [text("this text will be on a new line")])?;
}

let formatted = Formatted::new(Document::from(buffer.into_vec()), SimpleFormatContext::default());
assert_eq!("# heading\nthis text will be on a new line", formatted.print()?.as_code());

The pre-amble does not get written if no content is written to the buffer.

use biome_formatter::{FormatState, Formatted, PreambleBuffer, SimpleFormatContext, VecBuffer, write};
use biome_formatter::prelude::*;

struct Preamble;

impl Format<SimpleFormatContext> for Preamble {
    fn fmt(&self, f: &mut Formatter<SimpleFormatContext>) -> FormatResult<()> {
        write!(f, [text("# heading"), hard_line_break()])
    }
}

let mut state = FormatState::new(SimpleFormatContext::default());
let mut buffer = VecBuffer::new(&mut state);
{
    let mut with_preamble = PreambleBuffer::new(&mut buffer, Preamble);
}

let formatted = Formatted::new(Document::from(buffer.into_vec()), SimpleFormatContext::default());
assert_eq!("", formatted.print()?.as_code());

Implementations

impl<'buf, Preamble, Context> PreambleBuffer<'buf, Preamble, Context>

pub fn new( inner: &'buf mut dyn Buffer<Context = Context>, preamble: Preamble ) -> Self

pub fn did_write_preamble(&self) -> bool

Returns true if the preamble has been written, false otherwise.

Trait Implementations

impl<Preamble, Context> Buffer for PreambleBuffer<'_, Preamble, Context>

where Preamble: Format<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.