rich-ruby 1.0.1 → 1.0.2

data/docs/architecture.md

@@ -0,0 +1,43 @@
+# Architecture & Data Flow
+
+This document explains how Rich Ruby processes text and components to generate terminal output.
+
+## 1. High-Level Concept
+
+Rich Ruby follows a pipeline:
+**Input (Markup/Object) -> Text/Segments -> Console Options -> ANSI String -> Terminal**
+
+## 2. Core Entities
+
+### `Rich::Console`
+The "brain" of the library. It holds state about the terminal's width, height, and color capabilities. It acts as the orchestrator for all rendering.
+
+### `Rich::Text`
+A representation of text that includes "Spans" (range of characters + a Style). This is an intermediate format before splitting into segments.
+
+### `Rich::Segment`
+The lowest-level rendering unit. A segment is a simple string paired with a `Rich::Style`.
+- When you render any component (Table, Panel, etc.), it ultimately breaks down into a list of `Segments`.
+- Segments are responsible for generating the final ANSI escape codes via `Segment.render`.
+
+### `Rich::Style`
+Encapsulates foreground color, background color, and attributes (bold, etc.). Styles are **immutable**. Combining styles (`style1 + style2`) creates a new style object.
+
+## 3. The Rendering Pipeline
+
+1. **Measurement**: Components (like `Table`) calculate the required width of each cell using `Rich::Cells.cell_len`.
+2. **Layout**: Wrapping and alignment logic is applied to fit the `max_width`.
+3. **Segmentation**: The component converts its visual structure into `Rich::Segment` objects.
+4. **ANSI Generation**: The `Console` takes the segments and joins them into a single string containing escape sequences.
+5. **Output**: The string is written to `$stdout` (or the configured output stream).
+
+## 4. Windows Integration Logic
+
+In `lib/rich/win32_console.rb`, we use `Fiddle` to interface with `kernel32.dll`:
+
+- **VT Processing**: We call `GetConsoleMode` and `SetConsoleMode` to enable ANSI support.
+- **Size Detection**: We call `GetConsoleScreenBufferInfo` to get accurate dimensions without relying on environment variables.
+
+## 5. Extensibility
+
+Developers can create new components by implementing a `render` (or `to_segments`) method that returns a collection of `Rich::Segment` objects. This ensures that any new component automatically inherits font-width calculation and color-downgrade support.

data/docs/cheat-sheet.md

@@ -0,0 +1,52 @@
+# Rich Ruby Cheat Sheet
+
+A quick visual reference for markup, styles, and colors.
+
+## 1. Markup Tags
+Commonly used tags in `[tag]content[/tag]` syntax.
+
+| Tag | Result |
+|-----|--------|
+| `[bold]` | **Bold Text** |
+| `[dim]` | Dimmed Text |
+| `[italic]` | *Italic Text* |
+| `[u]` or `[underline]` | <u>Underline</u> |
+| `[strike]` | ~~Strikethrough~~ |
+| `[reverse]` | Inverse Background/Foreground |
+| `[red]` | Red Foreground |
+| `[on blue]` | Blue Background |
+| `[#ff5500]` | Hex Color |
+
+## 2. Color Keywords
+Standard 16-color names supported by almost all terminals.
+
+- `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`
+- `bright_black`, `bright_red`, `bright_green`, etc.
+
+## 3. Component Comparison
+
+| Component | best for... |
+|-----------|-------------|
+| **Panel** | Single focus messages, headers, or boxed content. |
+| **Table** | Columns of data, spreadsheets, or grid layouts. |
+| **Tree** | File systems, dependency graphs, or nested lists. |
+| **Syntax** | Code snippets in logs or documentation. |
+| **JSON** | Debugging API responses or config files. |
+| **Markdown**| Rendering READMEs or rich terminal helps. |
+
+## 4. Quick API Snippets
+
+### Print with Style
+```ruby
+Rich.print("[yellow]Wait...[/] [bold green]Success![/]")
+```
+
+### Create a Rule (Divider)
+```ruby
+Rich.rule("Chapter 1", style: "cyan")
+```
+
+### Inspect a Ruby Object
+```ruby
+puts Rich::Pretty.to_s(some_hash)
+```

data/docs/customization.md

