Struct roff::Roff

pub struct Roff { /* fields omitted */ }

A ROFF document, consisting of lines.

Lines are either control lines (requests that are built in, or invocations of macros), or text lines.

Example

let doc = Roff::new()
    .control("TH", ["FOO", "1"])
    .control("SH", ["NAME"])
    .text([roman("foo - do a foo thing")])
    .render();
assert!(doc.ends_with(".TH FOO 1\n.SH NAME\nfoo \\- do a foo thing\n"));

Implementations

impl Roff

pub fn new() -> Self

Instantiate a Roff

pub fn control<'a>(
    &mut self,
    name: impl Into<String>,
    args: impl IntoIterator<Item = &'a str>
) -> &mut Self

Append a control line.

The line consist of the name of a built-in command or macro, and some number of arguments. Arguments that contain spaces will be enclosed with double quotation marks.

pub fn text(&mut self, inlines: impl Into<Vec<Inline>>) -> &mut Self

Append a text line.

The line will be rendered in a way that ensures it can’t be interpreted as a control line. The caller does not need to ensure, for example, that the line doesn’t start with a period (“.”) or an apostrophe (“'”).

pub fn render(&self) -> String

Render as ROFF source text that can be fed to a ROFF implementation.

pub fn to_writer(&self, w: &mut dyn Write) -> Result<(), Error>

Write to a writer.

pub fn to_roff(&self) -> String

Render without handling apostrophes specially.

You probably want render or to_writer instead of this method.

Without special handling, apostrophes get typeset as right single quotes, including in words like “don’t”. In most situations, such as in manual pages, that’s unwanted. The other methods handle apostrophes specially to prevent it, but for completeness, and for testing, this method is provided to avoid it.

Trait Implementations

impl Debug for Roff

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

Formats the value using the given formatter.

impl Default for Roff

fn default() -> Roff

Returns the “default value” for a type.

impl<R: Into<Roff>> Extend<R> for Roff

fn extend<T: IntoIterator<Item = R>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<I: Into<Inline>> From<I> for Roff

fn from(other: I) -> Self

Performs the conversion.

impl<R: Into<Roff>> FromIterator<R> for Roff

fn from_iter<I: IntoIterator<Item = R>>(iter: I) -> Self

Creates a value from an iterator.

impl PartialEq<Roff> for Roff

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

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

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

This method tests for !=.

impl Eq for Roff

impl StructuralEq for Roff

impl StructuralPartialEq for Roff