multiio 0.2.3

A unified I/O orchestration library for CLI/server applications
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
145
146

use std::io::Read;

use serde::{Serialize, de::DeserializeOwned};

use super::FormatError;

pub(crate) fn deserialize<T: DeserializeOwned>(bytes: &[u8]) -> Result<T, FormatError> {
    let mut rdr = csv::ReaderBuilder::new()
        .has_headers(true)
        .from_reader(bytes);

    let records: Vec<csv::StringRecord> = rdr
        .records()
        .collect::<Result<Vec<_>, _>>()
        .map_err(|e| FormatError::Serde(Box::new(e)))?;

    let headers = rdr.headers().map_err(|e| FormatError::Serde(Box::new(e)))?;
    let headers: Vec<&str> = headers.iter().collect();

    let json_records: Vec<serde_json::Value> = records
        .iter()
        .map(|record| {
            let mut obj = serde_json::Map::new();
            for (i, field) in record.iter().enumerate() {
                if let Some(header) = headers.get(i) {
                    let v_str = field.to_string();
                    // Try to infer numeric fields so that structs with integer
                    // fields can be deserialized naturally.
                    let value = if let Ok(n) = v_str.parse::<i64>() {
                        serde_json::Value::Number(serde_json::Number::from(n))
                    } else {
                        serde_json::Value::String(v_str)
                    };

                    obj.insert((*header).to_string(), value);
                }
            }
            serde_json::Value::Object(obj)
        })
        .collect();

    let json_value = serde_json::Value::Array(json_records);
    serde_json::from_value(json_value).map_err(|e| FormatError::Serde(Box::new(e)))
}

pub(crate) struct CsvRecordStream<R, T> {
    iter: csv::DeserializeRecordsIntoIter<R, T>,
}

impl<R, T> Iterator for CsvRecordStream<R, T>
where
    R: Read,
    T: DeserializeOwned,
{
    type Item = Result<T, FormatError>;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter
            .next()
            .map(|res| res.map_err(|e| FormatError::Serde(Box::new(e))))
    }
}

pub(crate) fn stream_deserialize<T, R>(reader: R) -> CsvRecordStream<R, T>
where
    T: DeserializeOwned,
    R: Read,
{
    let rdr = csv::ReaderBuilder::new()
        .has_headers(true)
        .from_reader(reader);
    CsvRecordStream {
        iter: rdr.into_deserialize(),
    }
}

pub(crate) fn serialize<T: Serialize>(value: &T) -> Result<Vec<u8>, FormatError> {
    let json_value = serde_json::to_value(value).map_err(|e| FormatError::Serde(Box::new(e)))?;

    let mut wtr = csv::Writer::from_writer(Vec::new());

    match json_value {
        serde_json::Value::Array(arr) => {
            if let Some(first) = arr.first() {
                if let serde_json::Value::Object(obj) = first {
                    let headers: Vec<&str> = obj.keys().map(|s| s.as_str()).collect();
                    wtr.write_record(&headers)
                        .map_err(|e| FormatError::Serde(Box::new(e)))?;
                } else {
                    // Top-level array must contain objects; otherwise we don't
                    // know how to build the header/records.
                    return Err(FormatError::Other(Box::new(std::io::Error::new(
                        std::io::ErrorKind::InvalidData,
                        "CSV format requires array of objects or single object",
                    ))));
                }
            }

            for item in arr {
                let obj = match item {
                    serde_json::Value::Object(obj) => obj,
                    _ => {
                        return Err(FormatError::Other(Box::new(std::io::Error::new(
                            std::io::ErrorKind::InvalidData,
                            "CSV format requires array of objects or single object",
                        ))));
                    }
                };

                let record: Vec<String> = obj
                    .values()
                    .map(|v| match v {
                        serde_json::Value::String(s) => s.clone(),
                        _ => v.to_string(),
                    })
                    .collect();
                wtr.write_record(&record)
                    .map_err(|e| FormatError::Serde(Box::new(e)))?;
            }
        }
        serde_json::Value::Object(obj) => {
            let headers: Vec<&str> = obj.keys().map(|s| s.as_str()).collect();
            wtr.write_record(&headers)
                .map_err(|e| FormatError::Serde(Box::new(e)))?;

            let record: Vec<String> = obj
                .values()
                .map(|v| match v {
                    serde_json::Value::String(s) => s.clone(),
                    _ => v.to_string(),
                })
                .collect();
            wtr.write_record(&record)
                .map_err(|e| FormatError::Serde(Box::new(e)))?;
        }
        _ => {
            return Err(FormatError::Other(Box::new(std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                "CSV format requires an array or object",
            ))));
        }
    }

    wtr.into_inner()
        .map_err(|e| FormatError::Other(Box::new(e)))
}