Struct AlignOptions 

pub struct AlignOptions {
    pub align: Alignment,
    pub split: String,
    pub pad: char,
}

Configuration options for text alignment operations.

This struct allows you to customize how text alignment is performed, including the alignment direction, line separator, and padding character.

Examples

use ansi_align::{AlignOptions, Alignment, ansi_align_with_options};

// Basic usage with default settings
let opts = AlignOptions::new(Alignment::Center);

// Customized options
let opts = AlignOptions::new(Alignment::Right)
    .with_split("|")
    .with_pad('.');

let text = "short|longer text";
let result = ansi_align_with_options(text, &opts);

Fields

align: Alignment

The alignment type (left, center, right)

split: String

The string to split lines on (default: “\n”)

pad: char

The padding character to use (default: “ “)

Implementations

impl AlignOptions

pub fn new(align: Alignment) -> Self

Creates new alignment options with the specified alignment direction.

Uses default values for split string ("\n") and padding character (' ').

Arguments

• align - The alignment direction to use

Examples

use ansi_align::{AlignOptions, Alignment};

let opts = AlignOptions::new(Alignment::Center);

Examples found in repository

examples/cli_tool.rs (line 86)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cli = Cli::parse();

    if cli.demo {
        show_demo();
        return Ok(());
    }

    let input_text = get_input_text(&cli)?;

    if input_text.trim().is_empty() {
        if !cli.quiet {
            eprintln!("{}", "⚠️  No input text provided".yellow());
        }
        return Ok(());
    }

    let split_str = cli.split.replace("\\n", "\n").replace("\\t", "\t");

    let alignment = cli.align.into();
    let options = AlignOptions::new(alignment)
        .with_split(split_str)
        .with_pad(cli.pad);

    let aligned_text = ansi_align_with_options(&input_text, &options);

    if cli.border {
        print_with_border(&aligned_text, &cli);
    } else {
        println!("{}", aligned_text);
    }

    Ok(())
}

fn get_input_text(cli: &Cli) -> Result<String, Box<dyn std::error::Error>> {
    if let Some(file_path) = &cli.file {
        // Read from file
        Ok(fs::read_to_string(file_path)?)
    } else if let Some(text) = &cli.text {
        if text == "-" {
            // Read from stdin
            let mut buffer = String::new();
            io::stdin().read_to_string(&mut buffer)?;
            Ok(buffer)
        } else {
            // Process escape sequences in command line text
            Ok(text.replace("\\n", "\n").replace("\\t", "\t"))
        }
    } else {
        // Read from stdin if no text provided
        let mut buffer = String::new();
        io::stdin().read_to_string(&mut buffer)?;
        Ok(buffer)
    }
}

fn print_with_border(text: &str, cli: &Cli) {
    let lines: Vec<&str> = text.split('\n').collect();
    let max_width = lines
        .iter()
        .map(|line| string_width::string_width(line))
        .max()
        .unwrap_or(0);

    let border_width = max_width + 2; // 1 space padding on each side

    if !cli.quiet {
        // Top border
        println!(
            "{}{}{}",
            "┌".cyan().bold(),
            "─".repeat(border_width).cyan(),
            "┐".cyan().bold()
        );
    }

    // Content with side borders - text is already aligned
    for line in lines {
        if !cli.quiet {
            print!("{}", "│ ".cyan().bold());
        }
        print!("{}", line);
        if !cli.quiet {
            print!("{}", " │".cyan().bold());
        }
        println!();
    }

    if !cli.quiet {
        // Bottom border
        println!(
            "{}{}{}",
            "└".cyan().bold(),
            "─".repeat(border_width).cyan(),
            "┘".cyan().bold()
        );
    }
}

