ppbert 0.7.0

Simple pretty printer for Erlang's External Term Format
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
138
139
140
141
142
143

# Table of contents

- [ppbert](#ppbert)
- [bert-convert](#bert-convert)

# ppbert

A command-line utility to pretty print structures encoded using
Erlang's [External Term Format](http://erlang.org/doc/apps/erts/erl_ext_dist.html).
The input is read from *stdin* or a file and written to *stdout*,
making ppbert a good candidate for shell pipelines.

At the moment, ppbert supports the following subset of the External
Term Format:

- Small integers (tag: 97);
- Integers (tag: 98);
- Floating-point numbers (tags: 70, 99);
- Big integers (tags: 110, 111);
- Latin-1 atoms (tags: 100, 115);
- UTF-8 atoms (tags: 118, 119);
- Strings (tag: 107);
- Binaries (tag: 109);
- Tuples (tags: 104, 105);
- Lists (tags: 106, 108);
- Maps (tag: 116).


## Usage

```
$ ppbert -h
ppbert 0.6.0-rc1
Vincent Foley
Pretty print structure encoded in Erlang's External Term Format

USAGE:
    ppbert [FLAGS] [OPTIONS] [FILES]...

FLAGS:
    -2, --bert2                  Parses .bert2 files
    -d, --disk-log               Parses disk_log files
    -h, --help                   Prints help information
    -j, --json                   Outputs in JSON
    -p, --parse                  Parses the input, doesn't pretty print it
        --transform-proplists    Transforms proplists into JSON objects (only valid with --json)
    -V, --version                Prints version information
    -v, --verbose                Enables verbose mode

OPTIONS:
    -i, --indent-width <num>          Indents with <num> spaces
    -m, --max-terms-per-line <num>    Prints at most <num> basic terms per line

ARGS:
    <FILES>...


$ ppbert mini_dict.bert
[
  {host, "localhost"},
  {port, 80},
  {
    headers,
    [
      {
        <<"X-Real-Ip">>,
        {127, 0, 0, 1}
      },
      {<<"Keep-alive">>, true}
    ]
  }
]

$ printf "\x83\x77\x04atom" | ppbert
atom
```

## Performance

Ppbert is written in Rust and offers an appreciable performance gain
over using Erlang's `erlang:binary_to_term/1` and `io:format/2`.

```sh
$ cat erl_ppbert
#!/usr/bin/env escript

main(Args) ->
    lists:foreach(fun (Filename) ->
        {ok, Binary} = file:read_file(Filename),
        io:format("~p~n", [binary_to_term(Binary)])
    end, Args).

$ du large.bert
96M     large.bert

$ time ./erl_ppbert large.bert >/dev/null

real	0m43.017s
user	0m38.846s
sys 	0m4.345s

$ time ppbert large.bert >/dev/null

real	0m1.802s
user	0m1.251s
sys     0m0.549s
```

# bert-convert

A command-line utility to convert a bert file encoded in
[bertconf's](https://github.com/ferd/bertconf) DB format to
[rig's](https://github.com/lpgauth/rig) format.

## Usage

```
$ bert-convert -h
bert-convert 0.6.0-rc1
Vincent Foley
Convert bertconf .bert files to rig .bert2 files

USAGE:
    bert-convert [FLAGS] [OPTIONS] [FILES]...

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information
    -v, --verbose    Enables verbose mode

OPTIONS:
    -d, --output-dir <DIR>    Selects the output directory [default: .]

ARGS:
    <FILES>...


$ bert-convert -v -d /tmp/bert2 large.bert
bert-convert: large.bert: Parse time: 0.556925379s; Dump time: 0.580329024s

$ ls /tmp/bert2
large.bert2
```