use std::collections::BTreeMap;
use crate::exceptions::Result;
pub fn normalize_reference(reference: &str) -> Option<String> {
let reference = reference.trim();
if reference.is_empty() {
None
} else {
Some(reference.to_uppercase())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct FilterColumn {
pub col_id: u32,
pub vals: Vec<String>,
pub blank: bool,
}
impl FilterColumn {
pub fn new(col_id: u32, vals: Vec<String>, blank: bool) -> Self {
FilterColumn {
col_id,
vals,
blank,
}
}
pub fn filter_attributes(&self) -> Vec<(String, String)> {
if self.blank {
vec![("blank".to_string(), "1".to_string())]
} else {
Vec::new()
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct SortCondition {
pub reference: String,
pub descending: bool,
}
impl SortCondition {
pub fn new(reference: &str, descending: bool) -> Self {
SortCondition {
reference: normalize_reference(reference).unwrap_or_default(),
descending,
}
}
pub fn attributes(&self) -> Vec<(String, String)> {
let mut attrs = vec![("ref".to_string(), self.reference.clone())];
if self.descending {
attrs.push(("descending".to_string(), "1".to_string()));
}
attrs
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct AutoFilter {
reference: Option<String>,
filter_columns: BTreeMap<u32, FilterColumn>,
sort_conditions: Vec<SortCondition>,
}
impl AutoFilter {
pub fn new() -> Self {
AutoFilter::default()
}
pub fn reference(&self) -> Option<&str> {
self.reference.as_deref()
}
pub fn set_reference(&mut self, reference: &str) {
self.reference = normalize_reference(reference);
}
pub fn filter_columns(&self) -> &BTreeMap<u32, FilterColumn> {
&self.filter_columns
}
pub fn sort_conditions(&self) -> &[SortCondition] {
&self.sort_conditions
}
pub fn add_filter_column(
&mut self,
col_id: u32,
vals: Vec<String>,
blank: bool,
) -> FilterColumn {
let column = FilterColumn::new(col_id, vals, blank);
self.filter_columns.insert(col_id, column.clone());
column
}
pub fn add_sort_condition(&mut self, reference: &str, descending: bool) -> SortCondition {
let condition = SortCondition::new(reference, descending);
self.sort_conditions.push(condition.clone());
condition
}
pub fn has_details(&self) -> bool {
!self.filter_columns.is_empty() || !self.sort_conditions.is_empty()
}
}
pub fn parse_u32_attr(value: Option<&str>) -> u32 {
value
.and_then(|v| v.trim().parse::<f64>().ok())
.map(|v| v.trunc() as i64)
.unwrap_or(0) as u32
}
pub fn parse_bool_attr(value: Option<&str>) -> bool {
parse_u32_attr(value) != 0
}
pub fn reference_bounds(reference: &str) -> Result<crate::worksheet::iter_worksheet::RangeBounds> {
crate::worksheet::iter_worksheet::get_range_boundaries(reference, 0, 1)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reference_is_normalised() {
assert_eq!(normalize_reference("a1:b3"), Some("A1:B3".to_string()));
assert_eq!(normalize_reference(""), None);
assert_eq!(normalize_reference(" "), None);
}
#[test]
fn filters_and_sort_conditions_accumulate() {
let mut filter = AutoFilter::new();
filter.set_reference("a1:d10");
filter.add_filter_column(1, vec!["x".into(), "y".into()], false);
filter.add_sort_condition("a2:a10", true);
assert_eq!(filter.reference(), Some("A1:D10"));
assert_eq!(filter.filter_columns().len(), 1);
assert_eq!(filter.filter_columns()[&1].vals.len(), 2);
assert_eq!(filter.sort_conditions().len(), 1);
assert!(filter.has_details());
}
#[test]
fn blank_attribute_only_when_set() {
let with_blank = FilterColumn::new(0, vec![], true);
assert_eq!(
with_blank.filter_attributes(),
vec![("blank".to_string(), "1".to_string())]
);
let without = FilterColumn::new(0, vec![], false);
assert!(without.filter_attributes().is_empty());
}
#[test]
fn sort_condition_attributes() {
let asc = SortCondition::new("a1:a5", false);
assert_eq!(
asc.attributes(),
vec![("ref".to_string(), "A1:A5".to_string())]
);
let desc = SortCondition::new("a1:a5", true);
assert_eq!(desc.attributes().len(), 2);
assert_eq!(
desc.attributes()[1],
("descending".to_string(), "1".to_string())
);
}
#[test]
fn attribute_parsing_matches_python_coercions() {
assert_eq!(parse_u32_attr(Some("3")), 3);
assert_eq!(parse_u32_attr(None), 0);
assert_eq!(parse_u32_attr(Some("")), 0);
assert_eq!(parse_u32_attr(Some("2.7")), 2);
assert!(parse_bool_attr(Some("1")));
assert!(!parse_bool_attr(None));
assert!(!parse_bool_attr(Some("0")));
}
#[test]
fn empty_filter_needs_no_body() {
let mut filter = AutoFilter::new();
assert!(!filter.has_details());
filter.set_reference("A1:B2");
assert!(!filter.has_details());
}
}