#![allow(clippy::should_implement_trait)]
use crate::cell::utils::get_column_letter;
use crate::exceptions::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ReferenceDataType {
Numeric,
String,
}
impl ReferenceDataType {
pub fn as_str(self) -> &'static str {
match self {
ReferenceDataType::Numeric => "n",
ReferenceDataType::String => "s",
}
}
pub fn from_str(value: &str) -> Result<Self> {
match value {
"n" => Ok(ReferenceDataType::Numeric),
"s" => Ok(ReferenceDataType::String),
other => Err(Error::Value(format!(
"References must be either numeric or strings, got {other}"
))),
}
}
pub fn ref_element(self) -> &'static str {
match self {
ReferenceDataType::Numeric => "numRef",
ReferenceDataType::String => "strRef",
}
}
pub fn cache_element(self) -> &'static str {
match self {
ReferenceDataType::Numeric => "numCache",
ReferenceDataType::String => "strCache",
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct Reference {
pub sheet_title: String,
pub pos1: (usize, usize),
pub pos2: Option<(usize, usize)>,
pub data_type: Option<ReferenceDataType>,
pub number_format: Option<String>,
values: Option<Vec<CellValue>>,
}
#[derive(Debug, Clone, PartialEq)]
pub enum CellValue {
None,
Text(String),
Number(f64),
}
impl CellValue {
pub fn to_cache_string(&self) -> String {
match self {
CellValue::None => String::new(),
CellValue::Text(t) => t.clone(),
CellValue::Number(v) => {
if *v == v.trunc() && v.abs() < 1e16 {
format!("{}", *v as i64)
} else {
format!("{v}")
}
}
}
}
}
impl Reference {
pub fn new(
sheet_title: &str,
pos1: (usize, usize),
pos2: Option<(usize, usize)>,
data_type: Option<ReferenceDataType>,
number_format: Option<&str>,
) -> Result<Self> {
if let Some(format) = number_format {
if !crate::styles::numbers::is_builtin(format) {
return Err(Error::Value(format!("Invalid number format: {format}")));
}
}
Ok(Reference {
sheet_title: sheet_title.to_string(),
pos1,
pos2,
data_type,
number_format: number_format.map(str::to_string),
values: None,
})
}
pub fn set_values(&mut self, values: Vec<CellValue>, data_type: ReferenceDataType) {
self.values = Some(values);
self.data_type = Some(data_type);
}
pub fn values(&self) -> Option<&[CellValue]> {
self.values.as_deref()
}
pub fn effective_data_type(&self) -> ReferenceDataType {
self.data_type.unwrap_or(ReferenceDataType::Numeric)
}
pub fn effective_number_format(&self) -> &str {
self.number_format.as_deref().unwrap_or("General")
}
pub fn to_reference_string(&self) -> String {
let (r1, c1) = self.pos1;
match self.pos2 {
Some((r2, c2)) => {
let letters1 = get_column_letter(c1 as u32 + 1).unwrap_or_default();
let letters2 = get_column_letter(c2 as u32 + 1).unwrap_or_default();
format!(
"'{}'!${}${}:${}${}",
self.sheet_title,
letters1,
r1 + 1,
letters2,
r2 + 1
)
}
None => {
let letters = get_column_letter(c1 as u32 + 1).unwrap_or_default();
format!("'{}'!${}${}", self.sheet_title, letters, r1 + 1)
}
}
}
pub fn bounds(&self) -> Result<crate::worksheet::iter_worksheet::RangeBounds> {
let (r1, c1) = self.pos1;
match self.pos2 {
Some((r2, c2)) => Ok(crate::worksheet::iter_worksheet::RangeBounds {
min_col: c1 as u32 + 1,
min_row: r1 as u32 + 1,
max_col: c2 as u32 + 1,
max_row: r2 as u32 + 1,
}),
None => Ok(crate::worksheet::iter_worksheet::RangeBounds {
min_col: c1 as u32 + 1,
min_row: r1 as u32 + 1,
max_col: c1 as u32 + 1,
max_row: r1 as u32 + 1,
}),
}
}
}
impl std::fmt::Display for Reference {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.to_reference_string())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn single_cell_notation() {
let reference = Reference::new("Sheet1", (0, 0), None, None, None).unwrap();
assert_eq!(reference.to_reference_string(), "'Sheet1'!$A$1");
}
#[test]
fn range_notation() {
let reference = Reference::new("My Sheet", (1, 2), Some((4, 5)), None, None).unwrap();
assert_eq!(reference.to_reference_string(), "'My Sheet'!$C$2:$F$5");
assert_eq!(reference.to_string(), "'My Sheet'!$C$2:$F$5");
}
#[test]
fn bounds_are_one_based() {
let reference = Reference::new("S", (0, 0), Some((1, 1)), None, None).unwrap();
let bounds = reference.bounds().unwrap();
assert_eq!(bounds.min_col, 1);
assert_eq!(bounds.min_row, 1);
assert_eq!(bounds.max_col, 2);
assert_eq!(bounds.max_row, 2);
}
#[test]
fn data_type_drives_element_names() {
assert_eq!(ReferenceDataType::Numeric.ref_element(), "numRef");
assert_eq!(ReferenceDataType::Numeric.cache_element(), "numCache");
assert_eq!(ReferenceDataType::String.ref_element(), "strRef");
assert_eq!(ReferenceDataType::String.cache_element(), "strCache");
assert!(ReferenceDataType::from_str("bogus").is_err());
}
#[test]
fn defaults_are_numeric_and_general() {
let reference = Reference::new("S", (0, 0), None, None, None).unwrap();
assert_eq!(reference.effective_data_type(), ReferenceDataType::Numeric);
assert_eq!(reference.effective_number_format(), "General");
}
#[test]
fn only_a_built_in_number_format_is_accepted() {
let reference = Reference::new("S", (0, 0), None, None, Some("0.00")).unwrap();
assert_eq!(reference.effective_number_format(), "0.00");
let error = Reference::new("S", (0, 0), None, None, Some("yyyy-mm-dd")).unwrap_err();
assert!(
error.to_string().contains("Invalid number format"),
"{error}"
);
}
#[test]
fn cache_strings_match_python_formatting() {
assert_eq!(CellValue::Number(1.0).to_cache_string(), "1");
assert_eq!(CellValue::Number(1.5).to_cache_string(), "1.5");
assert_eq!(CellValue::Text("x".into()).to_cache_string(), "x");
assert_eq!(CellValue::None.to_cache_string(), "");
}
}