Struct WrapOptionsBuilder 

pub struct WrapOptionsBuilder { /* private fields */ }

🏗️ Fluent builder for creating WrapOptions with a clean, readable interface.

This builder provides a more ergonomic way to configure wrapping options compared to struct initialization, especially when you only need to change a few settings from the defaults.

Examples

Basic Usage

use wrap_ansi::WrapOptions;

let options = WrapOptions::builder()
    .hard_wrap(true)
    .build();

Method Chaining

use wrap_ansi::{wrap_ansi, WrapOptions};

let result = wrap_ansi(
    "Some long text that needs wrapping",
    15,
    Some(WrapOptions::builder()
        .hard_wrap(true)
        .trim_whitespace(false)
        .word_wrap(true)
        .build())
);

Conditional Configuration

use wrap_ansi::WrapOptions;

let preserve_formatting = true;
let strict_width = false;

let options = WrapOptions::builder()
    .trim_whitespace(!preserve_formatting)
    .hard_wrap(strict_width)
    .build();

Implementations

impl WrapOptionsBuilder

pub const fn hard_wrap(self, enabled: bool) -> Self

⚡ Configure hard wrapping behavior.

When enabled, long words that exceed the column limit will be broken at the boundary. When disabled (default), long words move to the next line.

Examples

use wrap_ansi::WrapOptions;

let strict = WrapOptions::builder().hard_wrap(true).build();
let flexible = WrapOptions::builder().hard_wrap(false).build();

Examples found in repository

examples/improved_features.rs (line 9)

fn main() -> Result<(), WrapError> {
    println!("=== Wrap-ANSI Improved Features Demo ===\n");

    // 1. Builder Pattern for Options
    println!("1. Builder Pattern for Options:");
    let options = WrapOptions::builder()
        .hard_wrap(true)
        .trim_whitespace(false)
        .word_wrap(true)
        .build();

    let text = "This is a verylongwordthatexceedslimit example";
    let wrapped = wrap_ansi(text, 15, Some(options));
    println!("Input: {}", text);
    println!("Output:\n{}\n", wrapped);

    // 2. Error Handling with Input Validation
    println!("2. Error Handling:");

    // Valid input
    match wrap_ansi_checked("Hello world", 10, None) {
        Ok(result) => println!("Valid input wrapped: {}", result.replace('\n', "\\n")),
        Err(e) => println!("Error: {}", e),
    }

    // Invalid column width
    match wrap_ansi_checked("Hello world", 0, None) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Expected error: {}", e),
    }

    // Large input (simulated)
    let large_text = "x".repeat(100);
    match wrap_ansi_checked(&large_text, 10, None) {
        Ok(result) => println!(
            "Large input handled: {} chars -> {} chars",
            large_text.len(),
            result.len()
        ),
        Err(e) => println!("Error with large input: {}", e),
    }

    println!();

    // 3. ANSI Color Preservation with Named Constants
    println!("3. ANSI Color Preservation:");
    let colored_text =
        "\u{001B}[31mThis is red text that will be wrapped across multiple lines\u{001B}[39m";
    let wrapped_colored = wrap_ansi(colored_text, 20, None);
    println!("Colored text wrapped:");
    println!("{}", wrapped_colored);
    println!();

    // 4. Hyperlink Preservation
    println!("4. Hyperlink Preservation:");
    let hyperlink_text = "\u{001B}]8;;https://example.com\u{0007}This is a clickable link that spans multiple lines\u{001B}]8;;\u{0007}";
    let wrapped_hyperlink = wrap_ansi(hyperlink_text, 15, None);
    println!("Hyperlink text wrapped:");
    println!("{}", wrapped_hyperlink);
    println!();

    // 5. Performance with Complex ANSI Sequences
    println!("5. Complex ANSI Sequences:");
    let complex_text =
        "\u{001B}[31m\u{001B}[42mRed text on green background\u{001B}[39m\u{001B}[49m normal text";
    let wrapped_complex = wrap_ansi(complex_text, 12, None);
    println!("Complex ANSI wrapped:");
    println!("{}", wrapped_complex);
    println!();

    // 6. Unicode Support
    println!("6. Unicode Support:");
    let unicode_text = "Hello 世界 🌍 こんにちは";
    let wrapped_unicode = wrap_ansi(unicode_text, 10, None);
    println!("Unicode text wrapped:");
    println!("{}", wrapped_unicode);

    Ok(())
}

pub const fn trim_whitespace(self, enabled: bool) -> Self

🧹 Configure whitespace trimming behavior.

When enabled (default), leading and trailing whitespace is removed from wrapped lines. When disabled, all whitespace is preserved.

Examples

use wrap_ansi::WrapOptions;

let clean = WrapOptions::builder().trim_whitespace(true).build();
let preserve = WrapOptions::builder().trim_whitespace(false).build();

Examples found in repository

examples/improved_features.rs (line 10)

