positional 0.4.5

A library to author/parse positional files
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

// Force name clashes to make sure the macros generate code with fully qualified imports.

pub trait ToPositionalField {}
pub trait ToPositionalRow {}
pub trait FromPositionalRow {}

mod positional {}

#[derive(::positional::ToPositionalRow, ::positional::FromPositionalRow, PartialEq, Debug)]
struct Data {
    #[field(size = 5)]
    name: String,
    #[field(size = 5, filler = '-', align = "right")]
    age: i32,
    #[field(size = 20)]
    address: String,
}

impl Data {
    #[allow(dead_code)]
    fn from_positional_row(_: &str) -> Self {
        unreachable!()
    }

    #[allow(dead_code)]
    fn to_positional_row(&self) -> String {
        unreachable!()
    }
}

impl Data {
    pub fn new(name: impl ToString, age: i32, address: impl ToString) -> Self {
        Self {
            name: name.to_string(),
            age,
            address: address.to_string(),
        }
    }
}

#[derive(Debug, PartialEq, ::positional::FromPositionalRow, ::positional::ToPositionalRow)]
struct JohnData {
    #[field(size = 10)]
    name: String,
}

#[derive(Debug, PartialEq, ::positional::FromPositionalRow, ::positional::ToPositionalRow)]
struct PaulData {
    #[field(size = 10)]
    name: String,
}

#[derive(Debug, PartialEq, ::positional::FromPositionalRow, ::positional::ToPositionalRow)]
enum Beatles {
    #[matcher(&row[0..=3] == "john")]
    John(JohnData),
    #[matcher(&row[0..=3] == "paul")]
    Paul(PaulData),
}

impl JohnData {
    #[allow(dead_code)]
    fn from_positional_row(_: &str) -> Self {
        unreachable!()
    }

    #[allow(dead_code)]
    fn to_positional_row(&self) -> String {
        unreachable!()
    }
}

impl PaulData {
    #[allow(dead_code)]
    fn from_positional_row(_: &str) -> Self {
        unreachable!()
    }

    #[allow(dead_code)]
    fn to_positional_row(&self) -> String {
        unreachable!()
    }
}

impl Beatles {
    #[allow(dead_code)]
    fn from_positional_row(_: &str) -> Self {
        unreachable!()
    }

    #[allow(dead_code)]
    fn to_positional_row(&self) -> String {
        unreachable!()
    }
}

#[test]
fn struct_parse_no_name_clashes() {
    let row =
        ::positional::FromPositionalRow::from_positional_row("1    ---10the address is this ")
            .expect("error converting from positional row");
    assert_eq!(Data::new(1, 10, "the address is this"), row);
}

#[test]
fn struct_ser_de_no_name_clashes() {
    let data = Data::new(1, 100, "the address is this");
    let row = ::positional::ToPositionalRow::to_positional_row(&data);
    let original_data: Data = ::positional::FromPositionalRow::from_positional_row(&row)
        .expect("error converting from positional row");
    assert_eq!(original_data, data);
}

#[test]
fn enum_no_name_clashes() {
    // Parsing
    let john_data = Beatles::John(JohnData {
        name: "john".to_string(),
    });
    let paul_data = Beatles::Paul(PaulData {
        name: "paul".to_string(),
    });
    let row_john = "john      ";
    let row_paul = "paul      ";

    let row_wrong = "xxxx      ";

    assert_eq!(
        <Beatles as ::positional::FromPositionalRow>::from_positional_row(row_john).unwrap(),
        john_data
    );
    assert_eq!(
        <Beatles as ::positional::FromPositionalRow>::from_positional_row(row_paul).unwrap(),
        paul_data
    );
    assert!(<Beatles as ::positional::FromPositionalRow>::from_positional_row(row_wrong).is_err());

    // Serializing
    let writer = ::positional::Writer::new(vec![john_data, paul_data]);
    assert_eq!("john      \npaul      ", writer.to_string());
}