jsonparser 0.2.1

A Rust crate for efficient parsing and validation of JSON data into strongly typed Rust data structures, enabling data integrity checks.
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

# JSON Parser


This Rust crate provides a robust and efficient solution for parsing JSON data into Rust's strongly-typed data structures. It's designed to simplify the process of converting JSON text into Rust types and allows you to validate your JSON data with schema-based validation, making it easier to work with JSON data in Rust applications.

## Features


- **Strong Typing**: Leverages Rust's type system to ensure that JSON data is parsed into the correct Rust data structures.
- **Error Handling**: Provides comprehensive error handling to catch and manage parsing errors, making your application more robust.
- **Schema-Based Validation**: This ensures that the JSON data adheres to a predefined schema, reducing runtime errors, enhancing data integrity and allows you to transform JSON values before validation.

## Getting Started


To use this crate in your project, add it to your `Cargo.toml`:

```toml
[dependencies]
jsonparser = "0.2.1"
```

Then, import it in your Rust file:

```rust
use jsonparser::*;
```

## Basic Usage


### Parsing JSON to Rust


To parse a JSON string into a Rust `JSONValue`, use the `from` function provided by the crate:

```rust
use jsonparser::JSONParser;

let input = r#"
    {
        "name": "John Doe",
        "age": 30,
        "is_student": false
    }
"#;

match JSONParser::from(input) {
    Ok(json) => println!("{:#?}", json),
    Err(e) => eprintln!("Failed to parse JSON: {}", e),
}
```

### Accessing Data


Once parsed, access the data using the `.get()` method or the indexing syntax for both objects and arrays:

```rust
// Using `.get()` method
if let Some(name) = json.get("name").and_then(|v| v.as_str()) {
    println!("Name: {}", name);
}

// Using indexing syntax
let age = &json["age"];
if let Some(age) = age.as_f64() {
    println!("Age: {}", age);
}
```

### Serialization


To serialize a Rust data structure into a JSON string, use the `serialize` method:

```rust
use jsonparser::{JSONParser, JSONValue};

let json: JSONValue = JSONParser::from(r#"{ "name": "John Doe", "age": 30, "is_student": false }"#).unwrap();
let serialized = json.serialize();

assert_eq!(serialized, r#"{"name":"John Doe","age":30,"is_student":false}"#);
```

### Validation


To validate a JSONValue, use the `validate` method:

```rust
use jsonparser::{JSONParser, JSONValue, JSONSchema, StringType, NumberType, BooleanType};

let json: JSONValue = JSONParser::from(r#"{ "name": "John Doe", "age": 30, "is_student": false }"#).unwrap();
let schema = JSONSchema::new([
    ("name", StringType::new().min_length(3).trim().boxed()),
    ("age", NumberType::new().gt(18).lt(100).boxed()),
    ("is_student", BooleanType::new().falsy().boxed()),
]);

assert!(schema.validate(&json).is_ok());
```

## Contribution


Contributions are welcome! If you have suggestions for improvements or find any issues, please open an issue or submit a pull request on [GitHub](https://github.com/nethriis/json-parser).

## License


This project is licensed under the [Apache-2.0 license](https://github.com/nethriis/json-parser/blob/main/LICENSE).