board_game_parser 0.1.0

A Rust-based parser for board game data, designed for efficient data extraction and transformation.
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


# Board Game Parser


## Overview


The **Board Game Parser** is a Rust-based utility designed to parse structured information about board games and convert it into a serialized JSON format. This tool processes text files containing data about board games and extracts details such as the game's name, author, age suitability, playtime, player count, and price.

## Features


- Parses text files with structured board game data.
- Outputs data as a JSON file.
- Supports flexible input with various whitespace formatting.

## Parsing Details


### Input Format

The parser expects an input file with the following structure:
```
Name: <game name>
Author: <author name>
Age: <minimum age>
Time: <minimum time>-<maximum time>
Players: <minimum players>-<maximum players>
Price: <price> <currency>
```

- **`Name:`** The name of the board game.
- **`Author:`** The creator or publisher of the game.
- **`Age:`** Minimum age requirement for the game.
- **`Time:`** Expected playtime, with optional range (e.g., `30-60` minutes).
- **`Players:`** Minimum and maximum player count.
- **`Price:`** Cost of the game, with optional currency (`UAH`, `USD`, `EUR`).

Example:
```
Name: Chess
Author: Unknown
Age: 6
Time: 10-60
Players: 2
Price: 20 USD
```

### Parsing Process

1. **Grammar Definition**: 
   The grammar is defined in `grammar.pest` using the [Pest parser](https://pest.rs/). It uses rules for:
   - Capturing sections such as `Name`, `Author`, `Age`, etc.
   - Handling optional whitespace and ranges.

2. **Data Extraction**: 
   The parser tokenizes input based on these rules and extracts relevant fields. Each game entry is represented as a `Pair` object in Pest, which is then converted to a `Game` struct using the `from_pair` method.

3. **Serialization**: 
   The extracted data is serialized into JSON format using the [Serde](https://serde.rs/) library.

### Output Format

The resulting JSON file contains an array of board games, each represented as an object with the following structure:
```json
[
  {
    "name": "Chess",
    "author": "Unknown",
    "age": 6,
    "min_time": 10,
    "max_time": 60,
    "min_players": 2,
    "max_players": null,
    "price": 20.0
  }
]
```

## Usage


### Commands

1. Parse a file:
   ```bash
   cargo run -- <input_file> <output_file>
   ```
   Example:
   ```bash
   cargo run input.txt output.json

   ```

2. Display credits:
   ```bash
   cargo run -- --credits

   ```

3. Display help:
   ```bash
   cargo run -- --help

   ```

### Examples

- Input file:
  ```
  Name: Catan
  Author: Klaus Teuber
  Age: 10
  Time: 60-120
  Players: 3-4
  Price: 30 USD
  ```

- Command:
  ```bash
  cargo run input.txt output.json

  ```

- Output file (`output.json`):
  ```json
  [
    {
      "name": "Catan",
      "author": "Klaus Teuber",
      "age": 10,
      "min_time": 60,
      "max_time": 120,
      "min_players": 3,
      "max_players": 4,
      "price": 30.0
    }
  ]
  ```

## Technical Details

This project leverages:
- **Pest**: For defining the parsing grammar and tokenizing input.
- **Serde**: For serialization and deserialization of parsed data.
- **Anyhow**: For improved error handling.

## Author

- Maksym Karpinskyi (karpinskyimaksym@gmail.com)

## License

MIT License