rusty-rich 0.2.1

✨ Features

• 🎨 Style — foreground/background colors, bold, italic, underline, dim, blink, reverse, strikethrough, overline, conceal, frame, encircle, links

• 📝 Console markup — [bold red]text[/bold red] BBCode-like inline styling

• 🎯 256 named colors — full ANSI 256-color palette with aliases, hex, RGB, auto-downgrade

• 🎭 170+ theme styles — repr, json, markdown, logging, traceback, rule, bar, progress, table, tree, syntax, prompt categories

• 📊 Table — tabular data with headers, footers, colspan/rowspan, column alignment, sections, 17 box styles

• 🌲 Tree — hierarchical tree rendering with Unicode guides

• 📦 Panel — bordered containers with titles, subtitles

• ➖ Rule — horizontal dividers with optional titles

• 📐 Padding & Align — CSS-style padding and alignment helpers

• 📋 Columns — side-by-side layout

• 🗂️ Layout — recursive split-pane layout with ratio sizing

• ⏳ Progress — multi-task progress bars with 11 column types, file tracking, track() iterator

• 🔄 Spinner — 55 animated spinners with case-insensitive name lookup

• 📌 Status — spinner + message with in-place update

• 🔄 Live — auto-updating displays with alt-screen, transient mode, stdout/stderr redirect via LiveWriter

• 🌈 Syntax highlighting — powered by syntect (100+ languages)

• 📝 Markdown — headings, code blocks, lists, blockquotes, links, tables

• 📋 JSON — pretty-printed, syntax-highlighted JSON

• 🔍 Logging — Rich-formatted log records via the log crate

• 🖼️ Box drawing — 17 box styles (rounded, square, heavy, double, ASCII, etc.)

• 🖥️ Screen / Alt-screen — full-screen terminal applications with ScreenContext

• ⌨️ Prompts — Prompt, IntPrompt, FloatPrompt, Confirm, Select<T>, password mode

• 🔴 Traceback — rich exception rendering with locals, source code, frame suppression, panic hook

• 📤 HTML & SVG export — capture console output for the web

• 🧩 Segment utilities — simplify, split_lines, strip_styles, strip_links, align, divide, set_shape, filter_control

📦 Installation

[dependencies]
rusty-rich = "0.2"

🚀 Quick Start

use rusty_rich::{
    Console, Panel, Table, Column, Rule, Tree,
    Style, Color, AlignMethod, Padding,
};

fn main() {
    let mut console = Console::new();

    // Print with markup
    console.print_str("[bold green]Hello, [red]World![/red][/bold green]");

    // Create a panel with a title
    let panel = Panel::new("Hello inside a rounded box!")
        .title("My Panel")
        .border_style(Style::new().color(Color::parse("cyan").unwrap()));
    console.println(&panel);

    // Create a table
    let mut table = Table::new();
    table.add_column(Column::new("Name").justify(AlignMethod::Left));
    table.add_column(Column::new("Age").justify(AlignMethod::Right));
    table.add_row_str("Alice", "30");
    table.add_row_str("Bob", "25");
    console.println(&table);

    // Create a tree
    let mut tree = Tree::new("Root");
    tree.add("Child 1").add("Grandchild");
    tree.add("Child 2");
    console.println(&tree);

    // Draw a rule
    console.rule("Section Break", None, None, None);
}

🎯 Colors (256 names)

use rusty_rich::{Color, Style};

// Named colors — 256 ANSI palette
let red = Color::parse("red").unwrap();
let hot_pink = Color::parse("hot_pink").unwrap();
let steel_blue = Color::parse("steel_blue").unwrap();
let grey53 = Color::parse("grey53").unwrap();

// Hex / RGB
let orange = Color::from_hex("#FF6600").unwrap();
let custom = Color::from_rgb(100, 200, 50);

// TrueColor → 8-bit → Standard auto-downgrade
let style = Style::new()
    .color(Color::parse("#FF6600").unwrap())
    .bgcolor(Color::parse("#1E1E2E").unwrap())
    .bold(true)
    .italic(true);

📊 Table with Colspan & Rowspan

use rusty_rich::{Table, Column, Cell};

let mut table = Table::new().title("User Report");
table.add_column(Column::new("Name"));
table.add_column(Column::new("Details").colspan(2));  // spans 2 columns
table.add_column(Column::new("Role"));                  // skipped by colspan above

let row = vec![
    Cell::new("Alice"),
    Cell::new("Engineer").colspan(2),
];
table.add_row(row);

⏳ Progress Bars

use rusty_rich::Progress;
use std::thread;
use std::time::Duration;

let mut progress = Progress::new();
let task_id = progress.add_task("Downloading...", Some(100.0));

for i in 0..=100 {
    progress.update(task_id, i as f64);
    print!("\r{}", progress.render(80));
    thread::sleep(Duration::from_millis(20));
}
println!();

// Or use the `track()` convenience with an iterator
let items: Vec<_> = (0..100).collect();
let tracker = progress.track(items, "Processing", None);
for item in tracker {
    // process item — progress auto-advances
}

