···

       
1
       
-
       
v1.1.0 (dev)

     

       
2
       
-
       
------------

     

       
3
       
 
       


     

       
4
       
 
       
- Simplify round trip processing of unknown messages using Jsont combinators (@avsm).

     

       
0
       
 
       

     

       
5
       
 
       


     

       
6
       
 
       
v1.0.0 (2025-11-12)

     

       
7
       
 
       
-------------------

     

···

       
1
       
+
       
v1.1.0 (2025-11-12)

     

       
2
       
+
       
-------------------

     

       
3
       
 
       


     

       
4
       
 
       
- Simplify round trip processing of unknown messages using Jsont combinators (@avsm).

     

       
5
       
+
       
- Relax alcotest version constraints (@avsm).

     

       
6
       
 
       


     

       
7
       
 
       
v1.0.0 (2025-11-12)

     

       
8
       
 
       
-------------------

     

···

       
25
       
 
       
  (ptime (>= 1.2.0))

     

       
26
       
 
       
  bytesrw

     

       
27
       
 
       
  (odoc :with-doc)

     

       
28
       
-
       
  (alcotest (and :with-test (>= 1.8.0)))))

     

···

       
25
       
 
       
  (ptime (>= 1.2.0))

     

       
26
       
 
       
  bytesrw

     

       
27
       
 
       
  (odoc :with-doc)

     

       
28
       
+
       
  (alcotest (and :with-test (>= 1.5.0)))))

     

···

       
15
       
 
       
  "ptime" {>= "1.2.0"}

     

       
16
       
 
       
  "bytesrw"

     

       
17
       
 
       
  "odoc" {with-doc}

     

       
18
       
-
       
  "alcotest" {with-test & >= "1.8.0"}

     

       
19
       
 
       
]

     

       
20
       
 
       
build: [

     

       
21
       
 
       
  ["dune" "subst"] {dev}

     

···

       
15
       
 
       
  "ptime" {>= "1.2.0"}

     

       
16
       
 
       
  "bytesrw"

     

       
17
       
 
       
  "odoc" {with-doc}

     

       
18
       
+
       
  "alcotest" {with-test & >= "1.5.0"}

     

       
19
       
 
       
]

     

       
20
       
 
       
build: [

     

       
21
       
 
       
  ["dune" "subst"] {dev}

     

···

       
46
       
 
       


     

       
47
       
 
       
  Format.fprintf ppf "%s (%s" filename t.mime_type;

     

       
48
       
 
       


     

       
49
       
-
       
  (match t.size_in_bytes with

     

       
50
       
-
       
  | Some size ->

     

       
51
       
 
       
      let mb = Int64.to_float size /. (1024. *. 1024.) in

     

       
52
       
-
       
      Format.fprintf ppf ", %.1f MB" mb

     

       
53
       
-
       
  | None -> ());

     

       
54
       
 
       


     

       
55
       
-
       
  (match t.duration_in_seconds with

     

       
56
       
-
       
  | Some duration ->

     

       
57
       
 
       
      let mins = duration / 60 in

     

       
58
       
 
       
      let secs = duration mod 60 in

     

       
59
       
-
       
      Format.fprintf ppf ", %dm%ds" mins secs

     

       
60
       
-
       
  | None -> ());

     

       
61
       
 
       


     

       
62
       
 
       
  Format.fprintf ppf ")"

     

       
63
       
 
       


     

···

       
46
       
 
       


     

       
47
       
 
       
  Format.fprintf ppf "%s (%s" filename t.mime_type;

     

       
48
       
 
       


     

       
49
       
+
       
  Option.iter

     

       
50
       
+
       
    (fun size ->

     

       
51
       
 
       
      let mb = Int64.to_float size /. (1024. *. 1024.) in

     

       
52
       
+
       
      Format.fprintf ppf ", %.1f MB" mb)

     

       
53
       
+
       
    t.size_in_bytes;

     

       
54
       
 
       


     

       
55
       
+
       
  Option.iter

     

       
56
       
+
       
    (fun duration ->

     

       
57
       
 
       
      let mins = duration / 60 in

     

       
58
       
 
       
      let secs = duration mod 60 in

     

       
59
       
+
       
      Format.fprintf ppf ", %dm%ds" mins secs)

     

       
60
       
+
       
    t.duration_in_seconds;

     

       
61
       
 
       


     

       
62
       
 
       
  Format.fprintf ppf ")"

     

       
63
       
 
       


     

···

       
19
       
 
       


     

       
20
       
 
       
module Unknown : sig

     

       
21
       
 
       
  type t = Jsont.json

     

       
22
       
-
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
23
       
-
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
24
       
 
       


     

       
25
       
 
       
  val empty : t

     

       
26
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
19
       
 
       


     

       
20
       
 
       
module Unknown : sig

     

       
21
       
 
       
  type t = Jsont.json

     

       
22
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object. Useful

     

       
23
       
+
       
      for preserving fields from custom extensions or future spec versions. *)

     

       
