laminate 0.1.0

Progressive data shaping for Rust — type coercion, format detection, and fault-tolerant deserialization built on serde
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

/// guess_type() tests — detect what type an unknown string represents.
use laminate::detect::{guess_type, GuessedType};

#[test]
fn detect_integer() {
    let guesses = guess_type("42");
    assert_eq!(guesses[0].kind, GuessedType::Integer);
    assert!(guesses[0].confidence > 0.9);
}

#[test]
fn detect_float() {
    let guesses = guess_type("3.14");
    assert_eq!(guesses[0].kind, GuessedType::Float);
}

#[test]
fn detect_boolean() {
    let guesses = guess_type("true");
    assert_eq!(guesses[0].kind, GuessedType::Boolean);

    let guesses = guess_type("Yes");
    assert_eq!(guesses[0].kind, GuessedType::Boolean);
}

#[test]
fn detect_date() {
    let guesses = guess_type("2026-04-02");
    assert!(matches!(guesses[0].kind, GuessedType::Date(_)));
}

#[test]
fn detect_currency() {
    let guesses = guess_type("$12.99");
    assert_eq!(guesses[0].kind, GuessedType::Currency);
}

#[test]
fn detect_unit_value() {
    let guesses = guess_type("5.2 kg");
    assert!(matches!(guesses[0].kind, GuessedType::UnitValue(_)));
}

#[test]
fn detect_uuid() {
    let guesses = guess_type("550e8400-e29b-41d4-a716-446655440000");
    assert_eq!(guesses[0].kind, GuessedType::Uuid);
}

#[test]
fn detect_email() {
    let guesses = guess_type("alice@example.com");
    assert_eq!(guesses[0].kind, GuessedType::Email);
}

#[test]
fn detect_url() {
    let guesses = guess_type("https://example.com/path");
    assert_eq!(guesses[0].kind, GuessedType::Url);
}

#[test]
fn detect_ip_v4() {
    let guesses = guess_type("192.168.1.1");
    assert!(guesses.iter().any(|g| g.kind == GuessedType::IpAddress));
}

#[test]
fn detect_json_object() {
    let guesses = guess_type(r#"{"key": "value"}"#);
    assert_eq!(guesses[0].kind, GuessedType::Json);
}

#[test]
fn detect_null_sentinel() {
    let guesses = guess_type("N/A");
    assert_eq!(guesses[0].kind, GuessedType::NullSentinel);

    let guesses = guess_type("null");
    assert_eq!(guesses[0].kind, GuessedType::NullSentinel);
}

#[test]
fn detect_plain_string() {
    let guesses = guess_type("hello world");
    assert_eq!(guesses[0].kind, GuessedType::PlainString);
}

#[test]
fn multiple_guesses_sorted_by_confidence() {
    // "1" is both integer and boolean
    let guesses = guess_type("1");
    assert!(guesses.len() >= 2);
    assert!(guesses[0].confidence >= guesses[1].confidence);
}

#[test]
fn ambiguous_date() {
    let guesses = guess_type("01/02/2026");
    let date_guess = guesses
        .iter()
        .find(|g| matches!(g.kind, GuessedType::Date(_)));
    assert!(date_guess.is_some());
    // Ambiguous dates should have lower confidence
    assert!(date_guess.unwrap().confidence < 0.8);
}

#[test]
fn iter118_empty_string_is_null_sentinel() {
    // Empty string is the #1 most common null sentinel in CSV/DB exports.
    // pandas treats "" as NaN by default. guess_type("") should return
    // NullSentinel, not PlainString — the previous early-return was wrong.
    let guesses = guess_type("");
    assert_eq!(
        guesses[0].kind,
        GuessedType::NullSentinel,
        "empty string should be NullSentinel"
    );
    assert!(guesses[0].confidence >= 0.9, "confidence should be high");

    // Whitespace-only string: after trim it's also empty → NullSentinel
    let guesses_ws = guess_type("   ");
    assert_eq!(
        guesses_ws[0].kind,
        GuessedType::NullSentinel,
        "whitespace-only should be NullSentinel"
    );

    // Tab-only string
    let guesses_tab = guess_type("\t\t");
    assert_eq!(
        guesses_tab[0].kind,
        GuessedType::NullSentinel,
        "tab-only should be NullSentinel"
    );

    // Non-empty strings should NOT be affected by this change
    let guesses_hello = guess_type("hello");
    assert_eq!(
        guesses_hello[0].kind,
        GuessedType::PlainString,
        "normal string still PlainString"
    );
}