use crate::config::Style;
use crate::roles::Roles;
use crate::tokens::Stream;
use cpp_parser::CppTokenKind;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Table {
pub cells: Vec<Vec<usize>>,
pub columns: usize,
pub starts: Vec<usize>,
pub paddings: Vec<usize>,
}
pub fn layout(widths: &[usize], first: usize, limit: usize) -> Option<Table> {
let n = widths.len();
if n < 2 {
return None;
}
let available = limit.saturating_sub(first);
if available == 0 {
return None;
}
let total = widths.iter().sum::<usize>() + n.saturating_sub(1);
let mut rows = total.div_ceil(available).max(1);
while rows <= n {
let columns = n.div_ceil(rows);
if columns >= 2
&& let Some(table) = with_columns(widths, first, limit, columns)
{
return if rows == 1 { None } else { Some(table) };
}
rows += 1;
}
None
}
fn with_columns(widths: &[usize], first: usize, limit: usize, columns: usize) -> Option<Table> {
let n = widths.len();
let mut column_widths = vec![0usize; columns];
for (index, width) in widths.iter().enumerate() {
let column = index % columns;
column_widths[column] = column_widths[column].max(*width);
}
let mut starts = vec![0usize; columns];
let mut column = first;
for (at, width) in column_widths.iter().enumerate() {
starts[at] = column;
column += width + 1;
}
let rows = n.div_ceil(columns);
for row in 0..rows {
let last = ((row + 1) * columns).min(n) - 1;
let column = last % columns;
if starts[column] + widths[last] > limit {
return None;
}
}
let mut paddings = Vec::with_capacity(n);
for (index, width) in widths.iter().enumerate() {
let column = index % columns;
paddings.push(column_widths[column] - width);
}
Some(Table {
cells: Vec::new(),
columns,
starts,
paddings,
})
}
pub fn cells_of(stream: &Stream<'_>, open: usize, close: usize) -> Option<Vec<Vec<usize>>> {
let mut cells: Vec<Vec<usize>> = vec![Vec::new()];
let mut depth = 0isize;
for index in open + 1..close {
if !stream.gaps[index].comments.is_empty() {
return None;
}
match stream.tokens[index].kind {
CppTokenKind::LeftParen | CppTokenKind::LeftBracket => depth += 1,
CppTokenKind::RightParen | CppTokenKind::RightBracket => depth -= 1,
CppTokenKind::LeftBrace | CppTokenKind::RightBrace => return None,
CppTokenKind::Semicolon => return None,
CppTokenKind::Comma if depth == 0 => {
cells.push(Vec::new());
continue;
}
_ => {}
}
cells.last_mut()?.push(index);
}
if cells.last().is_some_and(Vec::is_empty) {
cells.pop();
}
if cells.len() < 2 {
return None;
}
Some(cells)
}
pub fn is_an_initializer_list(roles: &Roles, stream: &Stream<'_>, open: usize) -> bool {
roles.init_brace.contains(&stream.tokens[open].start)
&& !roles.brace_kind.contains_key(&stream.tokens[open].start)
}
pub fn cell_width(
stream: &Stream<'_>,
roles: &Roles,
style: &Style,
cell: &[usize],
last: bool,
) -> usize {
let mut width = 0usize;
for (offset, index) in cell.iter().copied().enumerate() {
if offset > 0 {
width += crate::space::between(stream, index, roles, style);
}
width += stream.tokens[index].text.chars().count();
}
if !last { width + 1 } else { width }
}
#[cfg(test)]
mod tests {
use super::*;
fn integers() -> Vec<usize> {
let texts = [
"111", "2222", "33", "44444", "5", "666", "7777", "88", "999", "10", "11", "12", "13",
"14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25",
];
texts
.iter()
.enumerate()
.map(|(index, text)| text.len() + usize::from(index + 1 < texts.len()))
.collect()
}
#[test]
fn the_integer_array_becomes_nine_columns() {
let table = layout(&integers(), 24, 80).expect("a table");
assert_eq!(table.columns, 9);
assert_eq!(table.starts[0], 24);
assert_eq!(
table.paddings[0], 0,
"the widest first cell needs no padding"
);
}
#[test]
fn a_fitting_list_stays_on_one_line() {
assert_eq!(layout(&[5, 5, 5], 10, 80), None);
}
#[test]
fn twenty_five_names_are_five_by_five() {
let widths = [
8, 8, 8, 8, 8, 8, 8, 9, 9, 8, 9, 9, 8, 8, 11, 8, 7, 7, 10, 13, 9, 7, 10, 9, 8,
];
let table = layout(&widths, 4, 80).expect("a table");
assert_eq!(table.columns, 5);
}
#[test]
fn a_single_column_is_not_a_table() {
assert_eq!(layout(&[6, 7], 74, 80), None);
}
#[test]
fn the_widest_cell_of_a_column_sets_the_padding() {
let table = layout(&[3, 6, 4, 6], 0, 20).expect("a table");
assert_eq!(table.columns, 2);
assert_eq!(table.paddings, vec![1, 0, 0, 0]);
}
}