rustik-diff 0.2.0

Pure diff viewer and Git diff pager for Rustik.
Documentation
//! Binary entry point for the `rustik-diff` pager.

#[path = "rustik-diff/builtins.rs"]
mod builtins;
#[path = "rustik-diff/error.rs"]
mod error;
#[path = "rustik-diff/session.rs"]
mod session;

use std::ffi::OsString;
use std::io::{self, IsTerminal as _, Read as _, Write as _};
use std::path::Path;
use std::process::{Command, ExitCode, Output};
use std::{env, str};

use rustik_diff::{Decode, DiffDocument, DiffOptions, DiffViewer, FileTreeMode};
use rustik_repo::GitRepo;
use rustik_tui as tui;
use rustik_tui::Terminal;
use rustik_tui_termion as tui_termion;

use builtins::Builtins;
use error::Error;

/// Default static render width for non-terminal output.
const STATIC_COLS: usize = 100;
/// Maximum static render rows for non-terminal output.
const STATIC_MAX_ROWS: usize = 10_000;

/// Program entry point.
fn main() -> ExitCode {
    match run(env::args_os().skip(1).collect()) {
        Ok(()) => ExitCode::SUCCESS,
        Err(error) => {
            let _ = writeln!(io::stderr(), "rustik-diff: {error}");
            ExitCode::FAILURE
        }
    }
}

/// Runs the binary with forwarded Git arguments.
fn run(args: Vec<OsString>) -> Result<(), Error> {
    let cwd = env::current_dir()?;
    let input_from_git = io::stdin().is_terminal();
    let input = if input_from_git {
        let output = git_diff(&args, &cwd)?;
        if !output.status.success() {
            io::stderr().write_all(&output.stderr)?;
            return Err(Error::Git(output.status.code().unwrap_or(1)));
        }
        output.stdout
    } else {
        let mut buf = Vec::new();
        io::stdin().read_to_end(&mut buf)?;
        buf
    };

    run_or_forward(&input, &cwd, input_from_git.then_some(args.as_slice()))
}

/// Renders diff input or passes non-diff data through unchanged.
fn run_or_forward(input: &[u8], cwd: &Path, args: Option<&[OsString]>) -> Result<(), Error> {
    let document = match DiffDocument::decode_bytes(input) {
        Ok(document) if !document.is_empty() => document,
        Ok(_) => {
            io::stdout().write_all(input)?;
            return Ok(());
        }
        Err(error) => return Err(Error::Parse(error)),
    };
    let assets = Builtins::load()?;
    let mut options = DiffOptions {
        diff_palette: assets.palette,
        ..DiffOptions::default()
    };

    if !io::stdout().is_terminal() {
        let mut viewer = DiffViewer::new(document, options);
        let constraints = tui::Constraint::max(tui::Size::new(STATIC_COLS, STATIC_MAX_ROWS));

        tui_termion::term::print_constrained(&mut viewer, constraints)?;
        return Ok(());
    }
    let root = cwd
        .file_name()
        .and_then(|name| name.to_str())
        .filter(|name| !name.is_empty())
        .map(str::to_owned)
        .unwrap_or_else(|| cwd.display().to_string());

    options.file_tree = FileTreeMode::Auto;
    options.file_tree_root = root;

    let backend = tui_termion::term::screen()?;
    let mut terminal = Terminal::new(backend)?;
    let highlight_document = document.clone();
    let mut viewer = DiffViewer::new(document, options);

    terminal.clear()?;
    terminal.set_cursor_visible(false)?;

    let repo = args.map(|args| GitRepo::new(cwd, args));
    let result = session::run(&mut terminal, &mut viewer, highlight_document, repo);
    let cursor = terminal.set_cursor_visible(true);

    result?;
    cursor.map_err(Error::Io)
}

/// Runs `git diff` in `cwd`.
fn git_diff(args: &[OsString], cwd: &Path) -> io::Result<Output> {
    let mut command = Command::new("git");
    command
        .arg("diff")
        .args(args)
        .current_dir(cwd)
        .env("NO_COLOR", "1");
    command.output()
}