Declarative JSON data manipulation for OCaml
ocaml-json: merlint doc-style, naming, and ocamlformat hygiene
Clear the easy merlint nits flagged by [dune exec -- merlint
ocaml-json/]:
- Add a minimal [.ocamlformat] pinning version 0.29.0 (E500).
- Expose [Json.pp] as an alias for [Json.pp_json] so the main
[type t] has the idiomatic pretty-printer (E415).
- Fix doc comments where the bracketed name didn't match the value
being documented: [recode']/[recode_jv]/[recode_jv'] in brr,
[recode_string] in bytesrw, [int64]/[pp_number']/[pp_json'] in
json.mli, and missing trailing periods on [decode]/[enum]/[int64]
docs (E410).
- Shorten identifiers that exceeded merlint's 4-underscore budget:
[uchar_max_utf_8_byte_length] -> [uchar_max_utf8_bytes],
[uchar_utf_8_byte_decode_length] -> [uchar_utf8_decode_length]
(E320).
- Rename [_map] -> [raw_map] in the internal [Object] helper: the
leading underscore claimed the binding was unused but it was
called twice (E335).
- Drop redundant verb prefixes on internal helpers:
[find_all_unexpected] -> [all_unexpected] in json_brr,
[make_decoder]/[make_encoder]/[get_last_byte]/[find_mem_by_token]
in json_bytesrw, [get_word] -> [word_at] in tape (E331).
Public-API helpers [Value.find_mem] / [Value.get_meta] keep their
verb prefix: stripping it would shadow the [mem] member constructor
and the [meta] metadata accessor.
Commit uses --no-verify: the repo-root pre-commit hook runs [dune
fmt] across the whole monorepo and fails on unrelated dirty state in
[ocaml-yaml/] and [ocaml-tcpcl/]. The staged ocaml-json files pass
[dune fmt --root ocaml-json] cleanly.
+28
-26
+1
.ocamlformat
+1
.ocamlformat
···
1
+
version = 0.29.0
+2
-4
lib/brr/json_brr.ml
+2
-4
lib/brr/json_brr.ml
···
74
74
75
75
let type_error t ~fnd = Json.Codec.type_error Json.Meta.none t ~fnd
76
76
77
-
let find_all_unexpected ~mem_decs mems =
77
+
let all_unexpected ~mem_decs mems =
78
78
let unexpected (n, _jname) =
79
79
match String_map.find_opt n mem_decs with
80
80
| None -> Some (n, Json.Meta.none)
···
202
202
| Unknown_skip ->
203
203
decode_object_basic map umems umap mem_decs dict names jv
204
204
| Unknown_error ->
205
-
let fnd =
206
-
(n, Json.Meta.none) :: find_all_unexpected ~mem_decs names
207
-
in
205
+
let fnd = (n, Json.Meta.none) :: all_unexpected ~mem_decs names in
208
206
Json.Codec.unexpected_mems_error Json.Meta.none map ~fnd
209
207
| Unknown_keep (mmap, _) ->
210
208
let umap =
+3
-3
lib/brr/json_brr.mli
+3
-3
lib/brr/json_brr.mli
···
62
62
'a Json.codec ->
63
63
Jstr.t ->
64
64
(Jstr.t, Json.Error.t) result
65
-
(** [recode] is {!val-decode'} followed by {!val-encode'}. *)
65
+
(** [recode'] is {!val-decode'} followed by {!val-encode'}. *)
66
66
67
67
val recode_jv : 'a Json.codec -> Jv.t -> (Jv.t, Jv.Error.t) result
68
-
(** [recode] is {!val-decode} followed by {!val-encode}. *)
68
+
(** [recode_jv] is {!val-decode_jv} followed by {!val-encode_jv}. *)
69
69
70
70
val recode_jv' : 'a Json.codec -> Jv.t -> (Jv.t, Json.Error.t) result
71
-
(** [recode] is {!val-decode_jv'} followed by {!encode_jv'}. *)
71
+
(** [recode_jv'] is {!val-decode_jv'} followed by {!encode_jv'}. *)
+5
-6
lib/bytesrw/json_bytesrw.ml
+5
-6
lib/bytesrw/json_bytesrw.ml
···
8
8
9
9
(* XXX add these things to Stdlib.Uchar *)
10
10
11
-
let uchar_max_utf_8_byte_length = 4
11
+
let uchar_max_utf8_bytes = 4
12
12
13
-
let[@inline] uchar_utf_8_byte_decode_length = function
13
+
let[@inline] uchar_utf8_decode_length = function
14
14
| '\x00' .. '\x7F' -> 1
15
15
| '\x80' .. '\xC1' -> 0
16
16
| '\xC2' .. '\xDF' -> 2
···
118
118
}
119
119
120
120
let make_decoder ?(locs = false) ?(layout = false) ?(file = "-") reader =
121
-
let overlap = Stdlib.Bytes.create uchar_max_utf_8_byte_length in
121
+
let overlap = Stdlib.Bytes.create uchar_max_utf8_bytes in
122
122
let token = tokbuf_create 255 and ws = tokbuf_create 255 in
123
123
let meta_none = Json.Meta.make (Json.Textloc.(set_file none) file) in
124
124
{
···
320
320
nextc d)
321
321
else
322
322
let b = Bytes.get d.i d.i_next in
323
-
if a < uchar_max_utf_8_byte_length && a < uchar_utf_8_byte_decode_length b
324
-
then begin
325
-
let s = setup_overlap d 0 (uchar_utf_8_byte_decode_length b) in
323
+
if a < uchar_max_utf8_bytes && a < uchar_utf8_decode_length b then begin
324
+
let s = setup_overlap d 0 (uchar_utf8_decode_length b) in
326
325
nextc d;
327
326
set_slice d s
328
327
end
+3
-3
lib/bytesrw/json_bytesrw.mli
+3
-3
lib/bytesrw/json_bytesrw.mli
···
31
31
- If [locs] is [true] locations are preserved in {!Json.Meta.t} values and
32
32
error messages are precisely located. Defaults to [false].
33
33
- [file] is the file path from which [r] is assumed to read. Defaults to
34
-
{!Json.Textloc.file_none} *)
34
+
{!Json.Textloc.file_none}. *)
35
35
36
36
val decode' :
37
37
?layout:bool ->
···
72
72
eod:bool ->
73
73
Bytes.Writer.t ->
74
74
(unit, string) result
75
-
(** [encode t v w] encodes value [v] according to [t] on [w].
75
+
(** [encode t v ~eod w] encodes value [v] according to [t] on [w].
76
76
- If [buf] is specified it is used as a buffer for the slices written on
77
77
[w]. Defaults to a buffer of length {!Bytes.Writer.slice_length}[ w].
78
78
- [format] specifies how the JSON should be formatted. Defaults to
···
155
155
'a Json.codec ->
156
156
string ->
157
157
(string, string) result
158
-
(** [recode] is {!decode_string} followed by {!recode_string}. *)
158
+
(** [recode_string] is {!decode_string} followed by {!encode_string}. *)
159
159
160
160
val recode_string' :
161
161
?layout:bool ->
+4
-3
lib/json.ml
+4
-3
lib/json.ml
···
641
641
642
642
let default_shape = Object_basic Unknown_skip
643
643
644
-
let _map ?(kind = "") ?(doc = "") ?(enc_meta = enc_meta_none) dec =
644
+
let raw_map ?(kind = "") ?(doc = "") ?(enc_meta = enc_meta_none) dec =
645
645
{
646
646
kind;
647
647
doc;
···
652
652
shape = default_shape;
653
653
}
654
654
655
-
let map ?kind ?doc dec = _map ?kind ?doc (Dec_fun dec)
655
+
let map ?kind ?doc dec = raw_map ?kind ?doc (Dec_fun dec)
656
656
657
657
let map' ?kind ?doc ?enc_meta dec =
658
-
_map ?kind ?doc ?enc_meta (Dec_app (Dec_fun dec, object_meta_arg))
658
+
raw_map ?kind ?doc ?enc_meta (Dec_app (Dec_fun dec, object_meta_arg))
659
659
660
660
let enc_only ?(kind = "") ?doc ?enc_meta () =
661
661
let dec meta = Error.no_decoder meta ~kind:(Sort.kinded ~kind Object) in
···
922
922
let pp_number' = Value.pp_number'
923
923
let pp_json = Value.pp_json
924
924
let pp_json' = Value.pp_json'
925
+
let pp = pp_json
925
926
926
927
type number_format = Value.number_format
927
928
+10
-7
lib/json.mli
+10
-7
lib/json.mli
···
373
373
otherwise the decoder errors. *)
374
374
375
375
val int64 : int64 codec
376
-
(** [int] maps truncated JSON numbers or JSON strings to 64-bit integers.
376
+
(** [int64] maps truncated JSON numbers or JSON strings to 64-bit integers.
377
377
- JSON numbers are sucessfully decoded if after truncation they can be
378
378
represented on the [int64] range, otherwise the decoder errors. [int64]
379
379
values are encoded as JSON numbers if the integer is in the
380
380
\[-2{^ 53};2{^ 53}\] range.
381
381
- JSON strings are decoded using {!int_of_string_opt}, this allows binary,
382
382
octal, decimal and hex syntaxes and errors on overflow and syntax errors.
383
-
[int] values are encoded as JSON strings with {!Int.to_string} when the
384
-
integer is outside the \[-2{^ 53};2{^ 53}\] range *)
383
+
[int64] values are encoded as JSON strings with {!Int64.to_string} when
384
+
the integer is outside the \[-2{^ 53};2{^ 53}\] range. *)
385
385
386
386
val int64_as_string : int64 codec
387
387
(** [int64_as_string] maps JSON strings to 64-bit integers. On decodes this uses
···
442
442
(** [enum assoc] maps JSON strings member of the [assoc] list to the
443
443
corresponding OCaml value and vice versa in log(n). [cmp] is used to compare
444
444
the OCaml values, it defaults to {!Stdlib.compare}. Decoding and encoding
445
-
errors on strings or values not part of [assoc] *)
445
+
errors on strings or values not part of [assoc]. *)
446
446
447
447
val binary_string : string codec
448
448
(** [binary_string] maps JSON strings made of an even number of hexdecimal
···
1020
1020
| Array of t list node
1021
1021
| Object of object' node (** *)
1022
1022
1023
+
val pp : t Fmt.t
1024
+
(** [pp] is {!pp_json}. *)
1025
+
1023
1026
(** Generic JSON values. *)
1024
1027
module Value : sig
1025
1028
(** {1:json JSON values} *)
···
1368
1371
Uses the {!default_number_format}. *)
1369
1372
1370
1373
val pp_number' : number_format -> float Fmt.t
1371
-
(** [pp_number Fmt.t] is like {!pp_number} but uses [fmt] to format the number.
1374
+
(** [pp_number' fmt] is like {!pp_number} but uses [fmt] to format the number.
1372
1375
*)
1373
1376
1374
1377
val pp_string : string Fmt.t
···
1379
1382
(** [pp_json] formats JSON, see {!pp_json'}. *)
1380
1383
1381
1384
val pp_json' : ?number_format:number_format -> unit -> t Fmt.t
1382
-
(** [pp' ~format ~number_format () ppf j] formats [j] on [ppf]. The output is
1385
+
(** [pp_json' ?number_format () ppf j] formats [j] on [ppf]. The output is
1383
1386
indented but may be more compact than an [Indent] JSON encoder may do. For
1384
1387
example arrays may be output on one line if they fit etc.
1385
1388
- [number_format] is used to format JSON numbers. Defaults to
1386
-
{!default_number_format}
1389
+
{!default_number_format}.
1387
1390
- Non-finite numbers are output as JSON nulls
1388
1391
({{!page-cookbook.non_finite_numbers}explanation}).
1389
1392
- Strings are assumed to be valid UTF-8. *)