csv-line 0.3.0

Fast deserialization of a single csv line
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

#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![doc = include_str!("../README.md")]

use csv::StringRecord;
use parse::CsvRow;
use serde::de::DeserializeOwned;

mod parse;

/// A parser for a single line of CSV data.
pub struct CSVLine {
    separator: char,
}

impl CSVLine {
    /// Creates a new parser with the default separator (',').
    pub fn new() -> Self {
        Default::default()
    }

    /// Sets the separator character for the parser.
    pub fn with_separator(mut self, separator: char) -> Self {
        self.separator = separator;
        self
    }

    /// Deserializes a string into a custom type.
    pub fn decode_str<T: DeserializeOwned>(&self, s: &str) -> Result<T, csv::Error> {
        let record = StringRecord::from_iter(CsvRow::new(s, self.separator));
        record.deserialize(None)
    }
}

impl Default for CSVLine {
    fn default() -> Self {
        Self { separator: ',' }
    }
}

/// Deserializes a string into a custom type.
pub fn from_str<T: DeserializeOwned>(s: &str) -> Result<T, csv::Error> {
    CSVLine::new().decode_str(s)
}

/// Deserializes a string with a custom separator.
///
/// # Arguments
///
/// * `s` - The string slice to deserialize.
/// * `sep` - The separator character.
///
/// # Example
///
/// ```
/// #[derive(Debug, PartialEq, serde::Deserialize)]
/// struct Bar(Vec<u32>);
///
/// assert_eq!(csv_line::from_str_sep::<Bar>("31 42 28 97 0", ' ').unwrap(), Bar(vec![31,42,28,97,0]));
/// ```
pub fn from_str_sep<T: DeserializeOwned>(s: &str, sep: char) -> Result<T, csv::Error> {
    CSVLine::new().with_separator(sep).decode_str(s)
}

#[cfg(test)]
mod tests {
    use serde::Deserialize;

    use super::*;

    #[test]
    fn basic() {
        #[derive(Debug, PartialEq, Deserialize)]
        struct Foo(String);
        assert_eq!(from_str::<Foo>("foo").unwrap(), Foo("foo".into()));
        assert_eq!(from_str_sep::<Foo>("foo", ' ').unwrap(), Foo("foo".into()));
    }

    #[test]
    fn empty() {
        #[derive(Debug, PartialEq, Deserialize)]
        struct Foo(Option<String>);
        assert_eq!(from_str::<Foo>("").unwrap(), Foo(None));
        assert_eq!(from_str_sep::<Foo>("", ' ').unwrap(), Foo(None));
    }

    #[test]
    fn types() {
        #[derive(Debug, PartialEq, Deserialize)]
        struct Foo {
            text: String,
            maybe_text: Option<String>,
            num: i32,
            flag: bool,
        }
        assert_eq!(
            from_str::<Foo>(r#""foo,bar",,1,true"#).unwrap(),
            Foo {
                text: "foo,bar".into(),
                maybe_text: None,
                num: 1,
                flag: true
            }
        );
        assert_eq!(
            from_str_sep::<Foo>(r#""foo bar"  1 true"#, ' ').unwrap(),
            Foo {
                text: "foo bar".into(),
                maybe_text: None,
                num: 1,
                flag: true
            }
        );
    }

    #[test]
    fn tsv() {
        #[derive(Debug, PartialEq, Deserialize)]
        struct Foo(String, String);
        assert_eq!(
            CSVLine::new()
                .with_separator('\t')
                .decode_str::<Foo>("foo\tbar")
                .unwrap(),
            Foo("foo".into(), "bar".into())
        );
    }
}