24
       
 
       


     

       
25
       
 
       
  val empty : t

     

       
26
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
 
       
  type t = Jsont.json

     

       
21
       
-
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
22
       
-
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
 
       
  type t = Jsont.json

     

       
21
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object. Useful

     

       
22
       
+
       
      for preserving fields from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
158
       
 
       
let jsont =

     

       
159
       
 
       
  let kind = "CiTO intent" in

     

       
160
       
 
       
  let doc = "A Citation Typing Ontology intent annotation" in

     

       
161
       
-
       
  let dec = of_string in

     

       
162
       
-
       
  let enc = to_string in

     

       
163
       
-
       
  Jsont.map ~kind ~doc ~dec ~enc Jsont.string

     

···

       
158
       
 
       
let jsont =

     

       
159
       
 
       
  let kind = "CiTO intent" in

     

       
160
       
 
       
  let doc = "A Citation Typing Ontology intent annotation" in

     

       
161
       
+
       
  Jsont.map ~kind ~doc ~dec:of_string ~enc:to_string Jsont.string

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
 
       
  type t = Jsont.json

     

       
21
       
-
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
22
       
-
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
18
       
 
       


     

       
19
       
 
       
module Unknown : sig

     

       
20
       
 
       
  type t = Jsont.json

     

       
21
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object. Useful

     

       
22
       
