[package]
name = "qpprint"
version = "0.3.1"
edition = "2024"
license = "0BSD"
# https://crates.io/category_slugs
categories = [ "text-processing" ]
keywords = [ "cli", "console", "terminal", "format", "print" ]
repository = "https://repos.qrnch.tech/pub/qpprint"
description = "Simple console printing/formatting."

# https://doc.rust-lang.org/cargo/reference/manifest.html#the-badges-section
[badges]
maintenance = { status = "experimental" }

[dependencies]
terminal_size = { version = "0.4.2" }
unicode-width = { version = "0.2.0" }
yansi = { version = "1.0.1" }

[lints.clippy]
all = { level = "warn", priority = -1 }
pedantic = { level = "warn", priority = -1 }
nursery = { level = "warn", priority = -1 }
cargo = { level = "warn", priority = -1 }

multiple_crate_versions = "allow"

use qpprint::tbl::{Align, CellValue, Column, Data, Renderer};

use yansi::{Color, Painted};

fn main() {
  table1();
  println!();
  table2();
  println!();
  table3();
  println!();
  table4();
}


fn table1() {
  //
  // Define table columns
  //

  let columns = [idcol, namecol, namecol2];

  let mut data = Data::new(columns.len());
  data.add_row(vec![4.into(), "hell".into(), "hell".into()]);
  data.add_row(vec![42.into(), "hello".into(), "hello".into()]);
  data.add_row(vec![11.into(), "world".into(), "world".into()]);

  let renderer = Renderer::new(&columns, &data).header(Some('='));

  renderer.print();
}


fn table4() {
  let keycol = Column::new("Key", ToString::to_string);
  let valcol = Column::new("Value", ToString::to_string);

  let columns = [keycol, valcol];

  let mut data = Data::new(columns.len());
  data.add_row(vec!["hell".into(), "hell".into()]);
  data.add_row(vec!["hello🔒".into(), "hello".into()]);
  data.add_row(vec!["world".into(), "world".into()]);

  let renderer = Renderer::new(&columns, &data).header(Some('='));

  renderer.print();
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :

pub mod tbl;

use terminal_size::{terminal_size, Height, Width};

pub use yansi::{Color, Painted};

pub enum Types {
  Paragraph(String)
}

#[derive(Copy, Clone, Debug)]
pub enum Align {
  Left,
  Center,
  Right
}

pub struct Column {

use std::{
  borrow::Cow,
  fmt,
  iter::{self, zip}
};

use unicode_width::UnicodeWidthStr;

use yansi::Painted;

pub use super::Align;


#[allow(clippy::type_complexity)]
pub struct Column {

  }

  pub fn print(&self) {
    println!("{self}");
  }
}

/// Calculate the width (in units of number of terminal character cells) of a
/// unicode string.
///
/// Apparently this is not an exact science.  It should work well enough as
/// long as no one tries to be too creative.
#[inline]
fn strlen(s: &str) -> usize {
  //c.title.chars().count()
  s.width()
}

impl fmt::Display for Renderer<'_> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    //
    // Iterate over cells and generate a new rendered table.
    // Every cell here is a String
    //
    let mut rendered: Vec<Vec<String>> = Vec::with_capacity(self.data.len());

    //
    // Used to keep track of auto-detected column widths.
    //
    // If the renderer is configured to show a header, then initialize to the
    // column titles.  Otherwise initialize to 0.
    //
    // If a column min and/or max widths have been configured, the column
    // widths will be clamped later.
    //
    let mut col_widths: Vec<usize> = if self.show_header {
      self.cols.iter().map(|c| strlen(&c.title)).collect()
    } else {
      vec![0; self.cols.len()]
    };

    //
    // Convert table of CellValues into a table of Strings.
    //

      {
        let cell_str = (col.renderer)(cell);

        // ToDo: Cut down to size if cell_str.len() exceeds column's max_width

        //if cell_str.len() > col_width {}

        *cw = std::cmp::max(*cw, strlen(&cell_str));
        rrow.push(cell_str);
      }

      rendered.push(rrow);
    }

    //

    if self.show_header {
      //
      // Print column headers
      //
      for (col, cw) in std::iter::zip(self.cols, &col_widths) {
        let title = trunc_str(&col.title, *cw, col.trunc_len, col.trunc_ch);

        let cc = format_cell(&title, *cw, col.title_align);

        fields.push(cc);








      }
      writeln!(f, "{}", fields.join(&colspace))?;


      //
      // Print heading underline
      //

      for ((col, cw), (cv, cell)) in
        iter::zip(iter::zip(self.cols, &col_widths), iter::zip(cvs, row))
      {
        let cell = trunc_str(&cell, *cw, col.trunc_len, col.trunc_ch);

        if let Some(ref stylize) = col.stylize {
          let cell = stylize(cv, &cell);
          let cc = format_painted_cell(&cell, *cw, col.cell_align);

          fields.push(cc);








        } else {
          let cc = format_cell(&cell, *cw, col.cell_align);

          fields.push(cc);








        }
      }

      writeln!(f, "{}", fields.join(&colspace))?;
    }
    Ok(())
  }
}