📝 Markdown (with tables)

use rusty_rich::render_markdown;
use rusty_rich::Console;

let md = render_markdown("
# Hello

| Name  | Age |
|-------|-----|
| Alice | 30  |
| Bob   | 25  |

- list item 1
- list item 2
");

let console = Console::new();
console.println(&md);

⌨️ Interactive Prompts

use rusty_rich::{Prompt, Confirm, IntPrompt, Select};

// String input
let name = Prompt::ask_with("Enter your name").unwrap();

// Password input (masked with *)
let password = Prompt::new("Password").password(true).ask().unwrap();

// Confirmation with default
let ok = Confirm::ask_with("Continue?", true).unwrap();

// Integer with validation
let age = IntPrompt::ask_with("Enter age").unwrap();

// Pick from numbered choices
let choice = Select::new("Pick a color")
    .choice("Red", "red")
    .choice("Green", "green")
    .choice("Blue", "blue")
    .ask()
    .unwrap();

🔄 Live Display with Writer

use rusty_rich::{Console, Live, LiveWriter, Panel};
use std::io::Write;
use std::thread;
use std::time::Duration;

let mut live = Live::new(Panel::new("Starting...").title("Status"));
let mut writer = live.create_writer();
live.start().unwrap();

for i in 0..=100 {
    // Redirect writes through the live display
    writeln!(writer, "Processing item {}...", i).unwrap();
    live.update(Panel::new(format!("Progress: {}%", i)).title("Status")).unwrap();
    thread::sleep(Duration::from_millis(50));
}

live.stop().unwrap();

🔴 Rich Tracebacks

use rusty_rich::traceback;

// Install a global panic hook for rich tracebacks
traceback::install();

// Or render manually
let tb = Traceback::from_exception("MyError", "something went wrong", frames)
    .show_locals(true)
    .max_frames(5)
    .suppress(vec!["std::".into(), "core::".into()]);

🖥️ Full-Screen Apps

use rusty_rich::{Console, Screen, Live, Panel};
use std::thread;
use std::time::Duration;

let mut console = Console::new();
let mut screen = console.screen();  // enters alternate screen
screen.enter();

let mut live = Live::new(Panel::new("Loading...").title("Status"));
live.start().unwrap();

for i in 0..=100 {
    live.update(Panel::new(format!("Progress: {}%", i)).title("Status")).unwrap();
    thread::sleep(Duration::from_millis(50));
}

live.stop().unwrap();
screen.exit();  // restores terminal

🎨 Box Styles (17 built-in)

🧩 Segment Utilities

use rusty_rich::segment::{self, Segment, Segments};

let segs: Segments = vec![
    Segment::styled("Hello ", Style::new().bold(true)),
    Segment::styled("World", Style::new().bold(true)),
].into();

// Combine adjacent same-styled segments
let simplified = segs.simplify();           // → one "Hello World" segment

// Split into lines
let lines = segment::split_lines(&segs.segments);

// Strip all styling
let plain = segment::strip_styles(&segs.segments);  // → "Hello World"

// Align vertically
let aligned = segment::align_middle(&lines, 80, 10, None);

📂 Module Map

src/
├── lib.rs              # Crate root + re-exports
├── console.rs          # Central rendering engine
├── screen.rs           # Full-screen / alt-screen / ScreenContext
├── color.rs            # TrueColor / 256 / Standard (256 names)
├── style.rs            # 13 attributes + hyperlinks + metadata
├── theme.rs            # 170+ named styles + stack
├── segment.rs          # Segment + 9 utility functions
├── text.rs             # Text with Span styling
├── cells.rs            # Unicode cell width utilities
├── measure.rs          # Width measurement protocol
├── align.rs            # Horizontal + vertical alignment
├── ratio.rs            # Proportional space distribution
├── markup.rs           # BBCode-like markup parser
├── highlighter.rs      # Regex/Repr highlighters
│
├── panel.rs            # Bordered container
├── table.rs            # Tabular data + colspan/rowspan
├── tree.rs             # Hierarchical tree
├── rule.rs             # Horizontal divider
├── padding.rs          # CSS-style padding
├── columns.rs          # Side-by-side layout
├── layout.rs           # Split-pane layout
├── box_drawing.rs      # 17 box/border styles
│
├── progress.rs         # Multi-task progress + track()
├── progress_columns.rs # 11 progress column types
├── spinner.rs          # 55 animated spinners
├── status.rs           # Spinner + message
├── live.rs             # Auto-updating display + LiveWriter
│
├── syntax.rs           # Syntax highlighting (syntect)
├── markdown.rs         # Markdown rendering + table support
├── json.rs             # Pretty-printed JSON
├── logging.rs          # log crate integration
├── prompt.rs           # 5 interactive prompt types
├── traceback.rs        # Rich exception tracebacks
└── export.rs           # HTML / SVG / text export

🔬 Compared to Python Rich

🧪 Testing

cargo test                    # 197 unit tests
cargo test --test battle_test # Integration / battle tests

📄 License

MIT — See LICENSE for details.