+
       
      for preserving fields from custom extensions or future spec versions. *)

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
83
       
 
       
  | `Both (_, text) -> Some text

     

       
84
       
 
       


     

       
85
       
 
       
let equal a b = a.id = b.id

     

       
86
       
-
       


     

       
87
       
-
       
let compare a b =

     

       
88
       
-
       
  match (a.date_published, b.date_published) with

     

       
89
       
-
       
  | None, None -> 0

     

       
90
       
-
       
  | None, Some _ -> -1

     

       
91
       
-
       
  | Some _, None -> 1

     

       
92
       
-
       
  | Some da, Some db -> Ptime.compare da db

     

       
93
       
 
       


     

       
94
       
 
       
let pp ppf t =

     

       
95
       
 
       
  match (t.date_published, t.title) with

     
···

       
103
       
 
       
  | None, None -> Format.fprintf ppf "%s" t.id

     

       
104
       
 
       


     

       
105
       
 
       
let pp_summary ppf t =

     

       
106
       
-
       
  match t.title with

     

       
107
       
-
       
  | Some title -> Format.fprintf ppf "%s" title

     

       
108
       
-
       
  | None -> Format.fprintf ppf "%s" t.id

     

       
109
       
 
       


     

       
110
       
 
       
(* Jsont type *)

     

       
111
       
 
       


     
···

       
147
       
 
       
    }

     

       
148
       
 
       
  in

     

       
149
       
 
       


     

       
150
       
-
       
  (* Encoders to extract fields from item *)

     

       
151
       
-
       
  let enc_id t = t.id in

     

       
152
       
-
       
  let enc_content_html t = content_html t in

     

       
153
       
-
       
  let enc_content_text t = content_text t in

     

       
154
       
-
       
  let enc_url t = t.url in

     

       
155
       
-
       
  let enc_external_url t = t.external_url in

     

       
156
       
-
       
  let enc_title t = t.title in

     

       
157
       
-
       
  let enc_summary t = t.summary in

     

       
158
       
-
       
  let enc_image t = t.image in

     

       
159
       
-
       
  let enc_banner_image t = t.banner_image in

     

       
160
       
-
       
  let enc_date_published t = t.date_published in

     

       
161
       
-
       
  let enc_date_modified t = t.date_modified in

     

       
162
       
-
       
  let enc_authors t = t.authors in

     

       
163
       
-
       
  let enc_tags t = t.tags in

     

       
164
       
-
       
  let enc_language t = t.language in

     

       
165
       
-
       
  let enc_attachments t = t.attachments in

     

       
166
       
-
       
  let enc_references t = t.references in

     

       
167
       
-
       
  let enc_unknown t = t.unknown in

     

       
168
       
-
       


     

       
169
       
 
       
  Jsont.Object.map ~kind ~doc make_from_json

     

       
170
       
-
       
  |> Jsont.Object.mem "id" Jsont.string ~enc:enc_id

     

       
171
       
-
       
  |> Jsont.Object.opt_mem "content_html" Jsont.string ~enc:enc_content_html

     

       
172
       
-
       
  |> Jsont.Object.opt_mem "content_text" Jsont.string ~enc:enc_content_text

     

       
173
       
-
       
  |> Jsont.Object.opt_mem "url" Jsont.string ~enc:enc_url

     

       
174
       
-
       
  |> Jsont.Object.opt_mem "external_url" Jsont.string ~enc:enc_external_url

     

       
175
       
-
       
  |> Jsont.Object.opt_mem "title" Jsont.string ~enc:enc_title

     

       
176
       
-
       
  |> Jsont.Object.opt_mem "summary" Jsont.string ~enc:enc_summary

     

       
177
       
-
       
  |> Jsont.Object.opt_mem "image" Jsont.string ~enc:enc_image

     

       
178
       
-
       
  |> Jsont.Object.opt_mem "banner_image" Jsont.string ~enc:enc_banner_image

     

       
179
       
-
       
  |> Jsont.Object.opt_mem "date_published" Rfc3339.jsont ~enc:enc_date_published

     

       
180
       
-
       
  |> Jsont.Object.opt_mem "date_modified" Rfc3339.jsont ~enc:enc_date_modified

     

       
181
       
-
       
  |> Jsont.Object.opt_mem "authors" (Jsont.list Author.jsont) ~enc:enc_authors

     

       
182
       
-
       
  |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:enc_tags

     

       
183
       
-
       
  |> Jsont.Object.opt_mem "language" Jsont.string ~enc:enc_language

     

       
184
       
 
       
  |> Jsont.Object.opt_mem "attachments"

     

       
185
       
 
       
       (Jsont.list Attachment.jsont)

     

       
186
       
-
       
       ~enc:enc_attachments

     

       
187
       
 
       
  |> Jsont.Object.opt_mem "_references"

     

       
188
       
 
       
       (Jsont.list Reference.jsont)

     

       
189
       
-
       
       ~enc:enc_references

     

       
190
       
 
       
  |> Jsont.Object.opt_mem "_extensions" Jsont.json_object ~enc:(fun _t -> None)

     

       
191
       
-
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:enc_unknown

     

       
192
       
 
       
  |> Jsont.Object.finish

     

···

       
83
       
 
       
  | `Both (_, text) -> Some text

     

       
84
       
 
       


     

       
85
       
 
       
let equal a b = a.id = b.id

     

       
86
       
+
       
let compare a b = Option.compare Ptime.compare a.date_published b.date_published

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
87
       
 
       


     

       
88
       
 
       
let pp ppf t =

     

       
89
       
 
       
  match (t.date_published, t.title) with

     
···

       
97
       
 
       
  | None, None -> Format.fprintf ppf "%s" t.id

     

       
98
       
 
       


     

       
99
       
 
       
let pp_summary ppf t =

     

       
100
       
+
       
  Format.fprintf ppf "%s" (Option.value ~default:t.id t.title)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
101
       
 
       


     

       
102
       
 
       
(* Jsont type *)

     

       
103
       
 
       


     
···

       
139
       
 
       
    }

     

       
140
       
 
       
  in

     

       
141
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
142
       
 
       
  Jsont.Object.map ~kind ~doc make_from_json

     

       
143
       
+
       
  |> Jsont.Object.mem "id" Jsont.string ~enc:id

     

       
144
       
+
       
  |> Jsont.Object.opt_mem "content_html" Jsont.string ~enc:content_html

     

       
145
       
+
       
  |> Jsont.Object.opt_mem "content_text" Jsont.string ~enc:content_text

     

       
146
       
+
       
  |> Jsont.Object.opt_mem "url" Jsont.string ~enc:url

     

       
147
       
