terminfokit-cli 0.1.0

Terminfo compiler, decompiler, query, and conversion commands
Documentation
// SPDX-FileCopyrightText: 2026 Yasunobu Sakashita
//
// SPDX-License-Identifier: MIT OR Apache-2.0

use std::io::Write;
use std::process::{Command, Output, Stdio};

fn run_with_stdin(program: &str, args: &[&str], input: &[u8]) -> Output {
    let mut child = Command::new(program)
        .args(args)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("spawn CLI");
    child
        .stdin
        .take()
        .expect("piped stdin")
        .write_all(input)
        .expect("write stdin");
    child.wait_with_output().expect("wait for CLI")
}

fn transport(source: &[u8]) -> String {
    let output = run_with_stdin(env!("CARGO_BIN_EXE_tik-tic"), &["-x", "-Q1", "-"], source);
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    String::from_utf8(output.stdout).unwrap().trim().to_owned()
}

#[test]
fn unsupported_operations_are_usage_errors_before_external_lookup() {
    let output = Command::new(env!("CARGO_BIN_EXE_tik-tput"))
        .arg("init")
        .env_remove("TERM")
        .output()
        .expect("run tput");
    assert_eq!(output.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&output.stderr).contains("terminal required"));

    let output = Command::new(env!("CARGO_BIN_EXE_tik-infocmp"))
        .arg("-e")
        .env_remove("TERM")
        .output()
        .expect("run infocmp");
    assert_eq!(output.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&output.stderr).contains("unsupported"));
}

#[test]
fn integrated_commands_use_the_compatibility_implementations() {
    let source = b"demo|demo terminal,am,cols#80,clear=ok,\n";
    let compatibility = run_with_stdin(env!("CARGO_BIN_EXE_tik-tic"), &["-c", "-"], source);
    let integrated = run_with_stdin(
        env!("CARGO_BIN_EXE_terminfokit"),
        &["compile", "-c", "-"],
        source,
    );
    assert_eq!(integrated.status.code(), compatibility.status.code());
    assert_eq!(integrated.stdout, compatibility.stdout);
    assert_eq!(integrated.stderr, compatibility.stderr);

    let compatibility = run_with_stdin(env!("CARGO_BIN_EXE_tik-captoinfo"), &["-"], b"d:am:\n");
    let integrated = run_with_stdin(
        env!("CARGO_BIN_EXE_terminfokit"),
        &["convert", "termcap-to-terminfo", "-"],
        b"d:am:\n",
    );
    assert_eq!(integrated.status.code(), compatibility.status.code());
    assert_eq!(integrated.stdout, compatibility.stdout);
    assert_eq!(integrated.stderr, compatibility.stderr);
}

#[test]
fn tput_matches_numeric_extended_and_clear_x_rules() {
    let encoded = transport(b"demo|demo terminal,clear=base,E3=scroll,xnum#7,\n");
    let command = |args: &[&str]| {
        Command::new(env!("CARGO_BIN_EXE_tik-tput"))
            .args(args)
            .env("TERM", "demo")
            .env("TERMINFO", &encoded)
            .output()
            .expect("run tput")
    };

    let output = command(&["colors"]);
    assert_eq!(output.status.code(), Some(1));
    assert_eq!(output.stdout, b"-1\n");

    let output = command(&["xnum"]);
    assert_eq!(output.status.code(), Some(0));
    assert_eq!(output.stdout, b"7\n");

    let output = command(&["clear"]);
    assert_eq!(output.status.code(), Some(0));
    assert_eq!(output.stdout, b"basescroll");

    let output = command(&["-x", "clear"]);
    assert_eq!(output.status.code(), Some(0));
    assert_eq!(output.stdout, b"base");

    let output = command(&["colors", "xnum"]);
    assert_eq!(output.status.code(), Some(1));
    assert_eq!(output.stdout, b"-1\n7\n");

    let mut child = Command::new(env!("CARGO_BIN_EXE_tik-tput"))
        .arg("-S")
        .env("TERM", "demo")
        .env("TERMINFO", &encoded)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("spawn tput -S");
    child
        .stdin
        .take()
        .unwrap()
        .write_all(b"colors\nxnum\nunknown-capability\n")
        .unwrap();
    let output = child.wait_with_output().unwrap();
    assert_eq!(output.status.code(), Some(4));
    assert_eq!(output.stdout, b"-1\n7\n");
}

