formualizer-workbook 0.5.4

Ergonomic workbook API over the Formualizer engine (sheets, loaders, staging, undo/redo)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#[cfg(feature = "json")]
mod json_stream {
    use formualizer_common::RangeAddress;
    use formualizer_eval::engine::ingest::EngineLoadStream;
    use formualizer_eval::engine::named_range::NamedDefinition;
    use formualizer_eval::engine::{Engine, EvalConfig};
    use formualizer_workbook::traits::NamedRangeScope;
    use formualizer_workbook::{CellData, JsonAdapter, NamedRange, SpreadsheetWriter};

    fn create_test_engine() -> Engine<formualizer_eval::test_workbook::TestWorkbook> {
        let ctx = formualizer_eval::test_workbook::TestWorkbook::new();
        Engine::new(ctx, EvalConfig::default())
    }

    #[test]
    fn json_stream_registers_named_ranges() {
        let mut adapter = JsonAdapter::new();
        adapter.create_sheet("Sheet1").unwrap();
        adapter.create_sheet("Sheet2").unwrap();
        adapter
            .write_cell("Sheet2", 1, 1, CellData::from_value(0.0))
            .unwrap();

        adapter.set_named_ranges(
            "Sheet1",
            vec![
                NamedRange {
                    name: "GlobalName".into(),
                    scope: NamedRangeScope::Workbook,
                    address: RangeAddress::new("Sheet1", 1, 1, 1, 1).unwrap(),
                },
                NamedRange {
                    name: "LocalName".into(),
                    scope: NamedRangeScope::Sheet,
                    address: RangeAddress::new("Sheet1", 2, 1, 2, 2).unwrap(),
                },
            ],
        );

        let mut engine = create_test_engine();
        adapter.stream_into_engine(&mut engine).unwrap();

        let sheet_id = engine.sheet_id("Sheet1").expect("sheet present");
        let global = engine
            .resolve_name_entry("GlobalName", sheet_id)
            .map(|nr| &nr.definition)
            .expect("global name registered");

        match global {
            NamedDefinition::Cell(cell) => {
                assert_eq!(engine.sheet_name(cell.sheet_id), "Sheet1");
                assert_eq!(format!("{}", cell.coord), "$A$1");
            }
            other => panic!("expected cell definition, got {other:?}"),
        }

        let local = engine
            .resolve_name_entry("LocalName", sheet_id)
            .map(|nr| &nr.definition)
            .expect("local name registered");

        match local {
            NamedDefinition::Range(range) => {
                assert_eq!(engine.sheet_name(range.start.sheet_id), "Sheet1");
                assert_eq!(format!("{}", range.start.coord), "$A$2");
                assert_eq!(format!("{}", range.end.coord), "$B$2");
            }
            other => panic!("expected range definition, got {other:?}"),
        }
    }
}