+
       
  |> Jsont.Object.opt_mem "external_url" Jsont.string ~enc:external_url

     

       
148
       
+
       
  |> Jsont.Object.opt_mem "title" Jsont.string ~enc:title

     

       
149
       
+
       
  |> Jsont.Object.opt_mem "summary" Jsont.string ~enc:summary

     

       
150
       
+
       
  |> Jsont.Object.opt_mem "image" Jsont.string ~enc:image

     

       
151
       
+
       
  |> Jsont.Object.opt_mem "banner_image" Jsont.string ~enc:banner_image

     

       
152
       
+
       
  |> Jsont.Object.opt_mem "date_published" Rfc3339.jsont ~enc:date_published

     

       
153
       
+
       
  |> Jsont.Object.opt_mem "date_modified" Rfc3339.jsont ~enc:date_modified

     

       
154
       
+
       
  |> Jsont.Object.opt_mem "authors" (Jsont.list Author.jsont) ~enc:authors

     

       
155
       
+
       
  |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:tags

     

       
156
       
+
       
  |> Jsont.Object.opt_mem "language" Jsont.string ~enc:language

     

       
157
       
 
       
  |> Jsont.Object.opt_mem "attachments"

     

       
158
       
 
       
       (Jsont.list Attachment.jsont)

     

       
159
       
+
       
       ~enc:attachments

     

       
160
       
 
       
  |> Jsont.Object.opt_mem "_references"

     

       
161
       
 
       
       (Jsont.list Reference.jsont)

     

       
162
       
+
       
       ~enc:references

     

       
163
       
 
       
  |> Jsont.Object.opt_mem "_extensions" Jsont.json_object ~enc:(fun _t -> None)

     

       
164
       
+
       
  |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       
165
       
 
       
  |> Jsont.Object.finish

     

···

       
28
       
 
       


     

       
29
       
 
       
module Unknown : sig

     

       
30
       
 
       
  type t = Jsont.json

     

       
31
       
-
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
32
       
-
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
33
       
 
       


     

       
34
       
 
       
  val empty : t

     

       
35
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
28
       
 
       


     

       
29
       
 
       
module Unknown : sig

     

       
30
       
 
       
  type t = Jsont.json

     

       
31
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object. Useful

     

       
32
       
+
       
      for preserving fields from custom extensions or future spec versions. *)

     

       
33
       
 
       


     

       
34
       
 
       
  val empty : t

     

       
35
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
163
       
 
       
    add_error "items must have unique IDs";

     

       
164
       
 
       


     

       
165
       
 
       
  (* Validate authors *)

     

       
166
       
-
       
  (match feed.authors with

     

       
167
       
-
       
  | Some authors ->

     

       
168
       
-
       
      List.iteri

     

       
169
       
-
       
        (fun i author ->

     

       
170
       
-
       
          if not (Author.is_valid author) then

     

       
171
       
-
       
            add_error

     

       
172
       
-
       
              (Printf.sprintf

     

       
173
       
-
       
                 "feed author %d is invalid (needs at least one field)" i))

     

       
174
       
-
       
        authors

     

       
175
       
-
       
  | None -> ());

     

       
176
       
 
       


     

       
177
       
 
       
  (* Validate items *)

     

       
178
       
 
       
  List.iteri

     
···

       
181
       
 
       
        add_error (Printf.sprintf "item %d has empty ID" i);

     

       
182
       
 
       


     

       
183
       
 
       
      (* Validate item authors *)

     

       
184
       
-
       
      match Item.authors item with

     

       
185
       
-
       
      | Some authors ->

     

       
186
       
-
       
          List.iteri

     

       
187
       
-
       
            (fun j author ->

     

       
188
       
-
       
              if not (Author.is_valid author) then

     

       
189
       
-
       
                add_error (Printf.sprintf "item %d author %d is invalid" i j))

     

       
190
       
-
       
            authors

     

       
191
       
-
       
      | None -> ())

     

       
192
       
 
       
    feed.items;

     

       
193
       
 
       


     

       
194
       
 
       
  match !errors with [] -> Ok () | errs -> Error (List.rev errs)

     

···

       
163
       
 
       
    add_error "items must have unique IDs";

     

       
164
       
 
       


     

       
165
       
 
       
  (* Validate authors *)

     

       
166
       
+
       
  Option.iter

     

       
167
       
