rtf-parser 0.1.3

A Rust RTF parser & lexer library designed for speed and memory efficiency.
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

# rtf-parser
A Rust RTF parser & lexer library designed for speed and memory efficiency.

The library is split into 2 main components:
1. The lexer
2. The parser

The lexer scan the document and return a `Vec<Token>` which represent the RTF file in a code-understandable manner.
To use it : 
```rust
use rtf_parser::{Lexer, Parser, Token};

let tokens: Vec<Token> = Lexer::scan("<rtf>");
```

These tokens can then be passed to the parser to transcript it to a real document : `RtfDocument`.
```rust
let parser = Parser::new(tokens);
let doc: RtfDocument = parser.parse();
```

An `RtfDocument` is composed with : 
- the **header**, containing among others the font table and the encoding.
- the **body**, which is a `Vec<StyledBlock>`

A `StyledBlock` contains all the information about the formatting of a specific block of text.  
It contains a `Painter` and the text (`&str`).
The `Painter` is defined below, and the rendering implementation depends on the user. For now, it only supports font, bold, italic and underline.
```rust
struct Painter {
    font_ref: FontRef,
    font_size: u16,
    bold: bool,
    italic: bool,
    underline: bool,
}
```

The parser could also return the text without any formatting information, with the `to_text()` method.

```rust
let rtf = r#"{\rtf1\ansi{\fonttbl\f0\fswiss Helvetica;}\f0\pard Voici du texte en {\b gras}.\par}"#;
let tokens = Lexer::scan(rtf);
let text = Parser::new(tokens).to_text();
assert_eq!(text, "Voici du texte en gras.");
```

## Examples 
A complete example of rtf parsing is presented below : 
```rust
use rtf_parser::{Lexer, Parser};

let rtf_text = r#"{ \rtf1\ansi{\fonttbl\f0\fswiss Helvetica;}\f0\pard Voici du texte en {\b gras}.\par }"#;
let tokens = Lexer::scan(rtf_text);
let doc = Parser::new(tokens).parse();

assert_eq!(
    doc.header,
    RtfHeader {
        character_set: Ansi,
        font_table: FontTable::from([
            (0, Font { name: "Helvetica", character_set: 0, font_family: Swiss })
        ])
    }
);
assert_eq!(
    doc.body,
    [
        StyleBlock {
            painter: Painter { font_ref: 0, font_size: 0, bold: false, italic: false, underline: false },
            text: "Voici du texte en ",
        },
        StyleBlock {
            painter: Painter { font_ref: 0, font_size: 0, bold: true, italic: false, underline: false },
            text: "gras",
        },
        StyleBlock {
            painter: Painter { font_ref: 0, font_size: 0, bold: false, italic: false, underline: false },
            text: ".",
        },
    ]
);
```