@@ -0,0 +1,53 @@
+# Customization & Extensibility
+
+Rich Ruby is designed to be modular. You can extend it by creating your own box styles, syntax lexers, and themes.
+
+## 1. Custom Box Styles
+You can create a custom `Box` by instantiating the class with a set of characters.
+
+```ruby
+MY_BOX = Rich::Box.new(
+  top_left: "┏", top_right: "┓",
+  bottom_left: "┗", bottom_right: "┛",
+  horizontal: "━", vertical: "┃",
+  cross: "╋"
+)
+
+panel = Rich::Panel.new("Custom Border", box: MY_BOX)
+puts panel.render
+```
+
+## 2. Advanced Syntax Themes
+Themes are simply Hashes mapping token types to `Rich::Style` objects.
+
+```ruby
+MY_THEME = {
+  keyword: Rich::Style.new(color: "red", bold: true),
+  string:  Rich::Style.new(color: "green"),
+  comment: Rich::Style.new(color: "yellow", dim: true),
+  text:    Rich::Style.new(color: "default")
+}
+
+syntax = Rich::Syntax.new(code, language: "ruby", theme: MY_THEME)
+puts syntax.render
+```
+
+## 3. Adding a New Lexer
+To add support for a new language, create a class inheriting from `Rich::BaseLexer` and register it in `Rich::Syntax::LEXERS`.
+
+```ruby
+class MyLanguageLexer < Rich::BaseLexer
+  def tokenize(line, theme)
+    # Return an array of Rich::Segment objects
+    [Rich::Segment.new(line, style: theme[:text])]
+  end
+end
+
+# Register it
+Rich::Syntax::LEXERS["mylang"] = MyLanguageLexer.new
+```
+
+## 4. Custom Markup Tags
+The `Rich::Markup` parser utilizes the `Rich::Style` parsing engine. If you want to create a shorthand tag, you can add it to the `Style` registry if implemented, or simply use combined strings.
+
+Note: Rich Ruby aims to keep the core small. For complex custom components, we recommend composing existing `Panel`, `Table`, and `Text` objects.

data/docs/how-to-use.md

@@ -0,0 +1,96 @@
+# How-To Use Rich Ruby
+
+This guide provides quick examples and tips for using Rich Ruby effectively, categorized by user level.
+
+## 1. Beginner: Quick Start & Basic Styling
+
+If you're new to Rich Ruby, the easiest way to start is using the `Rich.print` method and [Markup](README.md#text-and-markup).
+
+### Styled Hello World
+```ruby
+require 'rich'
+
+Rich.print("[bold red]ERROR:[/] Something went wrong!")
+Rich.print("[green]SUCCESS:[/] Operation completed.")
+Rich.print("[blue italic]INFO:[/] Processing data...")
+```
+
+### Simple Rules (Dividers)
+Use rules to organize your terminal output.
+```ruby
+Rich.rule("Section 1")
+puts "Content goes here"
+Rich.rule(style: "dim")
+```
+
+---
+
+## 2. Intermediate: Components & Layout
+
+Once you're comfortable with basic printing, start using structured components like **Panels** and **Tables**.
+
+### Grouping with Panels
+Panels are great for highlights or error messages.
+```ruby
+panel = Rich::Panel.new(
+  "Data backup complete.\nVerified 1,024 files.",
+  title: "Backup Status",
+  border_style: "cyan"
+)
+puts panel.render(max_width: 40)
+```
+
+### Organizing with Tables
+Tables automatically calculate column widths.
+```ruby
+table = Rich::Table.new(title: "Inventory")
+table.add_column("Item", header_style: "bold")
+table.add_column("Stock", justify: :right)
+
+table.add_row("Apples", "50")
+table.add_row("Oranges", "12")
+puts table.render(max_width: 30)
+```
+
+---
+
+## 3. Advanced: Dynamic Content & Technical Control
+
+For power users building complex CLI tools.
+
+### Live Progress Bars
+```ruby
+bar = Rich::ProgressBar.new(total: 100)
+100.times do |i|
+  bar.update(i + 1)
+  print "\r#{bar.render}"
+  sleep 0.01
+end
+puts "" # New line after completion
+```
+
+### Code Highlighting
+Perfect for dev tools or logging code snippets.
+```ruby
+code = "def hello; puts 'world'; end"
+syntax = Rich::Syntax.new(code, language: "ruby", theme: :monokai)
+puts syntax.render
+```
+
+### Technical Transparency & Limitations
+- **Pure Ruby**: The entire library is implemented in Pure Ruby (with `Fiddle` for Windows API). This ensures portability but means performance may degrade with exceptionally large datasets (e.g., tables with 10,000+ rows).
+- **Windows Integration**: On Windows, we directly interface with `kernel32.dll` to enable Virtual Terminal processing. This is robust but depends on modern Windows 10/11 features for the best experience.
+- **Color Systems**: While we support TrueColor, the actual appearance depends on your terminal emulator's capabilities.
+
+---
+
+## Guide for Quick Reference
+
+| Task | Tool to Use |
+|------|-------------|
+| Quick logging | `Rich.print` |
+| Boxing content | `Rich::Panel` |
+| List data | `Rich::Table` |
+| File trees | `Rich::Tree` |
+| Source code | `Rich::Syntax` |
+| Formatted docs | `Rich::Markdown` |