fn main() -> Result<(), WrapError> {
    println!("=== Wrap-ANSI Improved Features Demo ===\n");

    // 1. Builder Pattern for Options
    println!("1. Builder Pattern for Options:");
    let options = WrapOptions::builder()
        .hard_wrap(true)
        .trim_whitespace(false)
        .word_wrap(true)
        .build();

    let text = "This is a verylongwordthatexceedslimit example";
    let wrapped = wrap_ansi(text, 15, Some(options));
    println!("Input: {}", text);
    println!("Output:\n{}\n", wrapped);

    // 2. Error Handling with Input Validation
    println!("2. Error Handling:");

    // Valid input
    match wrap_ansi_checked("Hello world", 10, None) {
        Ok(result) => println!("Valid input wrapped: {}", result.replace('\n', "\\n")),
        Err(e) => println!("Error: {}", e),
    }

    // Invalid column width
    match wrap_ansi_checked("Hello world", 0, None) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Expected error: {}", e),
    }

    // Large input (simulated)
    let large_text = "x".repeat(100);
    match wrap_ansi_checked(&large_text, 10, None) {
        Ok(result) => println!(
            "Large input handled: {} chars -> {} chars",
            large_text.len(),
            result.len()
        ),
        Err(e) => println!("Error with large input: {}", e),
    }

    println!();

    // 3. ANSI Color Preservation with Named Constants
    println!("3. ANSI Color Preservation:");
    let colored_text =
        "\u{001B}[31mThis is red text that will be wrapped across multiple lines\u{001B}[39m";
    let wrapped_colored = wrap_ansi(colored_text, 20, None);
    println!("Colored text wrapped:");
    println!("{}", wrapped_colored);
    println!();

    // 4. Hyperlink Preservation
    println!("4. Hyperlink Preservation:");
    let hyperlink_text = "\u{001B}]8;;https://example.com\u{0007}This is a clickable link that spans multiple lines\u{001B}]8;;\u{0007}";
    let wrapped_hyperlink = wrap_ansi(hyperlink_text, 15, None);
    println!("Hyperlink text wrapped:");
    println!("{}", wrapped_hyperlink);
    println!();

    // 5. Performance with Complex ANSI Sequences
    println!("5. Complex ANSI Sequences:");
    let complex_text =
        "\u{001B}[31m\u{001B}[42mRed text on green background\u{001B}[39m\u{001B}[49m normal text";
    let wrapped_complex = wrap_ansi(complex_text, 12, None);
    println!("Complex ANSI wrapped:");
    println!("{}", wrapped_complex);
    println!();

    // 6. Unicode Support
    println!("6. Unicode Support:");
    let unicode_text = "Hello 世界 🌍 こんにちは";
    let wrapped_unicode = wrap_ansi(unicode_text, 10, None);
    println!("Unicode text wrapped:");
    println!("{}", wrapped_unicode);

    Ok(())
}

pub const fn word_wrap(self, enabled: bool) -> Self

🔤 Configure word boundary respect.

When enabled (default), text wraps at word boundaries (spaces). When disabled, text can wrap at any character position.

Examples

use wrap_ansi::WrapOptions;

let word_aware = WrapOptions::builder().word_wrap(true).build();
let char_level = WrapOptions::builder().word_wrap(false).build();

Examples found in repository

examples/improved_features.rs (line 11)

fn main() -> Result<(), WrapError> {
    println!("=== Wrap-ANSI Improved Features Demo ===\n");

    // 1. Builder Pattern for Options
    println!("1. Builder Pattern for Options:");
    let options = WrapOptions::builder()
        .hard_wrap(true)
        .trim_whitespace(false)
        .word_wrap(true)
        .build();

    let text = "This is a verylongwordthatexceedslimit example";
    let wrapped = wrap_ansi(text, 15, Some(options));
    println!("Input: {}", text);
    println!("Output:\n{}\n", wrapped);

    // 2. Error Handling with Input Validation
    println!("2. Error Handling:");

    // Valid input
    match wrap_ansi_checked("Hello world", 10, None) {
        Ok(result) => println!("Valid input wrapped: {}", result.replace('\n', "\\n")),
        Err(e) => println!("Error: {}", e),
    }

    // Invalid column width
    match wrap_ansi_checked("Hello world", 0, None) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Expected error: {}", e),
    }

    // Large input (simulated)
    let large_text = "x".repeat(100);
    match wrap_ansi_checked(&large_text, 10, None) {
        Ok(result) => println!(
            "Large input handled: {} chars -> {} chars",
            large_text.len(),
            result.len()
        ),
        Err(e) => println!("Error with large input: {}", e),
    }

    println!();

    // 3. ANSI Color Preservation with Named Constants
    println!("3. ANSI Color Preservation:");
    let colored_text =
        "\u{001B}[31mThis is red text that will be wrapped across multiple lines\u{001B}[39m";
    let wrapped_colored = wrap_ansi(colored_text, 20, None);
    println!("Colored text wrapped:");
    println!("{}", wrapped_colored);
    println!();

    // 4. Hyperlink Preservation
    println!("4. Hyperlink Preservation:");
    let hyperlink_text = "\u{001B}]8;;https://example.com\u{0007}This is a clickable link that spans multiple lines\u{001B}]8;;\u{0007}";
    let wrapped_hyperlink = wrap_ansi(hyperlink_text, 15, None);
    println!("Hyperlink text wrapped:");
    println!("{}", wrapped_hyperlink);
    println!();

    // 5. Performance with Complex ANSI Sequences
    println!("5. Complex ANSI Sequences:");
    let complex_text =
        "\u{001B}[31m\u{001B}[42mRed text on green background\u{001B}[39m\u{001B}[49m normal text";
    let wrapped_complex = wrap_ansi(complex_text, 12, None);
    println!("Complex ANSI wrapped:");
    println!("{}", wrapped_complex);
    println!();

    // 6. Unicode Support
    println!("6. Unicode Support:");
    let unicode_text = "Hello 世界 🌍 こんにちは";
    let wrapped_unicode = wrap_ansi(unicode_text, 10, None);
    println!("Unicode text wrapped:");
    println!("{}", wrapped_unicode);

    Ok(())
}