+
       
    (List.iteri (fun i author ->

     

       
168
       
+
       
         if not (Author.is_valid author) then

     

       
169
       
+
       
           add_error

     

       
170
       
+
       
             (Printf.sprintf

     

       
171
       
+
       
                "feed author %d is invalid (needs at least one field)" i)))

     

       
172
       
+
       
    feed.authors;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
173
       
 
       


     

       
174
       
 
       
  (* Validate items *)

     

       
175
       
 
       
  List.iteri

     
···

       
178
       
 
       
        add_error (Printf.sprintf "item %d has empty ID" i);

     

       
179
       
 
       


     

       
180
       
 
       
      (* Validate item authors *)

     

       
181
       
+
       
      Option.iter

     

       
182
       
+
       
        (List.iteri (fun j author ->

     

       
183
       
+
       
             if not (Author.is_valid author) then

     

       
184
       
+
       
               add_error (Printf.sprintf "item %d author %d is invalid" i j)))

     

       
185
       
+
       
        (Item.authors item))

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
186
       
 
       
    feed.items;

     

       
187
       
 
       


     

       
188
       
 
       
  match !errors with [] -> Ok () | errs -> Error (List.rev errs)

     

···

       
19
       
 
       
module Unknown : sig

     

       
20
       
 
       
  type t = Jsont.json

     

       
21
       
 
       
  (** Unknown or unrecognized JSON object members as a generic JSON object.

     

       
22
       
-
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
0
       
 
       

     

       
23
       
 
       


     

       
24
       
 
       
  val empty : t

     

       
25
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
19
       
 
       
module Unknown : sig

     

       
20
       
 
       
  type t = Jsont.json

     

       
21
       
 
       
  (** Unknown or unrecognized JSON object members as a generic JSON object.

     

       
22
       
+
       
      Useful for preserving fields from custom extensions or future spec

     

       
23
       
+
       
      versions. *)

     

       
24
       
 
       


     

       
25
       
 
       
  val empty : t

     

       
26
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
29
       
 
       
let pp ppf t =

     

       
30
       
 
       
  let open Format in

     

       
31
       
 
       
  fprintf ppf "%s" t.url;

     

       
32
       
-
       
  match t.doi with Some d -> fprintf ppf " [DOI: %s]" d | None -> ()

     

       
33
       
 
       


     

       
34
       
 
       
let jsont =

     

       
35
       
 
       
  let kind = "Reference" in

     

···

       
29
       
 
       
let pp ppf t =

     

       
30
       
 
       
  let open Format in

     

       
31
       
 
       
  fprintf ppf "%s" t.url;

     

       
32
       
+
       
  Option.iter (fprintf ppf " [DOI: %s]") t.doi

     

       
33
       
 
       


     

       
34
       
 
       
let jsont =

     

       
35
       
 
       
  let kind = "Reference" in

     

···

       
20
       
 
       


     

       
21
       
 
       
module Unknown : sig

     

       
22
       
 
       
  type t = Jsont.json

     

       
23
       
-
       
  (** Unknown/unrecognized JSON object members as a generic JSON object.

     

       
24
       
-
       
      Useful for preserving fields from custom extensions or future spec versions. *)

     

       
25
       
 
       


     

       
26
       
 
       
  val empty : t

     

       
27
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
20
       
 
       


     

       
21
       
 
       
module Unknown : sig

     

       
22
       
 
       
  type t = Jsont.json

     

       
23
       
+
       
  (** Unknown/unrecognized JSON object members as a generic JSON object. Useful

     

       
24
       
+
       
      for preserving fields from custom extensions or future spec versions. *)

     

       
25
       
 
       


     

       
26
       
 
       
  val empty : t

     

       
27
       
 
       
  (** [empty] is the empty list of unknown fields. *)

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
let parse s =

     

       
7
       
-
       
  match Ptime.of_rfc3339 s with Ok (t, _, _) -> Some t | Error _ -> None

     

       
8
       
 
       


     

       
9
       
 
       
let format t = Ptime.to_rfc3339 ~frac_s:6 ~tz_offset_s:0 t

     

       
10
       
 
       
let pp ppf t = Format.pp_print_string ppf (format t)

     

···

       
4
       
 
       
  ---------------------------------------------------------------------------*)

     

       
5
       
 
       


     

       
6
       
 
       
let parse s =

     

       
7
       
