Struct linurgy::LinurgyBuilder

pub struct LinurgyBuilder<'a, 'b, 'c> { /* fields omitted */ }

Use this to prepare and execute linurgy editing on a stream.

A linurgy consists of an Input, which will be read line by line, edited by user defined rules, and then streamed into an Output.

Methods

impl<'a, 'b, 'c> LinurgyBuilder<'a, 'b, 'c>

pub fn new() -> Self

Instantiate a new builder with default values.

• Input: Input::StdIn,
• Output: Output::StdOut,
• Newline count trigger: 2,
• New text : "-------\n",
• EditType: EditType::Append

This will read from stdin, add dashes after 2 empty lines, and write to stdout.

pub fn set_input(&mut self, input: Input<'a>) -> &mut Self

Set the input source to read text from.

Examples

Using an in-memory Buffer

let text = String::from("Sample text\n\n\n");
let mut linurgy = LinurgyBuilder::new();

linurgy.set_input(Input::Buffer(&text));

Read from a File

let mut linurgy = LinurgyBuilder::new();
 
linurgy.set_input(Input::File("filename.txt"));

pub fn set_output(&mut self, output: Output<'b>) -> &mut Self

Set the output stream to write to.

Examples

Using an in-memory Buffer

let mut buffer = String::new();
let mut linurgy = LinurgyBuilder::new();

linurgy.set_output(Output::Buffer(&mut buffer));

Write straight to a File

let mut linurgy = LinurgyBuilder::new();
 
linurgy.set_output(Output::File("filename.txt"));

pub fn set_newline_trigger(&mut self, count: u8) -> &mut Self

Set the newline count to trigger editing.

Example

Add edit string after every 5 empty lines

let mut linurgy = LinurgyBuilder::new();
linurgy.set_newline_trigger(5);

pub fn set_new_text(&mut self, new_text: &'c str) -> &mut Self

Set the text that will be used when the newline trigger is reached.

Example

Add a line of dots after every empty line

let mut linurgy = LinurgyBuilder::new();
let new_text = format!("{}\n", ". ".repeat(25));
 
linurgy.set_newline_trigger(1);
linurgy.set_new_text(&new_text);

pub fn set_edit_type(&mut self, edit_type: EditType) -> &mut Self

Set how new text is added after the newline trigger is reached.

Example

Replace double empty lines with a line of dashes

let mut linurgy = LinurgyBuilder::new();
linurgy.set_edit_type(EditType::Replace);

pub fn run(&mut self) -> &mut Self

Execute the linurgy edits on the specified input stream.

This function will block until the input stream is exhausted. If the input stream is Input::StdIn, then stdin will be locked while this function runs. If stdin is locked elsewhere, this function will block until it becomes available again.

Panics

This function will panic if the input file in unable to be opened or read from, or if the output file is unable to be created or written to.

Examples

Execute default behaviour and add dashes to double newlines from stdin

LinurgyBuilder::new().run();

This will panic if "not-a-file" does not exist

LinurgyBuilder::new()
    .set_input(Input::File("not-a-file"))
    .run();

Trait Implementations

impl<'_, '_, '_> Default for LinurgyBuilder<'_, '_, '_>

fn default() -> Self

Returns the "default value" for a type.