pub const fn build(self) -> WrapOptions

🏁 Build the final WrapOptions configuration.

Consumes the builder and returns the configured WrapOptions struct.

Examples

use wrap_ansi::WrapOptions;

let options = WrapOptions::builder()
    .hard_wrap(true)
    .trim_whitespace(false)
    .build();

Examples found in repository

examples/improved_features.rs (line 12)

fn main() -> Result<(), WrapError> {
    println!("=== Wrap-ANSI Improved Features Demo ===\n");

    // 1. Builder Pattern for Options
    println!("1. Builder Pattern for Options:");
    let options = WrapOptions::builder()
        .hard_wrap(true)
        .trim_whitespace(false)
        .word_wrap(true)
        .build();

    let text = "This is a verylongwordthatexceedslimit example";
    let wrapped = wrap_ansi(text, 15, Some(options));
    println!("Input: {}", text);
    println!("Output:\n{}\n", wrapped);

    // 2. Error Handling with Input Validation
    println!("2. Error Handling:");

    // Valid input
    match wrap_ansi_checked("Hello world", 10, None) {
        Ok(result) => println!("Valid input wrapped: {}", result.replace('\n', "\\n")),
        Err(e) => println!("Error: {}", e),
    }

    // Invalid column width
    match wrap_ansi_checked("Hello world", 0, None) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Expected error: {}", e),
    }

    // Large input (simulated)
    let large_text = "x".repeat(100);
    match wrap_ansi_checked(&large_text, 10, None) {
        Ok(result) => println!(
            "Large input handled: {} chars -> {} chars",
            large_text.len(),
            result.len()
        ),
        Err(e) => println!("Error with large input: {}", e),
    }

    println!();

    // 3. ANSI Color Preservation with Named Constants
    println!("3. ANSI Color Preservation:");
    let colored_text =
        "\u{001B}[31mThis is red text that will be wrapped across multiple lines\u{001B}[39m";
    let wrapped_colored = wrap_ansi(colored_text, 20, None);
    println!("Colored text wrapped:");
    println!("{}", wrapped_colored);
    println!();

    // 4. Hyperlink Preservation
    println!("4. Hyperlink Preservation:");
    let hyperlink_text = "\u{001B}]8;;https://example.com\u{0007}This is a clickable link that spans multiple lines\u{001B}]8;;\u{0007}";
    let wrapped_hyperlink = wrap_ansi(hyperlink_text, 15, None);
    println!("Hyperlink text wrapped:");
    println!("{}", wrapped_hyperlink);
    println!();

    // 5. Performance with Complex ANSI Sequences
    println!("5. Complex ANSI Sequences:");
    let complex_text =
        "\u{001B}[31m\u{001B}[42mRed text on green background\u{001B}[39m\u{001B}[49m normal text";
    let wrapped_complex = wrap_ansi(complex_text, 12, None);
    println!("Complex ANSI wrapped:");
    println!("{}", wrapped_complex);
    println!();

    // 6. Unicode Support
    println!("6. Unicode Support:");
    let unicode_text = "Hello 世界 🌍 こんにちは";
    let wrapped_unicode = wrap_ansi(unicode_text, 10, None);
    println!("Unicode text wrapped:");
    println!("{}", wrapped_unicode);

    Ok(())
}

Trait Implementations

impl Clone for WrapOptionsBuilder

fn clone(&self) -> WrapOptionsBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WrapOptionsBuilder

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

Formats the value using the given formatter.

impl Default for WrapOptionsBuilder

fn default() -> WrapOptionsBuilder

Returns the “default value” for a type.