+
       
  Ptime.of_rfc3339 s |> Result.to_option |> Option.map (fun (t, _, _) -> t)

     

       
8
       
 
       


     

       
9
       
 
       
let format t = Ptime.to_rfc3339 ~frac_s:6 ~tz_offset_s:0 t

     

       
10
       
 
       
let pp ppf t = Format.pp_print_string ppf (format t)

     

···

       
384
       
 
       
  | Error e ->

     

       
385
       
 
       
      Alcotest.fail

     

       
386
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
387
       
-
       
  | Ok author ->

     

       
388
       
 
       
      (* Check that unknown fields are preserved *)

     

       
389
       
 
       
      let unknown = Author.unknown author in

     

       
390
       
 
       
      Alcotest.(check bool)

     

       
391
       
 
       
        "has unknown fields" false

     

       
392
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
393
       
 
       
      (* Encode and decode again *)

     

       
394
       
-
       
      (match Jsont_bytesrw.encode_string' Author.jsont author with

     

       
395
       
 
       
      | Error e ->

     

       
396
       
 
       
          Alcotest.fail

     

       
397
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
420
       
 
       
  | Error e ->

     

       
421
       
 
       
      Alcotest.fail

     

       
422
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
423
       
-
       
  | Ok item ->

     

       
424
       
 
       
      (* Check that unknown fields are preserved *)

     

       
425
       
 
       
      let unknown = Item.unknown item in

     

       
426
       
 
       
      Alcotest.(check bool)

     

       
427
       
 
       
        "has unknown fields" false

     

       
428
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
429
       
 
       
      (* Encode and decode again *)

     

       
430
       
-
       
      (match Jsont_bytesrw.encode_string' Item.jsont item with

     

       
431
       
 
       
      | Error e ->

     

       
432
       
 
       
          Alcotest.fail

     

       
433
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
456
       
 
       
  | Error e ->

     

       
457
       
 
       
      Alcotest.fail

     

       
458
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
459
       
-
       
  | Ok feed ->

     

       
460
       
 
       
      (* Check that unknown fields are preserved *)

     

       
461
       
 
       
      let unknown = Jsonfeed.unknown feed in

     

       
462
       
 
       
      Alcotest.(check bool)

     

       
463
       
 
       
        "has unknown fields" false

     

       
464
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
465
       
 
       
      (* Encode and decode again *)

     

       
466
       
-
       
      (match Jsonfeed.to_string feed with

     

       
467
       
 
       
      | Error e ->

     

       
468
       
 
       
          Alcotest.fail

     

       
469
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
479
       
 
       
                (Jsonfeed.Unknown.is_empty unknown2)))

     

       
480
       
 
       


     

       
481
       
 
       
let test_hub_unknown_roundtrip () =

     

       
482
       
-
       
  let json = {|{

     

       
0
       
 
       

     

       
483
       
 
       
    "type": "WebSub",

     

       
484
       
 
       
    "url": "https://example.com/hub",

     

       
485
       
 
       
    "custom_field": "test"

     

       
486
       
-
       
  }|} in

     

       
0
       
 
       

     

       
487
       
 
       
  match Jsont_bytesrw.decode_string' Hub.jsont json with

     

       
488
       
 
       
  | Error e ->

     

       
489
       
 
       
      Alcotest.fail

     

       
490
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
491
       
-
       
  | Ok hub ->

     

       
492
       
 
       
      let unknown = Hub.unknown hub in

     

       
493
       
 
       
      Alcotest.(check bool)

     

       
494
       
 
       
        "has unknown fields" false

     

       
495
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
496
       
-
       
      (match Jsont_bytesrw.encode_string' Hub.jsont hub with

     

       
497
       
 
       
      | Error e ->

     

       
498
       
 
       
          Alcotest.fail

     

       
499
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
520
       
 
       
  | Error e ->

     

       
521
       
 
       
      Alcotest.fail

     

       
522
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
523
       
-
       
  | Ok att ->

     

       
524
       
 
       
      let unknown = Attachment.unknown att in

     

       
525
       
 
       
      Alcotest.(check bool)

     

       
526
       
 
       
        "has unknown fields" false

     

       
527
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
528
       
-
       
      (match Jsont_bytesrw.encode_string' Attachment.jsont att with

     

       
529
       
 
       
      | Error e ->

     

       
530
       
 
       
          Alcotest.fail

     

       
531
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     

···

       
384
       
 
       
  | Error e ->

     

       
385
       
 
       
      Alcotest.fail

     

       
386
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
387
       
+
       
  | Ok author -> (

     

       
388
       
 
       
      (* Check that unknown fields are preserved *)

     

       
389
       
 
       
      let unknown = Author.unknown author in

     

       
390
       
 
       
      Alcotest.(check bool)

     

       
391
       
 
       
        "has unknown fields" false

     

       
392
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
393
       
 
       
      (* Encode and decode again *)

     

       
394
       
+
       
      match Jsont_bytesrw.encode_string' Author.jsont author with

     

       
395
       
 
       
      | Error e ->

     

       
396
       
 
       
          Alcotest.fail

     

       
397
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
420
       
 
       
  | Error e ->

     

       
421
       
 
       
      Alcotest.fail

     

       
422
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
423
       
+
       
  | Ok item -> (

     

       
424
       
 
       
      (* Check that unknown fields are preserved *)

     

       
425
       
 
       
      let unknown = Item.unknown item in

     

       
426
       
 
       
      Alcotest.(check bool)

     

       
427
       
 
       
        "has unknown fields" false

     

       
428
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
429
       
 
       
      (* Encode and decode again *)

     

       
430
       
+
       
      match Jsont_bytesrw.encode_string' Item.jsont item with

     

       
431
       
 
       
      | Error e ->

     

       
432
       
 
       
          Alcotest.fail

     

       
433
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
456
       
 
       
  | Error e ->

     

       
457
       
 
       
      Alcotest.fail

     

       
458
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
459
       
+
       
  | Ok feed -> (

     

       
460
       
 
       
      (* Check that unknown fields are preserved *)

     

       
461
       
 
       
      let unknown = Jsonfeed.unknown feed in

     

       
462
       
 
       
      Alcotest.(check bool)

     

       
463
       
 
       
        "has unknown fields" false

     

       
464
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
465
       
 
       
      (* Encode and decode again *)

     

       
466
       
+
       
      match Jsonfeed.to_string feed with

     

       
467
       
 
       
      | Error e ->

     

       
468
       
 
       
          Alcotest.fail

     

       
469
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
479
       
 
       
                (Jsonfeed.Unknown.is_empty unknown2)))

     

       
480
       
 
       


     

       
481
       
 
       
let test_hub_unknown_roundtrip () =

     

       
482
       
+
       
  let json =

     

       
483
       
+
       
    {|{

     

       
484
       
 
       
    "type": "WebSub",

     

       
485
       
 
       
    "url": "https://example.com/hub",

     

       
486
       
 
       
    "custom_field": "test"

     

       
487
       
+
       
  }|}

     

       
488
       
+
       
  in

     

       
489
       
 
       
  match Jsont_bytesrw.decode_string' Hub.jsont json with

     

       
490
       
 
       
  | Error e ->

     

       
491
       
 
       
      Alcotest.fail

     

       
492
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
493
       
+
       
  | Ok hub -> (

     

       
494
       
 
       
      let unknown = Hub.unknown hub in

     

       
495
       
 
       
      Alcotest.(check bool)

     

       
496
       
 
       
        "has unknown fields" false

     

       
497
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
498
       
+
       
      match Jsont_bytesrw.encode_string' Hub.jsont hub with

     

       
499
       
 
       
      | Error e ->

     

       
500
       
 
       
          Alcotest.fail

     

       
501
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))

     
···

       
522
       
 
       
  | Error e ->

     

       
523
       
 
       
      Alcotest.fail

     

       
524
       
 
       
        (Printf.sprintf "Parse failed: %s" (Jsont.Error.to_string e))

     

       
525
       
+
       
  | Ok att -> (

     

       
526
       
 
       
      let unknown = Attachment.unknown att in

     

       
527
       
 
       
      Alcotest.(check bool)

     

       
528
       
 
       
        "has unknown fields" false

     

       
529
       
 
       
        (Jsonfeed.Unknown.is_empty unknown);

     

       
530
       
+
       
      match Jsont_bytesrw.encode_string' Attachment.jsont att with

     

       
531
       
 
       
      | Error e ->

     

       
532
       
 
       
          Alcotest.fail

     

       
533
       
 
       
            (Printf.sprintf "Encode failed: %s" (Jsont.Error.to_string e))