use std::{fmt, str::FromStr, sync::Arc};
use super::{
ColumnFilter, ColumnLayout, ColumnPin, ColumnPlace, GridQuery, GroupKey, SortDirection, TableFilters, TableSort,
TextMatch,
};
use crate::core::Date;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct TableTextError;
impl fmt::Display for TableTextError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("not the text form of a table's value")
}
}
impl std::error::Error for TableTextError {}
fn write_string(out: &mut String, text: &str) {
out.push('"');
for c in text.chars() {
if c == '"' || c == '\\' {
out.push('\\');
}
out.push(c);
}
out.push('"');
}
fn space(out: &mut String) {
if !out.is_empty() && !out.ends_with('(') {
out.push(' ');
}
}
#[derive(Clone, Debug, PartialEq)]
enum Token {
Open,
Close,
Colon,
Text(String),
Word(String),
}
fn tokenize(text: &str) -> Option<Vec<Token>> {
let mut tokens = Vec::new();
let mut chars = text.chars().peekable();
while let Some(&c) = chars.peek() {
match c {
c if c.is_whitespace() => {
chars.next();
}
'(' | ')' | ':' => {
chars.next();
tokens.push(match c {
'(' => Token::Open,
')' => Token::Close,
_ => Token::Colon,
});
}
'"' => {
chars.next();
let mut string = String::new();
loop {
match chars.next()? {
'"' => break,
'\\' => match chars.next()? {
escaped @ ('"' | '\\') => string.push(escaped),
_ => return None,
},
c => string.push(c),
}
}
tokens.push(Token::Text(string));
}
_ => {
let mut word = String::new();
while let Some(&c) = chars.peek() {
if c.is_whitespace() || matches!(c, '(' | ')' | ':' | '"') {
break;
}
word.push(c);
chars.next();
}
tokens.push(Token::Word(word));
}
}
}
Some(tokens)
}
struct Reader {
tokens: Vec<Token>,
at: usize,
}
impl Reader {
fn new(text: &str) -> Option<Self> {
Some(Self {
tokens: tokenize(text)?,
at: 0,
})
}
fn done(&self) -> bool {
self.at >= self.tokens.len()
}
fn peek(&self) -> Option<&Token> {
self.tokens.get(self.at)
}
fn next(&mut self) -> Option<Token> {
let token = self.tokens.get(self.at).cloned();
self.at += 1;
token
}
fn expect(&mut self, token: Token) -> Option<()> {
(self.next()? == token).then_some(())
}
fn text(&mut self) -> Option<String> {
match self.next()? {
Token::Text(text) => Some(text),
_ => None,
}
}
fn word(&mut self) -> Option<String> {
match self.next()? {
Token::Word(word) => Some(word),
_ => None,
}
}
fn opens(&mut self, name: &str) -> Option<()> {
(self.word()? == name).then_some(())?;
self.expect(Token::Open)
}
fn texts_to_close(&mut self) -> Option<Vec<String>> {
let mut texts = Vec::new();
loop {
match self.next()? {
Token::Close => return Some(texts),
Token::Text(text) => texts.push(text),
_ => return None,
}
}
}
}
impl ColumnLayout {
pub fn to_text(&self) -> String {
let mut out = String::new();
for place in &self.columns {
space(&mut out);
out.push_str("column(");
write_string(&mut out, &place.id);
if place.hidden {
out.push_str(" hidden");
}
if place.fit {
out.push_str(" fit");
}
if let Some(width) = place.width {
out.push_str(&format!(" width:{width}"));
}
match place.pin {
ColumnPin::Start => out.push_str(" pin:start"),
ColumnPin::End => out.push_str(" pin:end"),
ColumnPin::None => {}
}
out.push(')');
}
out
}
pub fn parse(text: &str) -> Option<ColumnLayout> {
let mut reader = Reader::new(text)?;
let mut columns = Vec::new();
while !reader.done() {
reader.opens("column")?;
let mut place = ColumnPlace {
id: Arc::from(reader.text()?),
hidden: false,
width: None,
fit: false,
pin: ColumnPin::None,
};
loop {
match reader.next()? {
Token::Close => break,
Token::Word(word) => match word.as_str() {
"hidden" => place.hidden = true,
"fit" => place.fit = true,
"width" => {
reader.expect(Token::Colon)?;
place.width = Some(reader.word()?.parse().ok()?);
}
"pin" => {
reader.expect(Token::Colon)?;
place.pin = match reader.word()?.as_str() {
"start" => ColumnPin::Start,
"end" => ColumnPin::End,
_ => return None,
};
}
_ => return None,
},
_ => return None,
}
}
columns.push(place);
}
Some(ColumnLayout { columns })
}
pub fn valid<S: AsRef<str>>(self, ids: impl IntoIterator<Item = S>) -> Self {
let ids: Vec<String> = ids.into_iter().map(|id| id.as_ref().to_owned()).collect();
let mut places: Vec<ColumnPlace> = Vec::with_capacity(ids.len());
for mut place in self.columns {
if !ids.iter().any(|id| **id == *place.id) || places.iter().any(|kept| kept.id == place.id) {
continue;
}
place.width = place.width.filter(|width| width.is_finite() && *width >= 0.0);
places.push(place);
}
for (index, id) in ids.iter().enumerate() {
if places.iter().any(|place| *place.id == **id) {
continue;
}
let at = ids[..index]
.iter()
.rev()
.find_map(|before| places.iter().position(|place| *place.id == **before))
.map_or(0, |before| before + 1);
places.insert(
at,
ColumnPlace {
id: Arc::from(id.as_str()),
hidden: false,
width: None,
fit: false,
pin: ColumnPin::None,
},
);
}
ColumnLayout { columns: places }
}
}
impl fmt::Display for ColumnLayout {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_text())
}
}
impl FromStr for ColumnLayout {
type Err = TableTextError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
ColumnLayout::parse(text).ok_or(TableTextError)
}
}
impl TableSort {
pub fn to_text(&self) -> String {
let mut out = String::new();
write_string(&mut out, &self.column);
out.push_str(match self.direction {
SortDirection::Ascending => " ascending",
SortDirection::Descending => " descending",
});
out
}
pub fn parse(text: &str) -> Option<TableSort> {
let mut reader = Reader::new(text)?;
let column = reader.text()?;
let direction = match reader.word()?.as_str() {
"ascending" => SortDirection::Ascending,
"descending" => SortDirection::Descending,
_ => return None,
};
reader.done().then(|| TableSort {
column: Arc::from(column),
direction,
})
}
}
impl TableSort {
pub fn list_to_text(sorts: &[TableSort]) -> String {
sorts.iter().map(TableSort::to_text).collect::<Vec<_>>().join(" ")
}
pub fn parse_list(text: &str) -> Option<Vec<TableSort>> {
if text.trim().is_empty() {
return Some(Vec::new());
}
let mut reader = Reader::new(text)?;
let mut sorts = Vec::new();
while !reader.done() {
let column = reader.text()?;
let direction = match reader.word()?.as_str() {
"ascending" => SortDirection::Ascending,
"descending" => SortDirection::Descending,
_ => return None,
};
sorts.push(TableSort {
column: Arc::from(column),
direction,
});
}
Some(sorts)
}
}
impl fmt::Display for TableSort {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_text())
}
}
impl FromStr for TableSort {
type Err = TableTextError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
TableSort::parse(text).ok_or(TableTextError)
}
}
impl TableFilters {
pub fn to_text(&self) -> String {
let mut parts = Vec::new();
for (id, filter) in self.iter() {
let mut out = String::from("filter(");
write_string(&mut out, id);
match filter {
ColumnFilter::Text { how, text } => {
out.push_str(match how {
TextMatch::Contains => " contains ",
TextMatch::StartsWith => " starts_with ",
TextMatch::Equals => " equals ",
});
write_string(&mut out, text);
}
ColumnFilter::Number { at_least, at_most } => {
if let Some(low) = at_least {
out.push_str(&format!(" at_least:{low}"));
}
if let Some(high) = at_most {
out.push_str(&format!(" at_most:{high}"));
}
}
ColumnFilter::Date { from, to } => {
if let Some(from) = from {
out.push_str(&format!(" from:{from}"));
}
if let Some(to) = to {
out.push_str(&format!(" to:{to}"));
}
}
ColumnFilter::Set(values) => {
out.push_str(" in");
for value in values {
space(&mut out);
write_string(&mut out, value);
}
}
ColumnFilter::Bool(value) => out.push_str(if *value { " is:true" } else { " is:false" }),
}
out.push(')');
parts.push(out);
}
parts.join(" ")
}
pub fn parse(text: &str) -> Option<TableFilters> {
let mut reader = Reader::new(text)?;
let mut filters = TableFilters::new();
while !reader.done() {
reader.opens("filter")?;
let (id, filter) = read_filter(&mut reader)?;
filters.set(&id, filter);
}
Some(filters)
}
}
fn read_filter(reader: &mut Reader) -> Option<(String, ColumnFilter)> {
let id = reader.text()?;
let filter = match reader.word()?.as_str() {
word @ ("contains" | "starts_with" | "equals") => {
let text = reader.text()?;
reader.expect(Token::Close)?;
ColumnFilter::Text {
how: match word {
"contains" => TextMatch::Contains,
"starts_with" => TextMatch::StartsWith,
_ => TextMatch::Equals,
},
text,
}
}
"in" => ColumnFilter::Set(reader.texts_to_close()?),
first => {
let mut pairs = vec![(first.to_owned(), {
reader.expect(Token::Colon)?;
reader.word()?
})];
loop {
match reader.next()? {
Token::Close => break,
Token::Word(name) => {
reader.expect(Token::Colon)?;
pairs.push((name, reader.word()?));
}
_ => return None,
}
}
let value = |name: &str| {
pairs
.iter()
.find(|(held, _)| held == name)
.map(|(_, value)| value.clone())
};
match pairs[0].0.as_str() {
"at_least" | "at_most" => {
let number = |name: &str| -> Option<Option<f64>> {
match value(name) {
None => Some(None),
Some(text) => text.parse().ok().map(Some),
}
};
ColumnFilter::Number {
at_least: number("at_least")?,
at_most: number("at_most")?,
}
}
"from" | "to" => ColumnFilter::Date {
from: match value("from") {
Some(text) => Some(parse_date(&text)?),
None => None,
},
to: match value("to") {
Some(text) => Some(parse_date(&text)?),
None => None,
},
},
"is" => match value("is")?.as_str() {
"true" => ColumnFilter::Bool(true),
"false" => ColumnFilter::Bool(false),
_ => return None,
},
_ => return None,
}
}
};
Some((id, filter))
}
fn parse_date(text: &str) -> Option<Date> {
let mut parts = text.splitn(3, '-');
let year = parts.next()?.parse().ok()?;
let month = parts.next()?.parse().ok()?;
let day = parts.next()?.parse().ok()?;
Date::new(year, month, day)
}
impl GridQuery {
pub fn to_text(&self) -> String {
let mut parts = Vec::new();
if !self.sort.is_empty() {
parts.push(format!("sort({})", TableSort::list_to_text(&self.sort)));
}
if !self.filters.is_empty() {
parts.push(self.filters.to_text());
}
if !self.search.is_empty() {
let mut out = String::from("search(");
write_string(&mut out, &self.search);
out.push(')');
parts.push(out);
}
parts.join(" ")
}
pub fn parse(text: &str) -> Option<GridQuery> {
let mut reader = Reader::new(text)?;
let mut query = GridQuery::default();
while !reader.done() {
match reader.word()?.as_str() {
"sort" => {
reader.expect(Token::Open)?;
loop {
match reader.next()? {
Token::Close => break,
Token::Text(column) => {
let direction = match reader.word()?.as_str() {
"ascending" => SortDirection::Ascending,
"descending" => SortDirection::Descending,
_ => return None,
};
query.sort.push(TableSort {
column: Arc::from(column),
direction,
});
}
_ => return None,
}
}
}
"filter" => {
reader.expect(Token::Open)?;
let (id, filter) = read_filter(&mut reader)?;
query.filters.set(&id, filter);
}
"search" => {
reader.expect(Token::Open)?;
query.search = reader.text()?;
reader.expect(Token::Close)?;
}
_ => return None,
}
}
Some(query)
}
}
impl fmt::Display for GridQuery {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_text())
}
}
impl FromStr for GridQuery {
type Err = TableTextError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
GridQuery::parse(text).ok_or(TableTextError)
}
}
impl fmt::Display for TableFilters {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_text())
}
}
impl FromStr for TableFilters {
type Err = TableTextError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
TableFilters::parse(text).ok_or(TableTextError)
}
}
impl GroupKey {
pub fn to_text(&self) -> String {
let mut out = String::from("group(");
for value in &self.values {
space(&mut out);
write_string(&mut out, value);
}
out.push(')');
out
}
pub fn parse(text: &str) -> Option<GroupKey> {
let mut groups = GroupKey::parse_list(text)?;
(groups.len() == 1).then(|| groups.remove(0))
}
pub fn list_to_text(groups: &[GroupKey]) -> String {
groups.iter().map(GroupKey::to_text).collect::<Vec<_>>().join(" ")
}
pub fn parse_list(text: &str) -> Option<Vec<GroupKey>> {
let mut reader = Reader::new(text)?;
let mut groups = Vec::new();
while !reader.done() {
reader.opens("group")?;
groups.push(GroupKey {
values: reader.texts_to_close()?,
});
}
Some(groups)
}
}
impl fmt::Display for GroupKey {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_text())
}
}
impl FromStr for GroupKey {
type Err = TableTextError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
GroupKey::parse(text).ok_or(TableTextError)
}
}
#[cfg(feature = "persistent_storage")]
mod stored {
use super::{ColumnLayout, GridQuery, GroupKey, TableFilters, TableSort};
use crate::persistent_storage::{IntoPersistentValue, PersistentValue};
fn text(bytes: &[u8]) -> Option<String> {
<String as PersistentValue>::decode_persistent_value(bytes)
}
impl PersistentValue for ColumnLayout {
fn decode_persistent_value(bytes: &[u8]) -> Option<Self> {
ColumnLayout::parse(&text(bytes)?)
}
}
impl IntoPersistentValue for ColumnLayout {
fn encode_persistent_value(self) -> Vec<u8> {
self.to_text().encode_persistent_value()
}
}
impl PersistentValue for TableSort {
fn decode_persistent_value(bytes: &[u8]) -> Option<Self> {
TableSort::parse(&text(bytes)?)
}
}
impl IntoPersistentValue for TableSort {
fn encode_persistent_value(self) -> Vec<u8> {
self.to_text().encode_persistent_value()
}
}
impl PersistentValue for Option<TableSort> {
fn decode_persistent_value(bytes: &[u8]) -> Option<Self> {
let text = text(bytes)?;
if text.trim().is_empty() {
return Some(None);
}
Some(Some(TableSort::parse(&text)?))
}
}
impl IntoPersistentValue for Option<TableSort> {
fn encode_persistent_value(self) -> Vec<u8> {
self
.map(|sort| sort.to_text())
.unwrap_or_default()
.encode_persistent_value()
}
}
impl PersistentValue for Vec<TableSort> {
fn decode_persistent_value(bytes: &[u8]) -> Option<Self> {
TableSort::parse_list(&text(bytes)?)
}
}
impl IntoPersistentValue for Vec<TableSort> {
fn encode_persistent_value(self) -> Vec<u8> {
TableSort::list_to_text(&self).encode_persistent_value()
}
}
impl PersistentValue for GridQuery {
fn decode_persistent_value(bytes: &[u8]) -> Option<Self> {
GridQuery::parse(&text(bytes)?)
}
}
impl IntoPersistentValue for GridQuery {
fn encode_persistent_value(self) -> Vec<u8> {
self.to_text().encode_persistent_value()
}
}
impl PersistentValue for TableFilters {
fn decode_persistent_value(bytes: &[u8]) -> Option<Self> {
TableFilters::parse(&text(bytes)?)
}
}
impl IntoPersistentValue for TableFilters {
fn encode_persistent_value(self) -> Vec<u8> {
self.to_text().encode_persistent_value()
}
}
impl PersistentValue for Vec<GroupKey> {
fn decode_persistent_value(bytes: &[u8]) -> Option<Self> {
GroupKey::parse_list(&text(bytes)?)
}
}
impl IntoPersistentValue for Vec<GroupKey> {
fn encode_persistent_value(self) -> Vec<u8> {
GroupKey::list_to_text(&self).encode_persistent_value()
}
}
}