data/docs/test-report.md

@@ -0,0 +1,112 @@
+# Rich Ruby: Test Report
+
+This document showcases the results of the final test verification for the Rich Ruby library.
+
+## Environment
+- **Ruby**: 3.4.8 (MSVC)
+- **Platform**: Windows 10 (64-bit)
+- **Date**: December 23, 2025
+
+---
+
+## 1. Functional Test Suite
+The functional test suite covers core components: Color, Style, Text, Markup, Console, Box, Table, Trees, Progress, Syntax, Markdown, and JSON.
+
+**Command:**
+```bash
+ruby -W0 -Ilib -Itest -e "require './test/test_helper'; Dir['test/test_*.rb'].each { |f| require File.expand_path(f) }"
+```
+
+**Results:**
+```text
+Run options: --seed 29775
+
+# Running:
+
+.......................................................................................
+───────────────────────────────── Title ───────────────────────────────────────────────
+...Hello
+..................................................................................................
+
+Finished in 0.041029s, 4582.0690 runs/s, 8432.9568 assertions/s.
+
+188 runs, 346 assertions, 0 failures, 0 errors, 0 skips
+```
+
+---
+
+## 2. Performance & Stress Test Suite
+The stress test suite validates the library under heavy load and deep nesting conditions.
+
+**Command:**
+```bash
+ruby -W0 -Ilib examples/stress_test.rb
+```
+
+**Results:**
+```text
+======================================================================
+Rich Library Stress Test Suite
+======================================================================
+
+  Parse all 256 ANSI color names                    ... ✓ PASS (0.000s)
+  Parse 10,000 random hex colors                    ... ✓ PASS (0.042s)
+  Color downgrade from truecolor to 256             ... ✓ PASS (0.004s)
+  Color downgrade from truecolor to 16              ... ✓ PASS (0.014s)
+  ColorTriplet HSL roundtrip                        ... ✓ PASS (0.000s)
+  Color parse caching performance                   ... ✓ PASS (0.125s)
+  Parse complex style definitions                   ... ✓ PASS (0.000s)
+  Style combination chain (1000 styles)             ... ✓ PASS (0.008s)
+  Style attribute bitmask integrity                 ... ✓ PASS (0.000s)
+  Style render with all attributes                  ... ✓ PASS (0.000s)
+  CJK character width calculation                   ... ✓ PASS (0.001s)
+  Zero-width combining characters                   ... ✓ PASS (0.000s)
+  Mixed ASCII and Unicode                           ... ✓ PASS (0.001s)
+  Large Unicode string (10KB)                       ... ✓ PASS (0.315s)
+  Empty and whitespace strings                      ... ✓ PASS (0.000s)
+  Segment split at every position                   ... ✓ PASS (0.002s)
+  Segment line splitting with many newlines         ... ✓ PASS (0.000s)
+  Segment simplification (1000 segments)            ... ✓ PASS (0.001s)
+  Segment rendering with control codes              ... ✓ PASS (0.000s)
+  Text with 1000 overlapping spans                  ... ✓ PASS (0.053s)
+  Deeply nested markup                              ... ✓ PASS (0.000s)
+  Markup validation with errors                     ... ✓ PASS (0.000s)
+  Text wrapping at various widths                   ... ✓ PASS (0.120s)
+  Text with special characters                      ... ✓ PASS (0.000s)
+  Panel with very long content                      ... ✓ PASS (0.061s)
+  Panel with Unicode borders and content            ... ✓ PASS (0.001s)
+  Table with 100 rows                               ... ✓ PASS (0.088s)
+  Table with Unicode content                        ... ✓ PASS (0.003s)
+  Tree with deep nesting (10 levels)                ... ✓ PASS (0.000s)
+  Tree with many siblings (100)                     ... ✓ PASS (0.000s)
+  All box styles render correctly                   ... ✓ PASS (0.002s)
+  Progress bar at every percentage                  ... ✓ PASS (0.000s)
+  Progress bar with very large total                ... ✓ PASS (0.000s)
+  Spinner cycles through all frames                 ... ✓ PASS (0.004s)
+  Multiple spinner styles                           ... ✓ PASS (0.000s)
+  JSON with deeply nested structure                 ... ✓ PASS (0.002s)
+  JSON with large array                             ... ✓ PASS (0.017s)
+  JSON with special characters                      ... ✓ PASS (0.000s)
+  Pretty print complex Ruby object                  ... ✓ PASS (0.001s)
+  Console size detection                            ... ✓ PASS (0.000s)
+  Console options update                            ... ✓ PASS (0.000s)
+  Control codes generate valid ANSI                 ... ✓ PASS (0.000s)
+  ANSI stripping                                    ... ✓ PASS (0.000s)
+  Windows Console API functions available           ... ✓ PASS (0.000s)
+  Windows ANSI support detection                    ... ✓ PASS (0.000s)
+  Windows console size valid                        ... ✓ PASS (0.000s)
+  Empty inputs handled gracefully                   ... ✓ PASS (0.000s)
+  Nil inputs handled gracefully                     ... ✓ PASS (0.000s)
+  Very long single-line content                     ... ✓ PASS (0.000s)
+  Content at exact width boundary                   ... ✓ PASS (0.002s)
+  Zero and negative values                          ... ✓ PASS (0.000s)
+
+======================================================================
+Results: 51/51 tests passed in 0.87s
+======================================================================
+```
+
+---
+
+## 3. Transparency & Stability
+The recent repairs to the `Syntax` lexers specifically addressed infinite loop scenarios, ensuring that even large or malformed code blocks are processed efficiently. The library remains a zero-dependency, pure Ruby implementation optimized for the modern terminal.

