rustik-diff 0.3.0

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

#[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::ExitCode;
use std::{env, str};

use rustik_diff::{Builtins, Decode, DiffDocument, DiffOptions, DiffViewer, FileTreeMode};
use rustik_repo::{ReadRepository as _, git};
use rustik_tui as tui;
use rustik_tui::Terminal;
use rustik_tui_termion as tui_termion;

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;

/// Repository context available while rendering.
enum RenderRepo {
    /// Input came from a Git command and can be refetched.
    Git(git::Repository),
    /// Input came from stdin and has no backing repository context.
    Stdin,
}

/// 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 mut debug = false;
    let mut paths = false;
    let mut git_args = Vec::new();
    for arg in args {
        if !paths && arg == "--debug" {
            debug = true;
            continue;
        }
        paths |= arg == "--";
        git_args.push(arg);
    }

    let cwd = env::current_dir()?;
    let input_from_git = io::stdin().is_terminal();
    let repo = if input_from_git {
        let repository = git::Repository::new(&cwd, git_args.clone())?;
        RenderRepo::Git(repository)
    } else {
        RenderRepo::Stdin
    };
    let input = if let RenderRepo::Git(repository) = &repo {
        let output = repository.diff_output(&git_args)?;
        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, repo, debug)
}

/// Loads highlight context for files whose new side only exists in the worktree.
fn load_worktree_sources(viewer: &mut DiffViewer, repository: &git::Repository) {
    if let Ok(root) = repository.workdir() {
        viewer.load_worktree_sources(&root);
    }
}

/// Renders diff input or passes non-diff data through unchanged.
fn run_or_forward(input: &[u8], cwd: &Path, repo: RenderRepo, debug: bool) -> 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()
    };

    let interactive = io::stdout().is_terminal();
    if interactive {
        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 mut viewer = DiffViewer::new(document, options);
    match &repo {
        RenderRepo::Git(repository) => {
            let _ = viewer.load_file_sources(|oid| repository.cat_blob(oid));
            load_worktree_sources(&mut viewer, repository);
        }
        RenderRepo::Stdin => {
            if let Ok(repository) = git::Repository::discover(cwd.to_path_buf()) {
                let _ = viewer.load_file_sources(|oid| repository.cat_blob(oid));
                load_worktree_sources(&mut viewer, &repository);
            }
        }
    }

    if !interactive {
        let constraints = tui::Constraint::max(tui::Size::new(STATIC_COLS, STATIC_MAX_ROWS));

        tui_termion::term::print_constrained(&mut viewer, constraints)?;
        return Ok(());
    }

    let backend = tui_termion::term::screen()?;
    let mut terminal = Terminal::new(backend)?;

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

    let repo = match repo {
        RenderRepo::Git(repository) => Some(repository),
        RenderRepo::Stdin => None,
    };
    let result = session::run(&mut terminal, &mut viewer, repo, debug);
    let cursor = terminal.set_cursor_visible(true);

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