cli_tool/

cli_tool.rs

use ansi_align::{AlignOptions, Alignment, ansi_align_with_options};
use clap::{Parser, ValueEnum};
use colored::*;
use std::fs;
use std::io::{self, Read};

/// A beautiful CLI tool for aligning text with ANSI and Unicode support
#[derive(Parser)]
#[command(
    name = "ansi-align",
    version = "0.2.0",
    about = "🎨 Beautiful text alignment with ANSI escape sequences and Unicode support",
    long_about = "A powerful CLI tool that aligns text while preserving ANSI colors and properly handling Unicode characters including CJK. Perfect for creating beautiful terminal output, aligning code, or formatting data."
)]
struct Cli {
    /// Text to align (use '-' to read from stdin)
    #[arg(value_name = "TEXT")]
    text: Option<String>,

    /// Alignment direction
    #[arg(short, long, default_value = "center")]
    align: AlignmentArg,

    /// Character to use for padding
    #[arg(short, long, default_value = " ")]
    pad: char,

    /// String to split lines on
    #[arg(short, long, default_value = "\\n")]
    split: String,

    /// Read from file instead of argument
    #[arg(short, long, value_name = "FILE")]
    file: Option<String>,

    /// Add colorful borders around the output
    #[arg(short, long)]
    border: bool,

    /// Show example usage with colors
    #[arg(long)]
    demo: bool,

    /// Quiet mode - no decorative output
    #[arg(short, long)]
    quiet: bool,
}

#[derive(Clone, Copy, ValueEnum)]
enum AlignmentArg {
    Left,
    Center,
    Right,
}

impl From<AlignmentArg> for Alignment {
    fn from(arg: AlignmentArg) -> Self {
        match arg {
            AlignmentArg::Left => Alignment::Left,
            AlignmentArg::Center => Alignment::Center,
            AlignmentArg::Right => Alignment::Right,
        }
    }
}

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()
    );
}