path: root/src/output.rs

//! Terminal and JSON presentation.
//!
//! Color turns itself off when the output is not a terminal (a pipe, a file)
//! or when `NO_COLOR` is set, following <https://no-color.org>.

use std::io::IsTerminal;

use crate::model::{Conjugation, Entry, Locution, Sense};

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ColorChoice {
    Auto,
    Always,
    Never,
}

#[derive(Clone, Copy)]
pub struct Style {
    color: bool,
    pub width: usize,
}

impl Style {
    pub fn new(choice: ColorChoice, width: Option<usize>) -> Self {
        let color = match choice {
            ColorChoice::Always => true,
            ColorChoice::Never => false,
            ColorChoice::Auto => {
                std::env::var_os("NO_COLOR").is_none() && std::io::stdout().is_terminal()
            }
        };
        Style {
            color,
            width: width.unwrap_or_else(detect_width).clamp(40, 100),
        }
    }

    fn paint(&self, code: &str, s: &str) -> String {
        if self.color && !s.is_empty() {
            format!("\x1b[{code}m{s}\x1b[0m")
        } else {
            s.to_string()
        }
    }

    pub fn bold(&self, s: &str) -> String {
        self.paint("1", s)
    }
    pub fn dim(&self, s: &str) -> String {
        self.paint("2", s)
    }
    pub fn italic(&self, s: &str) -> String {
        self.paint("3", s)
    }
    pub fn cyan(&self, s: &str) -> String {
        self.paint("36", s)
    }
    pub fn green(&self, s: &str) -> String {
        self.paint("32", s)
    }
    pub fn red(&self, s: &str) -> String {
        self.paint("31", s)
    }
    pub fn yellow(&self, s: &str) -> String {
        self.paint("33", s)
    }
    pub fn heading(&self, s: &str) -> String {
        self.paint("1;36", s)
    }
}

fn detect_width() -> usize {
    if let Ok(cols) = std::env::var("COLUMNS") {
        if let Ok(n) = cols.parse::<usize>() {
            return n;
        }
    }
    terminal_size::terminal_size()
        .map(|(terminal_size::Width(w), _)| w as usize)
        .unwrap_or(80)
}

/// Wraps a paragraph to the given width. `first` indents the first line and
/// `rest` the following ones, so the text stays aligned under the sense
/// number instead of going back to the margin.
pub fn wrap(text: &str, width: usize, first: &str, rest: &str) -> String {
    let usable = width.saturating_sub(rest.chars().count()).max(20);
    let mut out = String::new();
    let mut line = String::new();
    let mut line_len = 0usize;
    let mut started = false;

    for word in text.split_whitespace() {
        let wlen = word.chars().count();
        if line_len > 0 && line_len + 1 + wlen > usable {
            out.push_str(if started { rest } else { first });
            out.push_str(&line);
            out.push('\n');
            started = true;
            line.clear();
            line_len = 0;
        }
        if line_len > 0 {
            line.push(' ');
            line_len += 1;
        }
        line.push_str(word);
        line_len += wlen;
    }
    if line_len > 0 {
        out.push_str(if started { rest } else { first });
        out.push_str(&line);
    }
    out
}

/// The full entry, as shown in the terminal.
pub fn entry(e: &Entry, st: &Style, show_abbr: bool) -> String {
    let mut out = String::new();
    out.push_str(&st.heading(&e.word));
    out.push('\n');

    if let Some(ety) = &e.etymology {
        out.push_str(&st.dim(&wrap(ety, st.width, "", "")));
        out.push('\n');
    }
    out.push('\n');

    for s in &e.senses {
        out.push_str(&sense(s, st, show_abbr));
        out.push('\n');
    }

    if !e.locutions.is_empty() {
        out.push('\n');
        out.push_str(&st.heading("Locuciones y expresiones"));
        out.push('\n');
        for l in &e.locutions {
            out.push_str(&locution(l, st, show_abbr));
        }
    }

    if let Some(c) = &e.conjugation {
        out.push('\n');
        out.push_str(&conjugation(c, st));
    }
    out
}

/// A sense: number, definition, examples and synonyms.
pub fn sense(s: &Sense, st: &Style, show_abbr: bool) -> String {
    let num = s.number.clone().unwrap_or_default();
    let label = if num.is_empty() {
        "  ".to_string()
    } else {
        format!("{num}.")
    };
    let pad = " ".repeat(label.chars().count().max(2) + 1);
    let first = format!("{} ", st.yellow(&label));

    let mut out = wrap(&superscript_homographs(&s.text), st.width, &first, &pad);
    out.push('\n');

    for ex in &s.examples {
        out.push_str(&st.italic(&st.dim(&wrap(ex, st.width, &pad, &pad))));
        out.push('\n');
    }
    if !s.synonyms.is_empty() {
        let joined = superscript_homographs(&s.synonyms.join(", "));
        let line = format!("{} {joined}", st.green("Sin.:"));
        out.push_str(&wrap(&line, st.width, &pad, &pad));
        out.push('\n');
    }
    if !s.antonyms.is_empty() {
        let joined = superscript_homographs(&s.antonyms.join(", "));
        let line = format!("{} {joined}", st.red("Ant.:"));
        out.push_str(&wrap(&line, st.width, &pad, &pad));
        out.push('\n');
    }
    if show_abbr && !s.grammar.is_empty() {
        let expanded: Vec<String> = s
            .grammar
            .iter()
            .map(|a| format!("{} = {}", a.short, a.long))
            .collect();
        let line = expanded.join("; ");
        out.push_str(&st.dim(&wrap(&line, st.width, &pad, &pad)));
        out.push('\n');
    }
    out
}

fn locution(l: &Locution, st: &Style, show_abbr: bool) -> String {
    let mut out = format!("\n{}\n", st.bold(&l.phrase));
    for s in &l.senses {
        out.push_str(&sense(s, st, show_abbr));
    }
    out
}

/// The conjugation, one mood per block and one tense per paragraph.
///
/// A seven-person grid per tense does not fit an 80-column terminal once
/// compound tenses show up («yo habría hablado»), so the forms flow separated
/// by «·». Each form already carries its pronoun, so no column header is needed.
pub fn conjugation(c: &