TUI Test Drive

require "tui_td"

driver = TUITD::Driver.new("htop", rows: 40, cols: 120, timeout: 30)
driver.start

# Send input
driver.send("hello world\n")
driver.send_keys(:enter)     # :enter, :tab, :escape
driver.send_keys(:up)        # :up, :down, :left, :right
driver.send_keys(:ctrl_c)    # :ctrl_c, :ctrl_d, :backspace

# Wait for expected output
driver.wait_for_text("> ")
driver.wait_for_stable          # Wait until 300ms of silence
driver.wait_for_exit            # Wait until process ends

# Read output
driver.raw_output               # Raw ANSI string
driver.state_data               # Structured Hash with :raw, :rows, :cursor, :size
driver.state_json                # JSON string (includes raw ANSI)
driver.state_json(pretty: true)  # Pretty JSON

# Visual capture
driver.screenshot("screenshot.png")  # PNG renderer
TUITD::HtmlRenderer.new(driver.state_data).render("output.html")  # HTML renderer
html_string = TUITD::HtmlRenderer.new(driver.state_data).to_html   # HTML string

# Video recording (requires ffmpeg)
driver.start_recording("session.mp4", framerate: 30, codec: "libx264")
driver.recording?                   # => true
driver.stop_recording               # => "session.mp4"

driver.close

state = TUITD::State.new(driver.state_data)

# Read text
state.plain_text                # "Hello\n> prompt\n"
state.text_at(row, col, length) # Extract substring at position
state.find_text("error")        # [{row: 2, col: 10, text: "error", full_line: "..."}]

# Inspect cells
state.foreground_at(0, 5)       # "cyan"
state.background_at(0, 5)       # "bright_black"
state.style_at(0, 5)            # {bold: true, italic: false, underline: false}

# AI-optimized compact output
state.to_ai_json
# => {
#   size:    {rows: 40, cols: 120},
#   cursor:  {row: 5, col: 12},
#   text:    "> Hello\n...",
#   highlights: [
#     {row: 0, text: "MyApp v1.0.0", bold: true, fg: "cyan"}
#   ],
#   summary: "Cursor at [5,12]. 1 styled row, colors: fg=cyan."
# }

require "tui_td"

driver = TUITD::Driver.new("my_tui_app", rows: 24, cols: 80)
driver.start

# Wait for the initial prompt
driver.wait_for_text("> ", timeout: 10)

# Send a command
driver.send("list files\n")
driver.wait_for_stable

# Analyze output
state = TUITD::State.new(driver.state_data)

if state.find_text("ERROR").any?
  puts "Bug found!"
  driver.screenshot("error_proof.png")
end

# Check colors
welcome_fg = state.foreground_at(0, 0)
raise "Expected cyan header" unless welcome_fg == "cyan"

# Send more commands, inspect, loop...
driver.send("/quit\n")
driver.wait_for_exit
driver.close

plan = File.read("test/example.json")
result = TUITD::TestRunner.new(plan).run
puts result[:passed]  # => true
result[:results].each { |r| puts "#{r[:step]}: #{r[:passed]} - #{r[:message]}" }

require "tui_td"
require "tui_td/matchers"

RSpec.describe "My TUI" do
  before(:all) do
    @driver = TUITD::Driver.new("my_tui_app", rows: 24, cols: 80)
    @driver.start
  end

  after(:all) { @driver&.close }

  let(:state) { TUITD::State.new(@driver.state_data) }

  it "shows welcome message" do
    expect(state).to have_text("Welcome")
  end

  it "has a cyan header" do
    expect(state).to have_fg("cyan").at(0, 0)
  end

  it "has a blue background on row 3" do
    expect(state).to have_bg("blue").at(3, 0)
  end

  it "has bold text on the first line" do
    expect(state).to have_style.at(0, 0).with(bold: true)
  end
end

require "tui_td/minitest/assertions"

class MyTUITest < Minitest::Test
  include TUITD::Minitest::Assertions

  def test_login
    driver = TUITD::Driver.new("my_tui", rows: 24, cols: 80)
    driver.start
    assert_text(driver, "Welcome")
    assert_button(driver, "OK")
    refute_text(driver, "Error")
    assert_snapshot(driver, "login", type: :text, region: 0..6)
  ensure
    driver&.close
  end
end

# Named snapshot (recommended)
expect(driver).to match_snapshot("login_screen")
expect(driver).to match_snapshot("login_screen", type: :all, wait: true)

# Partial screen comparison
expect(driver).to match_snapshot("banner", region: 0..6, chars_only: true)

# Skip volatile rows (e.g., prompt line)
expect(driver).to match_snapshot("main", ignore_rows: [5])

# In-memory comparison (legacy)
pre = driver.snapshot
expect(driver).to match_snapshot(pre, chars_only: true)

TUITD.configure do |c|
  c.snapshot_dir = "spec/snapshots"   # default
end

# Update all snapshots
UPDATE_SNAPSHOTS=1 bundle exec rspec

# Via CLI
tui-td --screenshot output.png capture "echo 'Hello World'"

# Via Ruby API
driver.screenshot("output.png")

# Ruby API — render to file
TUITD::HtmlRenderer.new(driver.state_data).render("output.html")

# Ruby API — get HTML string (e.g. for API responses)
html = TUITD::HtmlRenderer.new(driver.state_data).to_html

driver = TUITD::Driver.new("htop", rows: 40, cols: 120)
driver.start

# Start recording
driver.start_recording("session.mp4", framerate: 30, codec: "libx264", quality: "high")

# Check recording status
driver.recording?  # => true

# ... interact with TUI ...

# Stop recording
driver.stop_recording  # => "session.mp4"
driver.close             # auto-stops recording if active

TUITD.configure do |c|
  c.ffmpeg_path           = "/usr/local/bin/ffmpeg"  # default: auto-detect
  c.record_default_fps    = 30
  c.record_default_codec  = "libx264"
end

require "tui_td/matchers"

driver.start_recording("test.mp4", framerate: 30)
expect(driver).to be_recording
# ... interact ...
driver.stop_recording
expect(driver).not_to be_recording
expect(driver).to have_recorded_video("test.mp4")

require "tui_td/minitest/assertions"

assert_record_start(driver, "test.mp4", framerate: 30)
assert_recording(driver)
# ... interact ...
assert_record_stop(driver)
refute_recording(driver)