jupiter 4.1.0

Jupiter is a library for providing high-throughput ultra low latency services via the RESP protocol as defined by Redis.
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

//! Permits to load CSV data into a [Doc](crate::ig::docs::Doc).
//!
//! Wraps the given CSV data and returns it as **Doc**. The first line is used as header line
//! which defined the field names. All subsequent lines are imported as entries.
//!
//! # Examples
//!
//! CSV into a doc:
//! ```
//! # use csv::ReaderBuilder;
//! # use jupiter::ig::csv::csv_to_doc;
//! let input = "F1;F2;F3\r\nA;X;1\r\nB;Y;2";
//! let reader = ReaderBuilder::new()
//!             .delimiter(b';')
//!             .has_headers(false)
//!             .from_reader(input.as_bytes());
//! let doc = csv_to_doc(reader).unwrap();
//!
//! assert_eq!(doc.root().at(0).query("F1").as_str().unwrap(), "A");
//! assert_eq!(doc.root().at(0).query("F2").as_str().unwrap(), "X");
//! assert_eq!(doc.root().at(0).query("F3").as_str().unwrap(), "1");
//! assert_eq!(doc.root().at(1).query("F1").as_str().unwrap(), "B");
//! assert_eq!(doc.root().at(1).query("F2").as_str().unwrap(), "Y");
//! assert_eq!(doc.root().at(1).query("F3").as_str().unwrap(), "2");
//! ```
use crate::ig::builder::DocBuilder;
use crate::ig::docs::Doc;
use crate::ig::symbols::Symbol;
use csv::{Reader, StringRecordsIter};

/// Transforms the given CSV data into a doc which is a list of objects.
pub fn csv_to_doc<R>(mut reader: Reader<R>) -> anyhow::Result<Doc>
where
    R: std::io::Read,
{
    let doc_builder = DocBuilder::new();
    let mut list_builder = doc_builder.list();

    let mut record_iter = reader.records();
    let headers = read_headers(&mut record_iter, &doc_builder)?;
    let mut line = 2;
    for record in reader.records() {
        match record {
            Ok(record) => {
                let mut obj_builder = doc_builder.obj();
                for (header, value) in headers.iter().zip(record.iter()) {
                    obj_builder.insert_string(*header, value);
                }

                list_builder.append_object(obj_builder);
            }
            Err(error) => {
                return Err(anyhow::anyhow!(
                    "Failed to parse CSV in line {}: {}",
                    line,
                    error
                ));
            }
        }
        line += 1;
    }

    Ok(doc_builder.build_list(list_builder))
}

fn read_headers<R>(
    record_iter: &mut StringRecordsIter<R>,
    doc_builder: &DocBuilder,
) -> anyhow::Result<Vec<Symbol>>
where
    R: std::io::Read,
{
    if let Some(Ok(headers)) = record_iter.next() {
        let mut resolved_headers = Vec::new();

        for header in headers.iter() {
            resolved_headers.push(doc_builder.resolve(header)?);
        }

        Ok(resolved_headers)
    } else {
        Err(anyhow::anyhow!("Failed to read headers from CSV!"))
    }
}