jsonxf 1.0.2

A fast JSON pretty-printer and minimizer.
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

# Jsonxf

A JSON transformer, written in Rust.

Provides fast pretty-printing and minimizing of JSON-encoded strings
and streams, at the command line or within Rust programs.

Crate docs: https://docs.rs/jsonxf/


## Installation

    cargo install jsonxf


## Command-line Examples

Pretty-print a string to the terminal, using two spaces to indent:

    jsonxf -s '{"a": {"b": 2, "c": false}}'

Pretty-print and read a JSON file, using a tab character to indent:

    jsonxf -t $'\t' <foo.json | less

Minimize a file and gzip it:

    jsonxf -m <foo.json | gzip -c >foo-min.json.gz

Run `jsonxf -h` to see all configuration options.


## Rust Example

In your `Cargo.toml`:

```
[dependencies]
jsonxf = "1.0"
```

In your code:

```rust
extern crate jsonxf;
let ugly_json = "{\"hello\":\"world\"}";
let pretty_json = jsonxf::pretty_print(ugly_json).unwrap();
assert_eq!(pretty_json, "{\n  \"hello\": \"world\"\n}\n");
```


## Performance

Here are some benchmarks comparing Jsonxf 0.9's performance to
several of its counterparts:
  * [jq](https://stedolan.github.io/jq/), the extremely flexible JSON
    processor.
  * [jsonpp](https://github.com/jmhodges/jsonpp), a JSON pretty-printer
    written in Go.
  * [serdexf](benchmark/serdexf), a trivial example using the
    [serde_json](https://serde.rs/json.html) and
    [serde-transcode](https://serde.rs/transcode.html) libraries.
    This implementation is not complete and is included for library
    comparison only.
  * `cat` is thrown in as well, for scale.

Test platform: MBP (early 2013), macOS 10.13.2, 3GHz i7, 8GB RAM.

See [benchmark.rb](benchmark/benchmark.rb) for testing procedure.

Pretty-print test, 600MB minimized input (1M objects):

| command   | time (s) | relative time | notes |
|-----------|---------:|--------------:|-------|
| `cat`     |     2.26 |          0.3x | `cat` is a bad pretty-printer |
| `jsonxf`  |     7.76 |            1x | |
| `serdexf` |     9.33 |          1.2x | no newlines between objects 🙁 |
| `jsonpp`  |     25.0 |          3.2x | |
| `jq -M .` |     67.0 |          8.6x | |

Minimize test, 850MB pretty-printed input (1M objects):

| command      | time (s) | relative time | notes |
|--------------|---------:|--------------:|-------|
| `cat`        |     1.45 |          0.2x | `cat` is a bad minimizer |
| `jsonxf -m`  |     6.78 |            1x | |
| `serdexf -m` |     7.30 |          1.1x | |
| `jsonpp`     |        - |             - | minimizing is not supported 😭 |
| `jq -cM .`   |     78.0 |           12x | |


## Authorship and License

Copyright 2017-2020, Pete Gamache.

Jsonxf is released under the MIT License.