fn show_demo() {
    println!(
        "{}",
        "🎨 ansi-align Demo - Beautiful Text Alignment"
            .bold()
            .magenta()
    );
    println!();

    // Demo 1: Basic alignment
    println!("{}", "📝 Basic Alignment:".bold().blue());
    let basic_text = "Hello\nWorld\nRust";

    println!("\n{}", "Left:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Left))
    );

    println!("\n{}", "Center:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Center))
    );

    println!("\n{}", "Right:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Right))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 2: ANSI colors
    println!("\n{}", "🌈 ANSI Color Support:".bold().blue());
    let colored_text = format!(
        "{}\n{}\n{}",
        "Red Text".red().bold(),
        "Green Text".green().italic(),
        "Blue Text".blue().underline()
    );

    println!("\n{}", "Center aligned with colors:".green());
    println!(
        "{}",
        ansi_align_with_options(&colored_text, &AlignOptions::new(Alignment::Center))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 3: Unicode support
    println!("\n{}", "🌏 Unicode Support:".bold().blue());
    let unicode_text = "古\n古古古\nHello 世界";

    println!("\n{}", "Right aligned Unicode:".green());
    println!(
        "{}",
        ansi_align_with_options(unicode_text, &AlignOptions::new(Alignment::Right))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 4: Custom options
    println!("\n{}", "⚙️  Custom Options:".bold().blue());
    let custom_text = "Name|Age|Location";
    let options = AlignOptions::new(Alignment::Center)
        .with_split("|")
        .with_pad('.');

    println!("\n{}", "Custom separator '|' and padding '.':".green());
    println!("{}", ansi_align_with_options(custom_text, &options));

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 5: Menu example
    println!("\n{}", "📋 Menu Example:".bold().blue());
    let menu = format!(
        "{}\n{}\n{}\n{}",
        "🏠 Home".cyan(),
        "📋 About Us".yellow(),
        "📞 Contact".green(),
        "⚙️ Settings".magenta()
    );

    println!("\n{}", "Center aligned menu:".green());
    println!(
        "{}",
        ansi_align_with_options(&menu, &AlignOptions::new(Alignment::Center))
    );

    println!(
        "\n{}",
        "✨ Try it yourself with different options!".bold().green()
    );
    println!("{}", "Examples:".dimmed());
    println!(
        "{}",
        "  cargo run --example cli_tool -- \"Hello\\nWorld\" --align center".dimmed()
    );
    println!(
        "{}",
        "  echo \"Line 1\\nLonger Line 2\" | cargo run --example cli_tool -- - --border".dimmed()
    );
    println!(
        "{}",
        "  cargo run --example cli_tool -- --file README.md --align right --pad '.'".dimmed()
    );
}

examples/basic_usage.rs (line 41)

fn main() {
    println!("=== Basic Alignment Examples ===\n");

    // Simple text alignment
    let text = "Hello\nWorld\nRust";

    println!("Original text:");
    println!("{}\n", text);

    println!("Left aligned:");
    println!("{}\n", left(text));

    println!("Center aligned:");
    println!("{}\n", center(text));

    println!("Right aligned:");
    println!("{}\n", right(text));

    println!("=== ANSI Color Examples ===\n");

    // Text with ANSI colors
    let colored_text = "\x1b[31mRed\x1b[0m\n\x1b[32mGreen Text\x1b[0m\n\x1b[34mBlue\x1b[0m";

    println!("Colored text (center aligned):");
    println!("{}\n", center(colored_text));

    println!("=== Unicode Examples ===\n");

    // Unicode text with wide characters
    let unicode_text = "古\n古古古\nHello 世界";

    println!("Unicode text (right aligned):");
    println!("{}\n", right(unicode_text));

    println!("=== Custom Options Examples ===\n");

    // Custom separator and padding
    let pipe_separated = "Name|Age|Location";
    let options = AlignOptions::new(Alignment::Center)
        .with_split("|")
        .with_pad('.');

    println!("Custom separator and padding:");
    println!("{}\n", ansi_align_with_options(pipe_separated, &options));

    // Menu-like alignment
    let menu = "🏠 Home\n📋 About Us\n📞 Contact\n⚙️ Settings";

    println!("Menu (center aligned):");
    println!("{}\n", center(menu));
}

pub fn with_split<S: Into<String>>(self, split: S) -> Self

Sets the string used to split lines using the builder pattern.

By default, lines are split on "\n", but you can specify any string as a line separator.

Arguments

• split - The string to use as a line separator

Examples

use ansi_align::{AlignOptions, Alignment};

let opts = AlignOptions::new(Alignment::Center)
    .with_split("|")
    .with_split("<->"); // Multi-character separators work too

Examples found in repository

examples/cli_tool.rs (line 87)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cli = Cli::parse();

    if cli.demo {
        show_demo();
        return Ok(());
    }

    let input_text = get_input_text(&cli)?;

    if input_text.trim().is_empty() {
        if !cli.quiet {
            eprintln!("{}", "⚠️  No input text provided".yellow());
        }
        return Ok(());
    }

    let split_str = cli.split.replace("\\n", "\n").replace("\\t", "\t");

    let alignment = cli.align.into();
    let options = AlignOptions::new(alignment)
        .with_split(split_str)
        .with_pad(cli.pad);

    let aligned_text = ansi_align_with_options(&input_text, &options);

    if cli.border {
        print_with_border(&aligned_text, &cli);
    } else {
        println!("{}", aligned_text);
    }

    Ok(())
}

fn get_input_text(cli: &Cli) -> Result<String, Box<dyn std::error::Error>> {
    if let Some(file_path) = &cli.file {
        // Read from file
        Ok(fs::read_to_string(file_path)?)
    } else if let Some(text) = &cli.text {
        if text == "-" {
            // Read from stdin
            let mut buffer = String::new();
            io::stdin().read_to_string(&mut buffer)?;
            Ok(buffer)
        } else {
            // Process escape sequences in command line text
            Ok(text.replace("\\n", "\n").replace("\\t", "\t"))
        }
    } else {
        // Read from stdin if no text provided
        let mut buffer = String::new();
        io::stdin().read_to_string(&mut buffer)?;
        Ok(buffer)
    }
}

fn print_with_border(text: &str, cli: &Cli) {
    let lines: Vec<&str> = text.split('\n').collect();
    let max_width = lines
        .iter()
        .map(|line| string_width::string_width(line))
        .max()
        .unwrap_or(0);

    let border_width = max_width + 2; // 1 space padding on each side

    if !cli.quiet {
        // Top border
        println!(
            "{}{}{}",
            "┌".cyan().bold(),
            "─".repeat(border_width).cyan(),
            "┐".cyan().bold()
        );
    }

    // Content with side borders - text is already aligned
    for line in lines {
        if !cli.quiet {
            print!("{}", "│ ".cyan().bold());
        }
        print!("{}", line);
        if !cli.quiet {
            print!("{}", " │".cyan().bold());
        }
        println!();
    }

    if !cli.quiet {
        // Bottom border
        println!(
            "{}{}{}",
            "└".cyan().bold(),
            "─".repeat(border_width).cyan(),
            "┘".cyan().bold()
        );
    }
}

fn show_demo() {
    println!(
        "{}",
        "🎨 ansi-align Demo - Beautiful Text Alignment"
            .bold()
            .magenta()
    );
    println!();

    // Demo 1: Basic alignment
    println!("{}", "📝 Basic Alignment:".bold().blue());
    let basic_text = "Hello\nWorld\nRust";

    println!("\n{}", "Left:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Left))
    );

    println!("\n{}", "Center:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Center))
    );

    println!("\n{}", "Right:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Right))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 2: ANSI colors
    println!("\n{}", "🌈 ANSI Color Support:".bold().blue());
    let colored_text = format!(
        "{}\n{}\n{}",
        "Red Text".red().bold(),
        "Green Text".green().italic(),
        "Blue Text".blue().underline()
    );

    println!("\n{}", "Center aligned with colors:".green());
    println!(
        "{}",
        ansi_align_with_options(&colored_text, &AlignOptions::new(Alignment::Center))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 3: Unicode support
    println!("\n{}", "🌏 Unicode Support:".bold().blue());
    let unicode_text = "古\n古古古\nHello 世界";

    println!("\n{}", "Right aligned Unicode:".green());
    println!(
        "{}",
        ansi_align_with_options(unicode_text, &AlignOptions::new(Alignment::Right))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 4: Custom options
    println!("\n{}", "⚙️  Custom Options:".bold().blue());
    let custom_text = "Name|Age|Location";
    let options = AlignOptions::new(Alignment::Center)
        .with_split("|")
        .with_pad('.');

    println!("\n{}", "Custom separator '|' and padding '.':".green());
    println!("{}", ansi_align_with_options(custom_text, &options));

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 5: Menu example
    println!("\n{}", "📋 Menu Example:".bold().blue());
    let menu = format!(
        "{}\n{}\n{}\n{}",
        "🏠 Home".cyan(),
        "📋 About Us".yellow(),
        "📞 Contact".green(),
        "⚙️ Settings".magenta()
    );

    println!("\n{}", "Center aligned menu:".green());
    println!(
        "{}",
        ansi_align_with_options(&menu, &AlignOptions::new(Alignment::Center))
    );

    println!(
        "\n{}",
        "✨ Try it yourself with different options!".bold().green()
    );
    println!("{}", "Examples:".dimmed());
    println!(
        "{}",
        "  cargo run --example cli_tool -- \"Hello\\nWorld\" --align center".dimmed()
    );
    println!(
        "{}",
        "  echo \"Line 1\\nLonger Line 2\" | cargo run --example cli_tool -- - --border".dimmed()
    );
    println!(
        "{}",
        "  cargo run --example cli_tool -- --file README.md --align right --pad '.'".dimmed()
    );
}

examples/basic_usage.rs (line 42)

fn main() {
    println!("=== Basic Alignment Examples ===\n");

    // Simple text alignment
    let text = "Hello\nWorld\nRust";

    println!("Original text:");
    println!("{}\n", text);

    println!("Left aligned:");
    println!("{}\n", left(text));

    println!("Center aligned:");
    println!("{}\n", center(text));

    println!("Right aligned:");
    println!("{}\n", right(text));

    println!("=== ANSI Color Examples ===\n");

    // Text with ANSI colors
    let colored_text = "\x1b[31mRed\x1b[0m\n\x1b[32mGreen Text\x1b[0m\n\x1b[34mBlue\x1b[0m";

    println!("Colored text (center aligned):");
    println!("{}\n", center(colored_text));

    println!("=== Unicode Examples ===\n");

    // Unicode text with wide characters
    let unicode_text = "古\n古古古\nHello 世界";

    println!("Unicode text (right aligned):");
    println!("{}\n", right(unicode_text));

    println!("=== Custom Options Examples ===\n");

    // Custom separator and padding
    let pipe_separated = "Name|Age|Location";
    let options = AlignOptions::new(Alignment::Center)
        .with_split("|")
        .with_pad('.');

    println!("Custom separator and padding:");
    println!("{}\n", ansi_align_with_options(pipe_separated, &options));

    // Menu-like alignment
    let menu = "🏠 Home\n📋 About Us\n📞 Contact\n⚙️ Settings";

    println!("Menu (center aligned):");
    println!("{}\n", center(menu));
}

pub const fn with_pad(self, pad: char) -> Self

Sets the character used for padding using the builder pattern.

By default, spaces (' ') are used for padding, but you can specify any character.

Arguments

• pad - The character to use for padding

Examples

use ansi_align::{AlignOptions, Alignment};

let opts = AlignOptions::new(Alignment::Right)
    .with_pad('.');

Examples found in repository

examples/cli_tool.rs (line 88)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cli = Cli::parse();

    if cli.demo {
        show_demo();
        return Ok(());
    }

    let input_text = get_input_text(&cli)?;

    if input_text.trim().is_empty() {
        if !cli.quiet {
            eprintln!("{}", "⚠️  No input text provided".yellow());
        }
        return Ok(());
    }

    let split_str = cli.split.replace("\\n", "\n").replace("\\t", "\t");

    let alignment = cli.align.into();
    let options = AlignOptions::new(alignment)
        .with_split(split_str)
        .with_pad(cli.pad);

    let aligned_text = ansi_align_with_options(&input_text, &options);

    if cli.border {
        print_with_border(&aligned_text, &cli);
    } else {
        println!("{}", aligned_text);
    }

    Ok(())
}

fn get_input_text(cli: &Cli) -> Result<String, Box<dyn std::error::Error>> {
    if let Some(file_path) = &cli.file {
        // Read from file
        Ok(fs::read_to_string(file_path)?)
    } else if let Some(text) = &cli.text {
        if text == "-" {
            // Read from stdin
            let mut buffer = String::new();
            io::stdin().read_to_string(&mut buffer)?;
            Ok(buffer)
        } else {
            // Process escape sequences in command line text
            Ok(text.replace("\\n", "\n").replace("\\t", "\t"))
        }
    } else {
        // Read from stdin if no text provided
        let mut buffer = String::new();
        io::stdin().read_to_string(&mut buffer)?;
        Ok(buffer)
    }
}

fn print_with_border(text: &str, cli: &Cli) {
    let lines: Vec<&str> = text.split('\n').collect();
    let max_width = lines
        .iter()
        .map(|line| string_width::string_width(line))
        .max()
        .unwrap_or(0);

    let border_width = max_width + 2; // 1 space padding on each side

    if !cli.quiet {
        // Top border
        println!(
            "{}{}{}",
            "┌".cyan().bold(),
            "─".repeat(border_width).cyan(),
            "┐".cyan().bold()
        );
    }

    // Content with side borders - text is already aligned
    for line in lines {
        if !cli.quiet {
            print!("{}", "│ ".cyan().bold());
        }
        print!("{}", line);
        if !cli.quiet {
            print!("{}", " │".cyan().bold());
        }
        println!();
    }

    if !cli.quiet {
        // Bottom border
        println!(
            "{}{}{}",
            "└".cyan().bold(),
            "─".repeat(border_width).cyan(),
            "┘".cyan().bold()
        );
    }
}

fn show_demo() {
    println!(
        "{}",
        "🎨 ansi-align Demo - Beautiful Text Alignment"
            .bold()
            .magenta()
    );
    println!();

    // Demo 1: Basic alignment
    println!("{}", "📝 Basic Alignment:".bold().blue());
    let basic_text = "Hello\nWorld\nRust";

    println!("\n{}", "Left:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Left))
    );

    println!("\n{}", "Center:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Center))
    );

    println!("\n{}", "Right:".green());
    println!(
        "{}",
        ansi_align_with_options(basic_text, &AlignOptions::new(Alignment::Right))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 2: ANSI colors
    println!("\n{}", "🌈 ANSI Color Support:".bold().blue());
    let colored_text = format!(
        "{}\n{}\n{}",
        "Red Text".red().bold(),
        "Green Text".green().italic(),
        "Blue Text".blue().underline()
    );

    println!("\n{}", "Center aligned with colors:".green());
    println!(
        "{}",
        ansi_align_with_options(&colored_text, &AlignOptions::new(Alignment::Center))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 3: Unicode support
    println!("\n{}", "🌏 Unicode Support:".bold().blue());
    let unicode_text = "古\n古古古\nHello 世界";

    println!("\n{}", "Right aligned Unicode:".green());
    println!(
        "{}",
        ansi_align_with_options(unicode_text, &AlignOptions::new(Alignment::Right))
    );

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 4: Custom options
    println!("\n{}", "⚙️  Custom Options:".bold().blue());
    let custom_text = "Name|Age|Location";
    let options = AlignOptions::new(Alignment::Center)
        .with_split("|")
        .with_pad('.');

    println!("\n{}", "Custom separator '|' and padding '.':".green());
    println!("{}", ansi_align_with_options(custom_text, &options));

    println!("\n{}", "─".repeat(50).dimmed());

    // Demo 5: Menu example
    println!("\n{}", "📋 Menu Example:".bold().blue());
    let menu = format!(
        "{}\n{}\n{}\n{}",
        "🏠 Home".cyan(),
        "📋 About Us".yellow(),
        "📞 Contact".green(),
        "⚙️ Settings".magenta()
    );

    println!("\n{}", "Center aligned menu:".green());
    println!(
        "{}",
        ansi_align_with_options(&menu, &AlignOptions::new(Alignment::Center))
    );

    println!(
        "\n{}",
        "✨ Try it yourself with different options!".bold().green()
    );
    println!("{}", "Examples:".dimmed());
    println!(
        "{}",
        "  cargo run --example cli_tool -- \"Hello\\nWorld\" --align center".dimmed()
    );
    println!(
        "{}",
        "  echo \"Line 1\\nLonger Line 2\" | cargo run --example cli_tool -- - --border".dimmed()
    );
    println!(
        "{}",
        "  cargo run --example cli_tool -- --file README.md --align right --pad '.'".dimmed()
    );
}

examples/basic_usage.rs (line 43)

fn main() {
    println!("=== Basic Alignment Examples ===\n");

    // Simple text alignment
    let text = "Hello\nWorld\nRust";

    println!("Original text:");
    println!("{}\n", text);

    println!("Left aligned:");
    println!("{}\n", left(text));

    println!("Center aligned:");
    println!("{}\n", center(text));

    println!("Right aligned:");
    println!("{}\n", right(text));

    println!("=== ANSI Color Examples ===\n");

    // Text with ANSI colors
    let colored_text = "\x1b[31mRed\x1b[0m\n\x1b[32mGreen Text\x1b[0m\n\x1b[34mBlue\x1b[0m";

    println!("Colored text (center aligned):");
    println!("{}\n", center(colored_text));

    println!("=== Unicode Examples ===\n");

    // Unicode text with wide characters
    let unicode_text = "古\n古古古\nHello 世界";

    println!("Unicode text (right aligned):");
    println!("{}\n", right(unicode_text));

    println!("=== Custom Options Examples ===\n");

    // Custom separator and padding
    let pipe_separated = "Name|Age|Location";
    let options = AlignOptions::new(Alignment::Center)
        .with_split("|")
        .with_pad('.');

    println!("Custom separator and padding:");
    println!("{}\n", ansi_align_with_options(pipe_separated, &options));

    // Menu-like alignment
    let menu = "🏠 Home\n📋 About Us\n📞 Contact\n⚙️ Settings";

    println!("Menu (center aligned):");
    println!("{}\n", center(menu));
}

Trait Implementations

impl Clone for AlignOptions

fn clone(&self) -> AlignOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlignOptions

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

Formats the value using the given formatter.

impl Default for AlignOptions

fn default() -> Self

Returns the “default value” for a type.