formualizer_eval/
test_workbook.rs

1//! crates/formualizer-eval/src/test_workbook.rs
2//! --------------------------------------------
3//! Lightweight in-memory workbook for unit/prop tests.
4use std::collections::HashMap;
5use std::sync::Arc;
6
7use crate::engine::range_view::RangeView;
8use crate::function::Function;
9use crate::traits::{
10    EvaluationContext, FunctionProvider, NamedRangeResolver, Range, RangeResolver,
11    ReferenceResolver, Resolver, SourceResolver, Table, TableResolver,
12};
13use formualizer_common::{ExcelError, LiteralValue, parse_a1_1based};
14use formualizer_parse::{
15    ExcelErrorKind,
16    parser::{ReferenceType, TableReference},
17};
18
19type V = LiteralValue;
20type CellKey = (u32, u32); // 1-based (row, col)
21
22#[derive(Default, Clone)]
23struct Sheet {
24    cells: HashMap<CellKey, V>,
25}
26
27#[derive(Default)]
28pub struct TestWorkbook {
29    sheets: HashMap<String, Sheet>,
30    named: HashMap<String, Vec<Vec<V>>>,
31    tables: HashMap<String, Box<dyn Table>>,
32    fns: HashMap<(String, String), Arc<dyn Function>>,
33    aliases: HashMap<(String, String), (String, String)>,
34}
35
36impl TestWorkbook {
37    /* ─────────────── constructors ─────────────── */
38    pub fn new() -> Self {
39        Self::default()
40    }
41
42    fn default_sheet_name(&self) -> &str {
43        const FALLBACK: &str = "Sheet1";
44        if self.sheets.contains_key(FALLBACK) {
45            return FALLBACK;
46        }
47        self.sheets
48            .keys()
49            .min()
50            .map(|s| s.as_str())
51            .unwrap_or(FALLBACK)
52    }
53
54    /* ─────────────── cell helpers ─────────────── */
55    pub fn with_cell<S: Into<String>>(mut self, sheet: S, row: u32, col: u32, v: V) -> Self {
56        let sh = self.sheets.entry(sheet.into()).or_default();
57        sh.cells.insert((row, col), v);
58        self
59    }
60
61    pub fn with_cell_a1<S: Into<String>, A: AsRef<str>>(self, sheet: S, a1: A, v: V) -> Self {
62        let (col, row) = parse_a1(a1.as_ref()).expect("bad A1 ref in with_cell_a1");
63        self.with_cell(sheet, row, col, v)
64    }
65
66    pub fn with_range<S: Into<String>>(
67        mut self,
68        sheet: S,
69        row: u32,
70        col: u32,
71        data: Vec<Vec<V>>,
72    ) -> Self {
73        let sh = self.sheets.entry(sheet.into()).or_default();
74        for (r_off, r) in data.into_iter().enumerate() {
75            for (c_off, v) in r.into_iter().enumerate() {
76                sh.cells.insert((row + r_off as u32, col + c_off as u32), v);
77            }
78        }
79        self
80    }
81
82    /* ─────────────── named ranges ─────────────── */
83    pub fn with_named_range<S: Into<String>>(mut self, name: S, data: Vec<Vec<V>>) -> Self {
84        self.named.insert(name.into(), data);
85        self
86    }
87
88    /* ─────────────── tables (placeholder) ─────── */
89    pub fn with_table<T: Table + 'static, S: Into<String>>(mut self, name: S, table: T) -> Self {
90        self.tables.insert(name.into(), Box::new(table));
91        self
92    }
93
94    /// Create a simple in-memory table with headers, optional totals, and data.
95    /// headers: column names in order; data: Vec of rows; totals: optional row of totals matching width
96    pub fn with_simple_table<S: Into<String>>(
97        mut self,
98        name: S,
99        headers: Vec<String>,
100        data: Vec<Vec<V>>,
101        totals: Option<Vec<V>>,
102    ) -> Self {
103        #[derive(Debug)]
104        struct SimpleTable {
105            headers: Vec<String>,
106            data: Vec<Vec<V>>, // HxW
107            totals: Option<Vec<V>>,
108        }
109        impl Table for SimpleTable {
110            fn get_cell(&self, row: usize, column: &str) -> Result<V, ExcelError> {
111                // row is 0-based within data body
112                let column_key = column.to_lowercase();
113                let col_idx = self
114                    .headers
115                    .iter()
116                    .position(|h| h.to_lowercase() == column_key)
117                    .ok_or_else(|| ExcelError::from(ExcelErrorKind::Ref))?;
118                self.data
119                    .get(row)
120                    .and_then(|r| r.get(col_idx))
121                    .cloned()
122                    .ok_or_else(|| ExcelError::from(ExcelErrorKind::Ref))
123            }
124            fn get_column(&self, column: &str) -> Result<Box<dyn Range>, ExcelError> {
125                let column_key = column.to_lowercase();
126                let col_idx = self
127                    .headers
128                    .iter()
129                    .position(|h| h.to_lowercase() == column_key)
130                    .ok_or_else(|| ExcelError::from(ExcelErrorKind::Ref))?;
131                let mut col: Vec<Vec<V>> = Vec::with_capacity(self.data.len());
132                for r in &self.data {
133                    col.push(vec![r.get(col_idx).cloned().unwrap_or(V::Empty)]);
134                }
135                Ok(Box::new(crate::traits::InMemoryRange::new(col)))
136            }
137            fn columns(&self) -> Vec<String> {
138                self.headers.clone()
139            }
140            fn data_height(&self) -> usize {
141                self.data.len()
142            }
143            fn has_headers(&self) -> bool {
144                true
145            }
146            fn has_totals(&self) -> bool {
147                self.totals.is_some()
148            }
149            fn headers_row(&self) -> Option<Box<dyn Range>> {
150                Some(Box::new(crate::traits::InMemoryRange::new(vec![
151                    self.headers
152                        .iter()
153                        .cloned()
154                        .map(LiteralValue::Text)
155                        .collect(),
156                ])))
157            }
158            fn totals_row(&self) -> Option<Box<dyn Range>> {
159                self.totals.as_ref().map(|t| {
160                    Box::new(crate::traits::InMemoryRange::new(vec![t.clone()])) as Box<dyn Range>
161                })
162            }
163            fn data_body(&self) -> Option<Box<dyn Range>> {
164                Some(Box::new(crate::traits::InMemoryRange::new(
165                    self.data.clone(),
166                )))
167            }
168            fn clone_box(&self) -> Box<dyn Table> {
169                Box::new(SimpleTable {
170                    headers: self.headers.clone(),
171                    data: self.data.clone(),
172                    totals: self.totals.clone(),
173                })
174            }
175        }
176        let table = SimpleTable {
177            headers,
178            data,
179            totals,
180        };
181        self.tables.insert(name.into(), Box::new(table));
182        self
183    }
184
185    /* ─────────────── function helpers ─────────── */
186    pub fn with_function(mut self, func: Arc<dyn Function>) -> Self {
187        let ns = func.namespace().to_uppercase();
188        let name = func.name().to_uppercase();
189        for &alias in func.aliases() {
190            if !alias.eq_ignore_ascii_case(&name) {
191                // store alias mapping in workbook-scoped alias map
192                let akey = (ns.clone(), alias.to_uppercase());
193                self.aliases.insert(akey, (ns.clone(), name.clone()));
194            }
195        }
196        self.fns.insert((ns, name), func);
197        self
198    }
199
200    /// Register an alias for a function in this workbook (test helper)
201    pub fn with_alias<S: AsRef<str>>(
202        mut self,
203        ns: S,
204        alias: S,
205        target_ns: S,
206        target_name: S,
207    ) -> Self {
208        let key = (ns.as_ref().to_uppercase(), alias.as_ref().to_uppercase());
209        let val = (
210            target_ns.as_ref().to_uppercase(),
211            target_name.as_ref().to_uppercase(),
212        );
213        self.aliases.insert(key, val);
214        self
215    }
216
217    /* ─────────────── interpreter shortcut ─────── */
218    pub fn interpreter(&self) -> crate::interpreter::Interpreter<'_> {
219        crate::interpreter::Interpreter::new(self, self.default_sheet_name())
220    }
221}
222
223/* ─────────────────────── trait impls ─────────────────────── */
224impl EvaluationContext for TestWorkbook {
225    fn cancellation_token(&self) -> Option<Arc<std::sync::atomic::AtomicBool>> {
226        None
227    }
228
229    fn resolve_range_view<'c>(
230        &'c self,
231        reference: &ReferenceType,
232        current_sheet: &str,
233    ) -> Result<RangeView<'c>, ExcelError> {
234        use formualizer_common::LiteralValue as V;
235        use formualizer_parse::parser::ReferenceType as RT;
236
237        match reference {
238            // Preserve #REF! for invalid single-cell references by embedding as a 1x1 value
239            RT::Cell {
240                sheet, row, col, ..
241            } => {
242                let sheet_name = sheet.as_deref().unwrap_or(current_sheet);
243                let v = match self.resolve_cell_reference(Some(sheet_name), *row, *col) {
244                    Ok(val) => val,
245                    Err(e) => V::Error(e),
246                };
247                let owned = vec![vec![v]];
248                Ok(RangeView::from_owned_rows(owned, self.date_system()))
249            }
250            // Named range: delegate to resolver so missing names become #NAME?
251            RT::NamedRange(name) => {
252                let rows = self.resolve_named_range_reference(name)?;
253                Ok(RangeView::from_owned_rows(rows, self.date_system()))
254            }
255            // Tables and rectangular ranges: materialize via generic path
256            _ => {
257                let range_box = self.resolve_range_like(reference)?;
258                let owned: Vec<Vec<V>> = range_box.materialise().into_owned();
259                Ok(RangeView::from_owned_rows(owned, self.date_system()))
260            }
261        }
262    }
263
264    fn used_rows_for_columns(
265        &self,
266        sheet: &str,
267        start_col: u32,
268        end_col: u32,
269    ) -> Option<(u32, u32)> {
270        let sh = self.sheets.get(sheet)?;
271        let mut min_r: Option<u32> = None;
272        let mut max_r: Option<u32> = None;
273        for &(r, c) in sh.cells.keys() {
274            if c >= start_col && c <= end_col {
275                min_r = Some(min_r.map(|m| m.min(r)).unwrap_or(r));
276                max_r = Some(max_r.map(|m| m.max(r)).unwrap_or(r));
277            }
278        }
279        match (min_r, max_r) {
280            (Some(a), Some(b)) => Some((a, b)),
281            _ => None,
282        }
283    }
284
285    fn used_cols_for_rows(&self, sheet: &str, start_row: u32, end_row: u32) -> Option<(u32, u32)> {
286        let sh = self.sheets.get(sheet)?;
287        let mut min_c: Option<u32> = None;
288        let mut max_c: Option<u32> = None;
289        for &(r, c) in sh.cells.keys() {
290            if r >= start_row && r <= end_row {
291                min_c = Some(min_c.map(|m| m.min(c)).unwrap_or(c));
292                max_c = Some(max_c.map(|m| m.max(c)).unwrap_or(c));
293            }
294        }
295        match (min_c, max_c) {
296            (Some(a), Some(b)) => Some((a, b)),
297            _ => None,
298        }
299    }
300
301    fn sheet_bounds(&self, _sheet: &str) -> Option<(u32, u32)> {
302        Some((1_048_576, 16_384))
303    }
304
305    fn backend_caps(&self) -> crate::traits::BackendCaps {
306        crate::traits::BackendCaps {
307            streaming: false,
308            used_region: true,
309            write: false,
310            tables: false,
311            async_stream: false,
312        }
313    }
314}
315impl ReferenceResolver for TestWorkbook {
316    fn resolve_cell_reference(
317        &self,
318        sheet: Option<&str>,
319        row: u32,
320        col: u32,
321    ) -> Result<V, ExcelError> {
322        let sheet_name = sheet.unwrap_or(self.default_sheet_name());
323        self.sheets
324            .get(sheet_name)
325            .and_then(|sh| sh.cells.get(&(row, col)).cloned())
326            .ok_or_else(|| ExcelError::from(ExcelErrorKind::Ref))
327    }
328}
329
330impl RangeResolver for TestWorkbook {
331    fn resolve_range_reference(
332        &self,
333        sheet: Option<&str>,
334        sr: Option<u32>,
335        sc: Option<u32>,
336        er: Option<u32>,
337        ec: Option<u32>,
338    ) -> Result<Box<dyn Range>, ExcelError> {
339        let (sr, sc, er, ec) = match (sr, sc, er, ec) {
340            (Some(sr), Some(sc), Some(er), Some(ec)) => (sr, sc, er, ec),
341            _ => return Err(ExcelError::from(ExcelErrorKind::NImpl)),
342        };
343        let sheet_name = sheet.unwrap_or(self.default_sheet_name());
344        let sh = self
345            .sheets
346            .get(sheet_name)
347            .ok_or_else(|| ExcelError::from(ExcelErrorKind::Ref))?;
348        let mut data = Vec::with_capacity((er - sr + 1) as usize);
349        for r in sr..=er {
350            let mut row_vec = Vec::with_capacity((ec - sc + 1) as usize);
351            for c in sc..=ec {
352                row_vec.push(sh.cells.get(&(r, c)).cloned().unwrap_or(V::Empty));
353            }
354            data.push(row_vec);
355        }
356        Ok(Box::new(crate::traits::InMemoryRange::new(data)))
357    }
358}
359
360impl NamedRangeResolver for TestWorkbook {
361    fn resolve_named_range_reference(&self, name: &str) -> Result<Vec<Vec<V>>, ExcelError> {
362        self.named
363            .get(name)
364            .cloned()
365            .ok_or_else(|| ExcelError::from(ExcelErrorKind::Name))
366    }
367}
368
369impl TableResolver for TestWorkbook {
370    fn resolve_table_reference(&self, tref: &TableReference) -> Result<Box<dyn Table>, ExcelError> {
371        self.tables
372            .get(&tref.name)
373            .map(|table_box| table_box.as_ref().clone_box())
374            .ok_or_else(|| ExcelError::from(ExcelErrorKind::NImpl))
375    }
376}
377
378impl SourceResolver for TestWorkbook {}
379
380impl FunctionProvider for TestWorkbook {
381    fn get_function(&self, ns: &str, name: &str) -> Option<Arc<dyn Function>> {
382        let nns = ns.to_uppercase();
383        let nname = name.to_uppercase();
384        // direct hit
385        if let Some(f) = self.fns.get(&(nns.clone(), nname.clone())) {
386            return Some(f.clone());
387        }
388        // alias in workbook scope
389        if let Some((t_ns, t_name)) = self.aliases.get(&(nns.clone(), nname.clone()))
390            && let Some(f) = self.fns.get(&(t_ns.clone(), t_name.clone()))
391        {
392            return Some(f.clone());
393        }
394        // fall back to global registry (case-insensitive with aliases)
395        crate::function_registry::get(&nns, &nname)
396    }
397}
398
399/* blanket */
400impl Resolver for TestWorkbook {}
401
402/* ─────────────────────── A1 parser ───────────────────────── */
403fn parse_a1(a1: &str) -> Option<(u32, u32)> {
404    parse_a1_1based(a1).ok().map(|(row, col, _, _)| (col, row))
405}
formualizer_eval/test_workbook.rs

formualizer_eval/
test_workbook.rs
