sheeter-engine 1.2.0

Convert, inspect, and transform data files across ten formats with streaming where it matters and auto-detection where it can.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use sheeter_engine::{detect_content, detect_extension, Format};
use std::path::Path;

#[test]
fn detects_json_array() {
    assert_eq!(detect_content(b"[1,2,3]").unwrap(), Format::Json);
}

#[test]
fn detects_json_object() {
    assert_eq!(detect_content(b"{\"a\":1}").unwrap(), Format::Json);
}

#[test]
fn detects_ndjson() {
    assert_eq!(
        detect_content(b"{\"a\":1}\n{\"a\":2}\n").unwrap(),
        Format::Ndjson
    );
}

#[test]
fn detects_xml() {
    assert_eq!(detect_content(b"<r><a>1</a></r>").unwrap(), Format::Xml);
}

#[test]
fn detects_csv() {
    assert_eq!(
        detect_content(b"name,age\nAlice,30\n").unwrap(),
        Format::Csv
    );
}

#[test]
fn detects_tsv() {
    assert_eq!(
        detect_content(b"name\tage\nAlice\t30\n").unwrap(),
        Format::Tsv
    );
}

#[test]
fn detects_toml() {
    assert_eq!(
        detect_content(b"name = \"Alice\"\nage = 30\n").unwrap(),
        Format::Toml
    );
}

#[test]
fn detects_yaml() {
    assert_eq!(
        detect_content(b"- name: Alice\n  age: 30\n").unwrap(),
        Format::Yaml
    );
}

#[test]
fn bom_stripped_before_detection() {
    let with_bom = b"\xef\xbb\xbfname,age\nAlice,30\n";
    assert_eq!(detect_content(with_bom).unwrap(), Format::Csv);
}

#[test]
fn empty_input_errors() {
    assert!(detect_content(b"").is_err());
}

#[test]
fn extension_csv() {
    assert_eq!(detect_extension(Path::new("data.csv")), Some(Format::Csv));
}

#[test]
fn extension_jsonl_maps_to_ndjson() {
    assert_eq!(
        detect_extension(Path::new("events.jsonl")),
        Some(Format::Ndjson)
    );
}

#[test]
fn extension_unknown_returns_none() {
    assert_eq!(detect_extension(Path::new("data.xyz")), None);
}

#[test]
fn detects_ods_by_content() {
    use sheeter_engine::CanonicalValue;
    let hub = CanonicalValue::from_csv("a\n1\n").unwrap();
    let ods = sheeter_engine::to_ods_workbook(&[("Sheet1".to_string(), hub)]).unwrap();
    assert_eq!(detect_content(&ods).unwrap(), Format::Ods);
}

#[test]
fn detects_xlsx_by_content() {
    use sheeter_engine::CanonicalValue;
    let hub = CanonicalValue::from_csv("a\n1\n").unwrap();
    let bytes = CanonicalValue::to_xlsx_workbook(&[("Sheet1".to_string(), hub.clone())]).unwrap();
    assert_eq!(detect_content(&bytes).unwrap(), Format::Xlsx);
}

#[test]
fn rejects_random_zip() {
    // PK\x03\x04 magic followed by garbage
    let bogus = b"PK\x03\x04this is not a real zip";
    assert!(detect_content(bogus).is_err());
}

#[test]
fn rejects_odt_mimetype() {
    // Real ODT would fail here because we can't fabricate a valid ODT
    // without the full mimetype ZIP. Test the error path indirectly:
    // a valid ZIP with an ODT mimetype returns an error, not Ods.
    // Covered by unit test in detect.rs once we have an ODT fixture.
    // For now, just verify non-ZIP text still detects correctly.
    assert_eq!(detect_content(b"a,b\n1,2\n").unwrap(), Format::Csv);
}