Struct FormatterBuilder

pub struct FormatterBuilder<'a> { /* private fields */ }

A builder to create a Formatter.

See the documentation of Formatter for a usage example.

Implementations

impl<'a> FormatterBuilder<'a>

pub fn indent(self, indent: &'a [u8]) -> Self

Set the indent for indenting nested HCL structures.

The default indentation is two spaces.

pub fn dense(self, yes: bool) -> Self

If set, blocks are not visually separated by empty lines from attributes and adjacent blocks.

Default formatting:

attr1 = "value1"
attr2 = "value2"

block1 {}

block2 {}

Dense formatting:

attr1 = "value1"
attr2 = "value2"
block1 {}
block2 {}

pub fn compact(self, yes: bool) -> Self

If set, arrays and objects are formatted in a more compact way.

See the method documation of compact_arrays and compact_objects.

pub fn compact_arrays(self, yes: bool) -> Self

Controls the array formatting.

By default, array elements are separated by newlines:

array = [
  1,
  2,
  3,
]

When compact array formatting is enabled no newlines are inserted between elements:

array = [1, 2, 3]

pub fn compact_objects(self, yes: bool) -> Self

Controls the object formatting.

By default, object items are separated by newlines:

object = {
  one = "foo"
  two = "bar"
  three = "baz"
}

When compact object formatting is enabled no newlines are inserted between items:

object = { one = "foo", two = "bar", three = "baz" }

pub fn prefer_ident_keys(self, yes: bool) -> Self

Controls the object key quoting.

By default, object keys are formatted as quoted strings (unless they are of variant ObjectKey::Identifier).

object = {
  "foo" = 1
  "bar baz" = 2
}

When identifier keys are preferred, object keys that are also valid HCL identifiers are not quoted:

object = {
  foo = 1
  "bar baz" = 2
}

pub fn build<W>(self, writer: W) -> Formatter<'a, W>

where W: Write,

Consumes the FormatterBuilder and turns it into a Formatter which writes HCL to the provided writer.

pub fn build_vec(self) -> Formatter<'a, Vec<u8>>

Consumes the FormatterBuilder and turns it into a Formatter which is specialized to use a pre-allocated Vec<u8> as internal buffer.

The returned formatter can be passed to the format_string or format_vec method of types implementing Format.

Alternatively, the internal buffer can be obtained by calling into_inner on the returned Formatter after passing it to the format method of a type implementing Format.

Examples

use hcl::format::{Format, Formatter};
use hcl::structure::Attribute;

let mut formatter = Formatter::builder()
    .compact_arrays(true)
    .build_vec();

let attr = Attribute::new("foo", vec![1, 2, 3]);

assert_eq!(attr.format_string(&mut formatter)?, "foo = [1, 2, 3]\n");