#[test]
fn doctor_reports_inline_origin_and_statuses_without_mutation() {
    let encoded = transport(b"doctor-demo|diagnostic terminal,cols#90,lines#30,colors#256,\n");
    let output = Command::new(env!("CARGO_BIN_EXE_terminfokit"))
        .args(["doctor", "-T", "doctor-demo"])
        .env("TERMINFO", encoded)
        .output()
        .expect("run doctor");
    assert_eq!(output.status.code(), Some(0));
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stdout.contains("origin=inline:hex"));
    assert!(stdout.contains("name.primary=doctor-demo"));
    assert!(stdout.contains("size=90x30"));
    assert!(stdout.contains("colors=256"));

    let output = Command::new(env!("CARGO_BIN_EXE_terminfokit"))
        .arg("doctor")
        .env_remove("TERM")
        .env_remove("TERMINFO")
        .output()
        .expect("run doctor without TERM");
    assert_eq!(output.status.code(), Some(2));
}

#[test]
fn ndjson_diagnostics_are_one_structured_record_per_line() {
    let output = Command::new(env!("CARGO_BIN_EXE_tik-tic"))
        .args(["--diagnostic-format", "ndjson", "-R", "SVr2"])
        .output()
        .expect("run tic");
    assert_eq!(output.status.code(), Some(2));
    let stderr = String::from_utf8(output.stderr).expect("diagnostic UTF-8");
    let lines: Vec<_> = stderr.lines().collect();
    assert_eq!(lines.len(), 1);
    assert!(lines[0].starts_with('{'));
    assert!(lines[0].contains("\"code\":\"TIKC011\""));
    assert!(lines[0].contains("\"severity\":\"error\""));
}

#[test]
fn translation_frontends_share_binary_safe_parsers() {
    let output = run_with_stdin(
        env!("CARGO_BIN_EXE_tik-captoinfo"),
        &["-"],
        b"# non-utf8: \xff\ndemo|demo terminal:am:co#80:cl=\\E[H\\E[2J:\n",
    );
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(output.stdout.windows(8).any(|value| value == b"cols#80,"));

    let output = run_with_stdin(
        env!("CARGO_BIN_EXE_tik-infotocap"),
        &["-"],
        b"# non-utf8: \xff\ndemo|demo terminal,am,cols#80,clear=\\E[H,\n",
    );
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(output.stdout.windows(5).any(|value| value == b"co#80"));
}

#[test]
fn tic_check_accepts_non_utf8_comments_without_installing() {
    let output = run_with_stdin(
        env!("CARGO_BIN_EXE_tik-tic"),
        &["-c", "-"],
        b"# arbitrary byte: \xff\ndemo,am,cols#80,\n",
    );
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(output.stdout.is_empty());
}

#[test]
fn infocmp_source_file_mode_matches_aliases_and_reports_unmatched_entries() {
    let directory =
        std::env::temp_dir().join(format!("terminfokit-infocmp-source-{}", std::process::id()));
    std::fs::create_dir_all(&directory).unwrap();
    let left = directory.join("left.info");
    let right = directory.join("right.info");
    std::fs::write(&left, b"a|shared,cols#80,\nleft-only,am,\n").unwrap();
    std::fs::write(&right, b"shared|b,cols#81,\nright-only,am,\n").unwrap();

    let output = Command::new(env!("CARGO_BIN_EXE_tik-infocmp"))
        .arg("-F")
        .arg(&left)
        .arg(&right)
        .output()
        .expect("run infocmp -F");
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stdout.contains("a vs shared"));
    assert!(stdout.contains("left-only: no match"));
    assert!(stdout.contains("right-only: no match"));

    std::fs::remove_dir_all(directory).unwrap();
}