fixedlength-format-parser 0.1.1

Build parsers for files with fixed length, record-like fields.
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

# Fixed-length Format Parser

Write parsers for fixed-length formatted flat files quickly.

## Goal

This project provides a macro to quickly build a parser for formats where there exists records which begin with an identifier, then continue with a format of fixed length.

## Example

Consider the following file:

```text
AA20231201
PNDarth     Vader               123 Death Star Way            AB12 3CD
ZZ001
```

### Schema

This could be seen as a file with the format specified below:

Record types:

- Header ("AA")
- Person ("PN")
- Trailer ("ZZ")

> **Note:** Record types can be represented by any number of characters, but must always be present at the start of the record, and must always be the same length as each other.

**Header**:

Field | Value | Length | Description
------|-------|--------|------------
Type | "AA" | 2 | The header type
Date | YYYYMMDD | 8 | The date the file was produced.

**Person**:

Field | Value | Length | Description
------|-------|--------|------------
Type | "PN" | 2 | The person type
Forename | String | 10 | The forename of the person
Surname | String | 20 | The surname of the person
Address line | String | 30 | The address line
Postcode | String | 8 | The postcode in UK format

**Trailer**:

Field | Value | Length | Description
------|-------|--------|------------
Type | "ZZ" | 2 | The trailer type
Number of records | Number | 3 | The number of records in the file.

### Example Parser

```rust
use fixedlength_format_parser::FixedLengthFormatParser;

#[derive(FixedLengthFormatParser)]
pub enum PersonRecord {
    #[record_type = "AA"]
    Header {
        #[field_starts = 2]
        #[field_length = 8]
        // You could also specify the end instead of the length. End is exclusive.
        // #[field_ends = 10]
        date: String,
    },

    #[record_type = "PN"]
    Person {
        #[field_starts = 2]
        #[field_length = 10]
        forename: String,

        // `field_starts` is optional. If unspecified, it starts at 0 then increments by the length for each field.
        #[field_length = 20]
        surname: String,

        #[field_length = 30]
        address_line: String,

        #[field_length = 8]
        postcode: String,
    },

    #[record_type = "ZZ"]
    Trailer {
        // Any type is allowed, as long as it implements [`std::str::FromStr`].
        #[field_starts = 2]
        #[field_length = 3]
        num_records: usize,
    },
}

// You can now invoke the parser for each record:
fn parse_record(record: &str) -> PersonRecord {
    record.parse::<PersonRecord>().expect("the record should be valid")
}
```