path: root/src/format.rs

//! Define table formatting utilities

use std::io::{Write, Error};

use super::utils::NEWLINE;

/// Alignment for cell's content
#[derive(Clone, Debug, PartialEq, Copy)]
pub enum Alignment  {
	LEFT,
	CENTER,
	RIGHT
}

/// Position of a line separator in a table
#[derive(Clone, Debug, PartialEq, Copy)]
pub enum LinePosition {
	Top,
	Title,
	Intern,
	Bottom
}

/// Position of a column separator in a row
#[derive(Clone, Debug, PartialEq, Copy)]
pub enum ColumnPosition {
	Left,
	Intern,
	Right
}

/// Contains the character used for printing a line separator
#[derive(Clone, Debug, Copy)]
pub struct LineSeparator {
	/// Line separator
	line: char,
	/// Internal junction separator
	junc: char,
	/// Left junction separator
	ljunc: char,
	/// Right junction separator
	rjunc: char
}

impl LineSeparator {

	/// Create a new line separator instance where `line` is the character used to separate 2 lines
	/// and `junc` is the one used for junctions between columns and lines
	pub fn new(line: char, junc: char, ljunc: char, rjunc: char) -> LineSeparator {
		return LineSeparator{line: line, junc: junc, ljunc: ljunc, rjunc: rjunc};
	}

	/// Print a full line separator to `out`. `col_width` is a slice containing the width of each column
	pub fn print<T: Write+?Sized>(&self, out: &mut T, col_width: &[usize], colsep: bool, lborder: bool, rborder: bool) -> Result<(), Error> {
		if lborder {
			try!(out.write_all(&[self.ljunc as u8]));
		}
		let mut iter = col_width.into_iter().peekable();
		while let Some(width) = iter.next() {
			try!(out.write_all(&vec![self.line as u8; width+2]));
			if colsep && iter.peek().is_some() {
				try!(out.write_all(&[self.junc as u8]));
			}
		}
		if rborder {
			try!(out.write_all(&[self.rjunc as u8]));
		}
		return out.write_all(NEWLINE);
	}
}

impl Default for LineSeparator {
	fn default() -> Self {
		return LineSeparator::new('-', '+', '+', '+');
	}
}

/// Contains the table formatting rules
#[derive(Clone, Debug, Copy)]
pub struct TableFormat {
	/// Optional column separator character
	csep: Option<char>,
	/// Optional left border character
	lborder: Option<char>,
	/// Optional right border character
	rborder: Option<char>,
	/// Optional internal line separator
	lsep: Option<LineSeparator>,
	/// Optional title line separator
	tsep: Option<LineSeparator>,
	/// Optional top line separator
	top_sep: Option<LineSeparator>,
	/// Optional bottom line separator
	bottom_sep: Option<LineSeparator>,
	/// Left padding
	pad_left: usize,
	/// Right padding
	pad_right: usize
}

impl TableFormat {

	/// Create a new empty TableFormat.
	pub fn new() -> TableFormat {
		 return TableFormat{
			 csep: None,
			 lborder: None,
			 rborder: None,
			 lsep: None,
			 tsep: None,
			 top_sep: None,
			 bottom_sep: None,
			 pad_left: 0,
			 pad_right: 0
		 };
	}

	/// Return a tuple with left and right padding
	pub fn get_padding(&self) -> (usize, usize) {
		return (self.pad_left, self.pad_right);
	}

	/// Set left and right padding
	pub fn padding(&mut self, left: usize, right: usize) {
		self.pad_left = left;
		self.pad_right = right;
	}

	/// Set the character used for internal column separation
	pub fn column_separator(&mut self, separator: char) {
		self.csep = Some(separator);
	}

	/// Set the character used for table borders
	pub fn borders(&mut self, border: char) {
		self.lborder = Some(border);
		self.rborder = Some(border);
	}

	/// Set a line separator
	pub fn separator(&mut self, what: LinePosition, separator: LineSeparator) {
		*match what {
			LinePosition::Top => &mut self.top_sep,
			LinePosition::Bottom => &mut self.bottom_sep,
			LinePosition::Title => &mut self.tsep,
			LinePosition::Intern => &mut self.lsep
		} = Some(separator);
	}

	/// Set format for multiple kind of line separator
	pub fn separators(&mut self, what: &[LinePosition], separator: LineSeparator) {
		for pos in what {
			self.separator(*pos, separator);
		}
	}

	fn get_sep_for_line(&self, pos: LinePosition) -> &Option<LineSeparator> {
		return match pos {
			LinePosition::Intern => return &self.lsep,
			LinePosition::Top => return &self.top_sep,
			LinePosition::Bottom => return &self.bottom_sep,
			LinePosition::Title => match &self.tsep {
				s @ &Some(_) => s,
				&None => &self.lsep
			}
		};
	}

	/// Print a full line separator to `out`. `col_width` is a slice containing the width of each column
	pub fn print_line_separator<T: Write+?Sized>(&self, out: &mut T, col_width: &[usize], pos: LinePosition) -> Result<(), Error> {
		return match *self.get_sep_for_line(pos) {
			Some(ref l) => l.print(out, col_width, self.csep.is_some(), self.lborder.is_some(), self.rborder.is_some()),
			None => Ok(())
		};
	}

	pub fn get_column_separator(&self, pos: ColumnPosition) -> Option<char> {
		return match pos {
			ColumnPosition::Left => self.lborder,
			ColumnPosition::Intern => self.csep,
			ColumnPosition::Right => self.rborder
		};
	}

	/// Print a column separator or a table border
	pub fn print_column_separator<T: Write+?Sized>(&self, out: &mut T, pos: ColumnPosition) -> Result<(), Error> {
		return match self.get_column_separator(pos) {
			Some(s) => out.write_all(&[s as u8]),
			None => Ok(())
		};
	}
}

impl Default for TableFormat {
	fn default() -> Self {
		return TableFormat::new();
	}
}

/// A builder to create a `TableFormat`
pub struct FormatBuilder {
	format: Box<TableFormat>
}

impl FormatBuilder {
	pub fn new() -> FormatBuilder {
		return FormatBuilder {
			format: Box::new(TableFormat::new())
		};
	}

	/// Set left and right padding
	pub fn padding(mut self, left: usize, right: usize) -> Self {
		self.format.padding(left, right);
		return self;
	}

	/// Set the character used for internal column separation
	pub fn column_separator(mut self, separator: char) -> Self {
		self.format.column_separator(separator);
		return self;
	}

	/// Set the character used for table borders
	pub fn borders(mut self, border: char) -> Self {
		self.format.borders(border);
		return self;
	}

	/// Set a line separator format
	pub fn separator(mut self, what: LinePosition, separator: LineSeparator) -> Self {
		self.format.separator(what, separator);
		return self;
	}

	/// Set separator format for multiple kind of line separators
	pub fn separators(mut self, what: &[LinePosition], separator: LineSeparator) -> Self {
		self.format.separators(what, separator);
		return self;
	}

	/// Consume this builder and return the generated `TableFormat`
	pub fn build(self) -> TableFormat {
		return *self.format;
	}
}

/// Predifined formats. Those constants are lazily evaluated when
/// the corresponding struct is dereferenced
pub mod consts {
	use super::{TableFormat, LineSeparator, FormatBuilder, LinePosition};

	lazy_static! {