fn format_cell(s: &str, cell_width: usize, align: Align) -> String {
  match align {
    Align::Left => {
      //println!("cell_width={cell_width}, strlen(s)={}", strlen(s));
      let pad = cell_width - strlen(s);
      format!("{s}{:pad$}", "")
    }
    Align::Center => {
      let pad = cell_width - strlen(s);
      let (lpad, rpad) = split_len(pad);
      format!("{:lpad$}{s}{:rpad$}", "", "")
    }
    Align::Right => {
      let pad = cell_width - strlen(s);
      format!("{:pad$}{s}", "")
    }
  }
}

fn format_painted_cell(
  s: &Painted<String>,
  cell_width: usize,
  align: Align
) -> String {
  match align {
    Align::Left => {
      let pad = cell_width - strlen(&s.value);
      format!("{s}{:pad$}", "")
    }
    Align::Center => {
      let pad = cell_width - strlen(&s.value);
      let (lpad, rpad) = split_len(pad);
      format!("{:lpad$}{s}{:rpad$}", "", "")
    }
    Align::Right => {
      let pad = cell_width - strlen(&s.value);
      format!("{:pad$}{s}", "")
    }
  }
}


#[inline]
const fn split_len(len: usize) -> (usize, usize) {
  let left = len / 2;
  let right = len - left;
  (left, right)
}


fn clamp_width(w: usize, min: Option<usize>, max: Option<usize>) -> usize {
  let w = min.map_or(w, |min| if w < min { min } else { w });
  max.map_or(w, |max| if w > max { max } else { w })
}

fn trunc_str(
  s: &str,
  width: usize,
  trunc_len: usize,
  trunc_ch: char
) -> Cow<str> {
  let slen = strlen(s);
  if slen > width {
    let trunc = s[..slen - trunc_len - 1].to_string();

    let cont = std::iter::repeat_n(trunc_ch, trunc_len).collect::<String>();
    let s = format!("{trunc}{cont}");
    Cow::from(s)
  } else {
    Cow::from(s)
  }
}

# Change Log

⚠️  indicates a breaking change.

## [Unreleased]

[Details](/vdiff?from=qpprint-0.3.1&to=trunk)

### Added

### Changed

### Removed

---

## [0.3.1] - 2025-05-30

[Details](/vdiff?from=qpprint-0.3.0&to=qpprint-0.3.1)

### Added

- Derive `Copy`, `Clone` and `Debug` for `Align`.

### Changed

- Fix cell width calculation when it contains unicode characters that are wider
  than a single character cell when drawn to the terminal.  Apparently this
  isn't an exact science, but should work as long as one doesn't try to be too
  creative.

---

## [0.3.0] - 2025-05-16

[Details](/vdiff?from=qpprint-0.2.1&to=qpprint-0.3.0)

### Changed