data/docs/troubleshooting.md

@@ -0,0 +1,36 @@
+# Troubleshooting & FAQ
+
+Common issues and solutions when working with Rich Ruby.
+
+## 1. Character Encoding & Unicode
+**Problem**: CJK characters (Chinese, Japanese, Korean) or emojis appear as blocks or distorted.
+**Solution**: 
+- Ensure your terminal emulator has a font that supports these characters (e.g., Cascadia Code, JetBrains Mono, or a Nerd Font).
+- On Windows, ensure your shell environment is set to UTF-8. In PowerShell/CMD, run: `chcp 65001`.
+- Rich Ruby uses `Rich::Cells` to calculate width, but if the terminal font doesn't match the expected Unicode width, the layout might look slightly off.
+
+## 2. Colors Not Appearing
+**Problem**: Output is plain text with no color.
+**Solution**:
+- Check if your terminal supports ANSI colors.
+- If you are piping output (e.g., `ruby script.rb > log.txt`), Rich Ruby automatically disables color. Use `Rich::Console.new(force_terminal: true)` to override this.
+- If on Windows, Rich Ruby attempts to enable VT Processing. If it fails (e.g., very old Win 10), it will downgrade to basic 16-color mode via Console API.
+
+## 3. The `io-nonblock` Warning
+**Problem**: `Ignoring io-nonblock-0.3.2 because its extensions are not built.`
+**Solution**:
+- This is a Ruby environment issue, not a Rich Ruby bug. Rich Ruby has **zero dependencies**.
+- You can ignore it, or run your scripts with `ruby -W0` to silence it.
+
+## 4. Performance in Large Loops
+**Problem**: The script feels slow when printing thousands of lines.
+**Solution**:
+- Standard terminal I/O is slow. Try batching your output or using the `Rich::Live` display (if available in your version) to update only changed lines.
+- Avoid re-creating `Rich::Console` instances inside tight loops; use the global `Rich.get_console` instead.
+
+## 5. Dark Mode vs. Light Mode
+**Problem**: Text is invisible because it's too bright/dark for the background.
+**Solution**:
+- Avoid using hardcoded colors like `white` or `black` for main content.
+- Use `default` color or theme-aware colors.
+- Rich Ruby doesn't currently detect the terminal's background color (as many terminals don't support the query), so providing high-contrast themes like `:monokai` or `:dracula` is the best practice for user accessibility.

data/docs/windows-notes.md

@@ -0,0 +1,30 @@
+# Windows Support & Environmental Notes
+
+Rich Ruby is designed to be a first-class citizen on Windows.
+
+## Windows Native Integration
+
+We use Ruby's `Fiddle` to call Windows API functions directly. This avoids dependencies on external gems like `curses` or `win32-console`.
+
+### Virtual Terminal Processing
+When you initialize a `Rich::Console`, it attempts to enable `ENABLE_VIRTUAL_TERMINAL_PROCESSING` (0x0004) via `SetConsoleMode`. This allows the Windows Command Prompt and PowerShell to understand ANSI escape codes natively.
+
+### Fallback Behavior
+On older systems (legacy console), the library detects the lack of VT support and simplifies output to basic 16 colors using the Windows Console API where possible, or strips formatting to ensure readability.
+
+## Known Environmental Artifacts
+
+### `io-nonblock` Warning
+You may see the following warning in your terminal:
+`Ignoring io-nonblock-0.3.2 because its extensions are not built.`
+
+**Transparency Note:**
+This warning is related to the local Ruby environment's gem installation and is **not caused by Rich Ruby**. Rich Ruby has **zero external gem dependencies** and does not require `io-nonblock` for its core functionality.
+
+To run tests without seeing this warning, use the `-W0` flag:
+```bash
+ruby -W0 -Ilib -Itest test/test_console.rb
+```
+
+## MSVC Compatibility
+Rich Ruby is developed and tested on **Ruby 3.4.8 (MSVC)** compiled with Visual Studio 2026. It is fully compatible with MSVC-built Ruby runtimes.

data/examples/demo.rb

@@ -1,106 +1,106 @@
-# frozen_string_literal: true
-
-# Comprehensive demo of Rich library features
-
-require_relative "../lib/rich"
-
-console = Rich::Console.new
-
-# Title
-console.rule("Rich Library Demo", style: "bold magenta")
-puts ""
-
-# 1. Colors and Styles
-puts "1. Colors and Styles"
-puts "=" * 40
-console.print("Normal text")
-console.print("Bold text", style: "bold")
-console.print("Italic text", style: "italic")
-console.print("Underlined text", style: "underline")
-console.print("Red text", style: "red")
-console.print("Green on yellow", style: "green on yellow")
-console.print("Bold blue italic", style: "bold blue italic")
-puts ""
-
-# 2. Text with Spans
-puts "2. Text with Style Spans"
-puts "=" * 40
-text = Rich::Text.new("Hello ")
-text.append("World", style: "bold red")
-text.append("! This is ")
-text.append("Rich", style: "italic magenta")
-text.append(" for Ruby.")
-puts text.render + "\n"
-
-# 3. Markup
-puts "3. Markup Parsing"
-puts "=" * 40
-markup = Rich::Markup.render("[bold]Bold[/bold] and [italic red]italic red[/italic red] text")
-puts markup + "\n"
-
-# 4. Panel
-puts "4. Panel Component"
-puts "=" * 40
-panel = Rich::Panel.new(
-  "This is content inside a panel.\nIt can have multiple lines.",
-  title: "My Panel",
-  subtitle: "Subtitle here",
-  border_style: "cyan",
-  title_style: "bold white"
-)
-puts panel.render(max_width: 50)
-puts ""
-
-# 5. Table
-puts "5. Table Component"
-puts "=" * 40
-table = Rich::Table.new(
-  title: "User Data",
-  show_header: true,
-  border_style: "blue"
-)
-table.add_column("Name", header_style: "bold")
-table.add_column("Age", justify: :right)
-table.add_column("City", header_style: "bold green")
-
-table.add_row("Alice", "30", "New York")
-table.add_row("Bob", "25", "San Francisco")
-table.add_row("Charlie", "35", "London")
-table.add_row("Diana", "28", "Tokyo")
-
-puts table.render(max_width: 60)
-puts ""
-
-# 6. Box Styles
-puts "6. Different Box Styles"
-puts "=" * 40
-
-[Rich::Box::ASCII, Rich::Box::SQUARE, Rich::Box::ROUNDED, Rich::Box::HEAVY, Rich::Box::DOUBLE].each do |box_style|
-  small_panel = Rich::Panel.new(
-    "Content",
-    title: box_style.class == Class ? box_style.name : "Box",
-    box: box_style,
-    expand: false,
-    padding: 0
-  )
-  puts small_panel.render(max_width: 30)
-end
-puts ""
-
-# 7. Color System Info
-puts "7. System Information"
-puts "=" * 40
-info_table = Rich::Table.new(show_header: false, box: Rich::Box::SIMPLE)
-info_table.add_column("Property", style: "cyan")
-info_table.add_column("Value", style: "yellow")
-info_table.add_row("Color System", console.color_system.to_s)
-info_table.add_row("Terminal", console.terminal? ? "Yes" : "No")
-info_table.add_row("Width", console.width.to_s)
-info_table.add_row("Height", console.height.to_s)
-info_table.add_row("Ruby Version", RUBY_VERSION)
-info_table.add_row("Platform", RUBY_PLATFORM)
-
-puts info_table.render(max_width: 50)
-puts ""
-
-console.rule("Demo Complete!", style: "bold green")
+# frozen_string_literal: true
+
+# Comprehensive demo of Rich library features
+
+require_relative "../lib/rich"
+
+console = Rich::Console.new
+
+# Title
+console.rule("Rich Library Demo", style: "bold magenta")
+puts ""
+
+# 1. Colors and Styles
+puts "1. Colors and Styles"
+puts "=" * 40
+console.print("Normal text")
+console.print("Bold text", style: "bold")
+console.print("Italic text", style: "italic")
+console.print("Underlined text", style: "underline")
+console.print("Red text", style: "red")
+console.print("Green on yellow", style: "green on yellow")
+console.print("Bold blue italic", style: "bold blue italic")
+puts ""
+
+# 2. Text with Spans
+puts "2. Text with Style Spans"
+puts "=" * 40
+text = Rich::Text.new("Hello ")
+text.append("World", style: "bold red")
+text.append("! This is ")
+text.append("Rich", style: "italic magenta")
+text.append(" for Ruby.")
+puts text.render + "\n"
+
+# 3. Markup
+puts "3. Markup Parsing"
+puts "=" * 40
+markup = Rich::Markup.render("[bold]Bold[/bold] and [italic red]italic red[/italic red] text")
+puts markup + "\n"
+
+# 4. Panel
+puts "4. Panel Component"
+puts "=" * 40
+panel = Rich::Panel.new(
+  "This is content inside a panel.\nIt can have multiple lines.",
+  title: "My Panel",
+  subtitle: "Subtitle here",
+  border_style: "cyan",
+  title_style: "bold white"
+)
+puts panel.render(max_width: 50)
+puts ""
+
+# 5. Table
+puts "5. Table Component"
+puts "=" * 40
+table = Rich::Table.new(
+  title: "User Data",
+  show_header: true,
+  border_style: "blue"
+)
+table.add_column("Name", header_style: "bold")
+table.add_column("Age", justify: :right)
+table.add_column("City", header_style: "bold green")
+
+table.add_row("Alice", "30", "New York")
+table.add_row("Bob", "25", "San Francisco")
+table.add_row("Charlie", "35", "London")
+table.add_row("Diana", "28", "Tokyo")
+
+puts table.render(max_width: 60)
+puts ""
+
+# 6. Box Styles
+puts "6. Different Box Styles"
+puts "=" * 40
+
+[Rich::Box::ASCII, Rich::Box::SQUARE, Rich::Box::ROUNDED, Rich::Box::HEAVY, Rich::Box::DOUBLE].each do |box_style|
+  small_panel = Rich::Panel.new(
+    "Content",
+    title: box_style.class == Class ? box_style.name : "Box",
+    box: box_style,
+    expand: false,
+    padding: 0
+  )
+  puts small_panel.render(max_width: 30)
+end
+puts ""
+
+# 7. Color System Info
+puts "7. System Information"
+puts "=" * 40
+info_table = Rich::Table.new(show_header: false, box: Rich::Box::SIMPLE)
+info_table.add_column("Property", style: "cyan")
+info_table.add_column("Value", style: "yellow")
+info_table.add_row("Color System", console.color_system.to_s)
+info_table.add_row("Terminal", console.terminal? ? "Yes" : "No")
+info_table.add_row("Width", console.width.to_s)
+info_table.add_row("Height", console.height.to_s)
+info_table.add_row("Ruby Version", RUBY_VERSION)
+info_table.add_row("Platform", RUBY_PLATFORM)
+
+puts info_table.render(max_width: 50)
+puts ""
+
+console.rule("Demo Complete!", style: "bold green")