comparing 8ce9b82167ed35ccf304360f4fde55bd4e78e945 and main on anil.recoil.org/ocaml-jsonfeed

.tangled/workflows/build.yml

···

       26
       26
        
           - bzip2

     

       27
       27
        
           - gcc

     

       28
       28
        
           - ocaml

     

       29
       29
       +
           - pkg-config

     

       29
       30
        
       

     

       30
       31
        
       steps:

     

       31
       32
        
         - name: opam

+8 -2

CHANGES.md

···

       1
       1
       -
       v1.0.0

     

       2
       2
       -
       ------

     

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

     

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

     

       3
       3
       +
       

     

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

     

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

     

       6
       6
       +
       

     

       7
       7
       +
       v1.0.0 (2025-11-12)

     

       8
       8
       +
       -------------------

     

       3
       9
        
       

     

       4
       10
        
       - Initial public release (@avsm)

     

       5
       11

+3 -3

dune-project

···

       21
       21
        
          and serialization using Jsonm and Ptime.")

     

       22
       22
        
        (depends

     

       23
       23
        
         (ocaml (>= 5.2.0))

     

       24
       24
       -
         (jsonm (>= 1.0.0))

     

       24
       24
       +
         (jsont (>= 0.2.0))

     

       25
       25
        
         (ptime (>= 1.2.0))

     

       26
       26
       -
         (fmt (>= 0.11.0))

     

       26
       26
       +
         bytesrw

     

       27
       27
        
         (odoc :with-doc)

     

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

     

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

+4 -3

jsonfeed.opam

···

       11
       11
        
       depends: [

     

       12
       12
        
         "dune" {>= "3.18"}

     

       13
       13
        
         "ocaml" {>= "5.2.0"}

     

       14
       14
       -
         "jsonm" {>= "1.0.0"}

     

       14
       14
       +
         "jsont" {>= "0.2.0"}

     

       15
       15
        
         "ptime" {>= "1.2.0"}

     

       16
       16
       -
         "fmt" {>= "0.11.0"}

     

       16
       16
       +
         "bytesrw"

     

       17
       17
        
         "odoc" {with-doc}

     

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

     

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

     

       19
       19
        
       ]

     

       20
       20
        
       build: [

     

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

     
···

       32
       32
        
         ]

     

       33
       33
        
       ]

     

       34
       34
        
       x-maintenance-intent: ["(latest)"]

     

       35
       35
       +
       dev-repo: "git+https://tangled.sh/@anil.recoil.org/ocaml-jsonfeed"

+12 -37

lib/attachment.ml

···

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

     

       5
       5
        
       

     

       6
       6
        
       module Unknown = struct

     

       7
       7
       -
         type t = (string * Jsont.json) list

     

       7
       7
       +
         type t = Jsont.json

     

       8
       8
        
       

     

       9
       9
       -
         let empty = []

     

       10
       10
       -
         let is_empty = function [] -> true | _ -> false

     

       9
       9
       +
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       10
       10
       +
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       11
       11
        
       end

     

       12
       12
        
       

     

       13
       13
        
       type t = {

     
···

       46
       46
        
       

     

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

     

       48
       48
        
       

     

       49
       49
       -
         (match t.size_in_bytes with

     

       50
       50
       -
         | Some size ->

     

       49
       49
       +
         Option.iter

     

       50
       50
       +
           (fun size ->

     

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

     

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

     

       53
       53
       -
         | None -> ());

     

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

     

       53
       53
       +
           t.size_in_bytes;

     

       54
       54
        
       

     

       55
       55
       -
         (match t.duration_in_seconds with

     

       56
       56
       -
         | Some duration ->

     

       55
       55
       +
         Option.iter

     

       56
       56
       +
           (fun duration ->

     

       57
       57
        
             let mins = duration / 60 in

     

       58
       58
        
             let secs = duration mod 60 in

     

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

     

       60
       60
       -
         | None -> ());

     

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

     

       60
       60
       +
           t.duration_in_seconds;

     

       61
       61
        
       

     

       62
       62
        
         Format.fprintf ppf ")"

     

       63
       63
        
       

     

       64
       64
        
       let jsont =

     

       65
       65
        
         let kind = "Attachment" in

     

       66
       66
        
         let doc = "An attachment object" in

     

       67
       67
       -
         let unknown_mems :

     

       68
       68
       -
             (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       69
       69
       -
           let open Jsont.Object.Mems in

     

       70
       70
       -
           let dec_empty () = [] in

     

       71
       71
       -
           let dec_add _meta (name : string) value acc =

     

       72
       72
       -
             ((name, Jsont.Meta.none), value) :: acc

     

       73
       73
       -
           in

     

       74
       74
       -
           let dec_finish _meta mems =

     

       75
       75
       -
             List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       76
       76
       -
           in

     

       77
       77
       -
           let enc =

     

       78
       78
       -
             {

     

       79
       79
       -
               enc =

     

       80
       80
       -
                 (fun (type acc)

     

       81
       81
       -
                   (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       82
       82
       -
                   unknown

     

       83
       83
       -
                   (acc : acc)

     

       84
       84
       -
                 ->

     

       85
       85
       -
                   List.fold_left

     

       86
       86
       -
                     (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       87
       87
       -
                     acc unknown);

     

       88
       88
       -
             }

     

       89
       89
       -
           in

     

       90
       90
       -
           map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       91
       91
       -
         in

     

       92
       67
        
         let create_obj url mime_type title size_in_bytes duration_in_seconds unknown =

     

       93
       68
        
           create ~url ~mime_type ?title ?size_in_bytes ?duration_in_seconds ~unknown

     

       94
       69
        
             ()

     
···

       100
       75
        
         |> Jsont.Object.opt_mem "size_in_bytes" Jsont.int64 ~enc:size_in_bytes

     

       101
       76
        
         |> Jsont.Object.opt_mem "duration_in_seconds" Jsont.int

     

       102
       77
        
              ~enc:duration_in_seconds

     

       103
       103
       -
         |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

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

     

       104
       79
        
         |> Jsont.Object.finish

+3 -3

lib/attachment.mli

···

       18
       18
        
       (** {1 Unknown Fields} *)

     

       19
       19
        
       

     

       20
       20
        
       module Unknown : sig

     

       21
       21
       -
         type t = (string * Jsont.json) list

     

       22
       22
       -
         (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       23
       23
       -
             from custom extensions or future spec versions. *)

     

       21
       21
       +
         type t = Jsont.json

     

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

     

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

     

       24
       24
        
       

     

       25
       25
        
         val empty : t

     

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

+4 -30

lib/author.ml

···

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

     

       5
       5
        
       

     

       6
       6
        
       module Unknown = struct

     

       7
       7
       -
         type t = (string * Jsont.json) list

     

       7
       7
       +
         type t = Jsont.json

     

       8
       8
        
       

     

       9
       9
       -
         let empty = []

     

       10
       10
       -
         let is_empty = function [] -> true | _ -> false

     

       9
       9
       +
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       10
       10
       +
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       11
       11
        
       end

     

       12
       12
        
       

     

       13
       13
        
       type t = {

     
···

       44
       44
        
       let jsont =

     

       45
       45
        
         let kind = "Author" in

     

       46
       46
        
         let doc = "An author object with at least one field set" in

     

       47
       47
       -
         (* Custom mems map for Unknown.t that strips metadata from names *)

     

       48
       48
       -
         let unknown_mems :

     

       49
       49
       -
             (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       50
       50
       -
           let open Jsont.Object.Mems in

     

       51
       51
       -
           let dec_empty () = [] in

     

       52
       52
       -
           let dec_add _meta (name : string) value acc =

     

       53
       53
       -
             ((name, Jsont.Meta.none), value) :: acc

     

       54
       54
       -
           in

     

       55
       55
       -
           let dec_finish _meta mems =

     

       56
       56
       -
             List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       57
       57
       -
           in

     

       58
       58
       -
           let enc =

     

       59
       59
       -
             {

     

       60
       60
       -
               enc =

     

       61
       61
       -
                 (fun (type acc)

     

       62
       62
       -
                   (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       63
       63
       -
                   unknown

     

       64
       64
       -
                   (acc : acc)

     

       65
       65
       -
                 ->

     

       66
       66
       -
                   List.fold_left

     

       67
       67
       -
                     (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       68
       68
       -
                     acc unknown);

     

       69
       69
       -
             }

     

       70
       70
       -
           in

     

       71
       71
       -
           map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       72
       72
       -
         in

     

       73
       47
        
         (* Constructor that matches the jsont object map pattern *)

     

       74
       48
        
         let create_obj name url avatar unknown =

     

       75
       49
        
           create ?name ?url ?avatar ~unknown ()

     
···

       78
       52
        
         |> Jsont.Object.opt_mem "name" Jsont.string ~enc:name

     

       79
       53
        
         |> Jsont.Object.opt_mem "url" Jsont.string ~enc:url

     

       80
       54
        
         |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:avatar

     

       81
       81
       -
         |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

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

     

       82
       56
        
         |> Jsont.Object.finish

+3 -3

lib/author.mli

···

       17
       17
        
       (** {1 Unknown Fields} *)

     

       18
       18
        
       

     

       19
       19
        
       module Unknown : sig

     

       20
       20
       -
         type t = (string * Jsont.json) list

     

       21
       21
       -
         (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       22
       22
       -
             from custom extensions or future spec versions. *)

     

       20
       20
       +
         type t = Jsont.json

     

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

     

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

     

       23
       23
        
       

     

       24
       24
        
         val empty : t

     

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

+1 -3

lib/cito.ml

···

       158
       158
        
       let jsont =

     

       159
       159
        
         let kind = "CiTO intent" in

     

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

     

       161
       161
       -
         let dec = of_string in

     

       162
       162
       -
         let enc = to_string in

     

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

     

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

+4 -29

lib/hub.ml

···

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

     

       5
       5
        
       

     

       6
       6
        
       module Unknown = struct

     

       7
       7
       -
         type t = (string * Jsont.json) list

     

       7
       7
       +
         type t = Jsont.json

     

       8
       8
        
       

     

       9
       9
       -
         let empty = []

     

       10
       10
       -
         let is_empty = function [] -> true | _ -> false

     

       9
       9
       +
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       10
       10
       +
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       11
       11
        
       end

     

       12
       12
        
       

     

       13
       13
        
       type t = { type_ : string; url : string; unknown : Unknown.t }

     
···

       22
       22
        
       let jsont =

     

       23
       23
        
         let kind = "Hub" in

     

       24
       24
        
         let doc = "A hub endpoint" in

     

       25
       25
       -
         let unknown_mems :

     

       26
       26
       -
             (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       27
       27
       -
           let open Jsont.Object.Mems in

     

       28
       28
       -
           let dec_empty () = [] in

     

       29
       29
       -
           let dec_add _meta (name : string) value acc =

     

       30
       30
       -
             ((name, Jsont.Meta.none), value) :: acc

     

       31
       31
       -
           in

     

       32
       32
       -
           let dec_finish _meta mems =

     

       33
       33
       -
             List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       34
       34
       -
           in

     

       35
       35
       -
           let enc =

     

       36
       36
       -
             {

     

       37
       37
       -
               enc =

     

       38
       38
       -
                 (fun (type acc)

     

       39
       39
       -
                   (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       40
       40
       -
                   unknown

     

       41
       41
       -
                   (acc : acc)

     

       42
       42
       -
                 ->

     

       43
       43
       -
                   List.fold_left

     

       44
       44
       -
                     (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       45
       45
       -
                     acc unknown);

     

       46
       46
       -
             }

     

       47
       47
       -
           in

     

       48
       48
       -
           map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       49
       49
       -
         in

     

       50
       25
        
         let create_obj type_ url unknown = create ~type_ ~url ~unknown () in

     

       51
       26
        
         Jsont.Object.map ~kind ~doc create_obj

     

       52
       27
        
         |> Jsont.Object.mem "type" Jsont.string ~enc:type_

     

       53
       28
        
         |> Jsont.Object.mem "url" Jsont.string ~enc:url

     

       54
       54
       -
         |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

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

     

       55
       30
        
         |> Jsont.Object.finish

+3 -3

lib/hub.mli

···

       17
       17
        
       (** {1 Unknown Fields} *)

     

       18
       18
        
       

     

       19
       19
        
       module Unknown : sig

     

       20
       20
       -
         type t = (string * Jsont.json) list

     

       21
       21
       -
         (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       22
       22
       -
             from custom extensions or future spec versions. *)

     

       20
       20
       +
         type t = Jsont.json

     

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

     

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

     

       23
       23
        
       

     

       24
       24
        
         val empty : t

     

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

+22 -75

lib/item.ml

···

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

     

       5
       5
        
       

     

       6
       6
        
       module Unknown = struct

     

       7
       7
       -
         type t = (string * Jsont.json) list

     

       7
       7
       +
         type t = Jsont.json

     

       8
       8
        
       

     

       9
       9
       -
         let empty = []

     

       10
       10
       -
         let is_empty = function [] -> true | _ -> false

     

       9
       9
       +
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       10
       10
       +
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       11
       11
        
       end

     

       12
       12
        
       

     

       13
       13
        
       type content = [ `Html of string | `Text of string | `Both of string * string ]

     
···

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

     

       84
       84
        
       

     

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

     

       86
       86
       -
       

     

       87
       87
       -
       let compare a b =

     

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

     

       89
       89
       -
         | None, None -> 0

     

       90
       90
       -
         | None, Some _ -> -1

     

       91
       91
       -
         | Some _, None -> 1

     

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

     

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

     

       93
       87
        
       

     

       94
       88
        
       let pp ppf t =

     

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

     
···

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

     

       104
       98
        
       

     

       105
       99
        
       let pp_summary ppf t =

     

       106
       106
       -
         match t.title with

     

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

     

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

     

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

     

       109
       101
        
       

     

       110
       102
        
       (* Jsont type *)

     

       111
       103
        
       

     
···

       147
       139
        
           }

     

       148
       140
        
         in

     

       149
       141
        
       

     

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

     

       151
       151
       -
         let enc_id t = t.id in

     

       152
       152
       -
         let enc_content_html t = content_html t in

     

       153
       153
       -
         let enc_content_text t = content_text t in

     

       154
       154
       -
         let enc_url t = t.url in

     

       155
       155
       -
         let enc_external_url t = t.external_url in

     

       156
       156
       -
         let enc_title t = t.title in

     

       157
       157
       -
         let enc_summary t = t.summary in

     

       158
       158
       -
         let enc_image t = t.image in

     

       159
       159
       -
         let enc_banner_image t = t.banner_image in

     

       160
       160
       -
         let enc_date_published t = t.date_published in

     

       161
       161
       -
         let enc_date_modified t = t.date_modified in

     

       162
       162
       -
         let enc_authors t = t.authors in

     

       163
       163
       -
         let enc_tags t = t.tags in

     

       164
       164
       -
         let enc_language t = t.language in

     

       165
       165
       -
         let enc_attachments t = t.attachments in

     

       166
       166
       -
         let enc_references t = t.references in

     

       167
       167
       -
         let enc_unknown t = t.unknown in

     

       168
       168
       -
       

     

       169
       169
       -
         let unknown_mems :

     

       170
       170
       -
             (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       171
       171
       -
           let open Jsont.Object.Mems in

     

       172
       172
       -
           let dec_empty () = [] in

     

       173
       173
       -
           let dec_add _meta (name : string) value acc =

     

       174
       174
       -
             ((name, Jsont.Meta.none), value) :: acc

     

       175
       175
       -
           in

     

       176
       176
       -
           let dec_finish _meta mems =

     

       177
       177
       -
             List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       178
       178
       -
           in

     

       179
       179
       -
           let enc =

     

       180
       180
       -
             {

     

       181
       181
       -
               enc =

     

       182
       182
       -
                 (fun (type acc)

     

       183
       183
       -
                   (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       184
       184
       -
                   unknown

     

       185
       185
       -
                   (acc : acc)

     

       186
       186
       -
                 ->

     

       187
       187
       -
                   List.fold_left

     

       188
       188
       -
                     (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       189
       189
       -
                     acc unknown);

     

       190
       190
       -
             }

     

       191
       191
       -
           in

     

       192
       192
       -
           map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       193
       193
       -
         in

     

       194
       194
       -
       

     

       195
       142
        
         Jsont.Object.map ~kind ~doc make_from_json

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       210
       157
        
         |> Jsont.Object.opt_mem "attachments"

     

       211
       158
        
              (Jsont.list Attachment.jsont)

     

       212
       212
       -
              ~enc:enc_attachments

     

       159
       159
       +
              ~enc:attachments

     

       213
       160
        
         |> Jsont.Object.opt_mem "_references"

     

       214
       161
        
              (Jsont.list Reference.jsont)

     

       215
       215
       -
              ~enc:enc_references

     

       162
       162
       +
              ~enc:references

     

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

     

       217
       217
       -
         |> Jsont.Object.keep_unknown unknown_mems ~enc:enc_unknown

     

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

     

       218
       165
        
         |> Jsont.Object.finish

+3 -3

lib/item.mli

···

       27
       27
        
       (** {1 Unknown Fields} *)

     

       28
       28
        
       

     

       29
       29
        
       module Unknown : sig

     

       30
       30
       -
         type t = (string * Jsont.json) list

     

       31
       31
       -
         (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       32
       32
       -
             from custom extensions or future spec versions. *)

     

       30
       30
       +
         type t = Jsont.json

     

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

     

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

     

       33
       33
        
       

     

       34
       34
        
         val empty : t

     

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

+16 -47

lib/jsonfeed.ml

···

       12
       12
        
       module Item = Item

     

       13
       13
        
       

     

       14
       14
        
       module Unknown = struct

     

       15
       15
       -
         type t = (string * Jsont.json) list

     

       15
       15
       +
         type t = Jsont.json

     

       16
       16
        
       

     

       17
       17
       -
         let empty = []

     

       18
       18
       -
         let is_empty = function [] -> true | _ -> false

     

       17
       17
       +
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       18
       18
       +
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       19
       19
        
       end

     

       20
       20
        
       

     

       21
       21
        
       type t = {

     
···

       85
       85
        
       let jsont =

     

       86
       86
        
         let kind = "JSON Feed" in

     

       87
       87
        
         let doc = "A JSON Feed document" in

     

       88
       88
       -
         let unknown_mems :

     

       89
       89
       -
             (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       90
       90
       -
           let open Jsont.Object.Mems in

     

       91
       91
       -
           let dec_empty () = [] in

     

       92
       92
       -
           let dec_add _meta (name : string) value acc =

     

       93
       93
       -
             ((name, Jsont.Meta.none), value) :: acc

     

       94
       94
       -
           in

     

       95
       95
       -
           let dec_finish _meta mems =

     

       96
       96
       -
             List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       97
       97
       -
           in

     

       98
       98
       -
           let enc =

     

       99
       99
       -
             {

     

       100
       100
       -
               enc =

     

       101
       101
       -
                 (fun (type acc)

     

       102
       102
       -
                   (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       103
       103
       -
                   unknown

     

       104
       104
       -
                   (acc : acc)

     

       105
       105
       -
                 ->

     

       106
       106
       -
                   List.fold_left

     

       107
       107
       -
                     (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       108
       108
       -
                     acc unknown);

     

       109
       109
       -
             }

     

       110
       110
       -
           in

     

       111
       111
       -
           map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       112
       112
       -
         in

     

       113
       88
        
       

     

       114
       89
        
         (* Helper constructor that sets version automatically *)

     

       115
       90
        
         let make_from_json _version title home_page_url feed_url description

     
···

       149
       124
        
         |> Jsont.Object.opt_mem "expired" Jsont.bool ~enc:expired

     

       150
       125
        
         |> Jsont.Object.opt_mem "hubs" (Jsont.list Hub.jsont) ~enc:hubs

     

       151
       126
        
         |> Jsont.Object.mem "items" (Jsont.list Item.jsont) ~enc:items

     

       152
       152
       -
         |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

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

     

       153
       128
        
         |> Jsont.Object.finish

     

       154
       129
        
       

     

       155
       130
        
       (* Encoding and Decoding *)

     
···

       188
       163
        
           add_error "items must have unique IDs";

     

       189
       164
        
       

     

       190
       165
        
         (* Validate authors *)

     

       191
       191
       -
         (match feed.authors with

     

       192
       192
       -
         | Some authors ->

     

       193
       193
       -
             List.iteri

     

       194
       194
       -
               (fun i author ->

     

       195
       195
       -
                 if not (Author.is_valid author) then

     

       196
       196
       -
                   add_error

     

       197
       197
       -
                     (Printf.sprintf

     

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

     

       199
       199
       -
               authors

     

       200
       200
       -
         | None -> ());

     

       166
       166
       +
         Option.iter

     

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

     

       168
       168
       +
                if not (Author.is_valid author) then

     

       169
       169
       +
                  add_error

     

       170
       170
       +
                    (Printf.sprintf

     

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

     

       172
       172
       +
           feed.authors;

     

       201
       173
        
       

     

       202
       174
        
         (* Validate items *)

     

       203
       175
        
         List.iteri

     
···

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

     

       207
       179
        
       

     

       208
       180
        
             (* Validate item authors *)

     

       209
       209
       -
             match Item.authors item with

     

       210
       210
       -
             | Some authors ->

     

       211
       211
       -
                 List.iteri

     

       212
       212
       -
                   (fun j author ->

     

       213
       213
       -
                     if not (Author.is_valid author) then

     

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

     

       215
       215
       -
                   authors

     

       216
       216
       -
             | None -> ())

     

       181
       181
       +
             Option.iter

     

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

     

       183
       183
       +
                    if not (Author.is_valid author) then

     

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

     

       185
       185
       +
               (Item.authors item))

     

       217
       186
        
           feed.items;

     

       218
       187
        
       

     

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

+4 -3

lib/jsonfeed.mli

···

       17
       17
        
           optional fields. *)

     

       18
       18
        
       

     

       19
       19
        
       module Unknown : sig

     

       20
       20
       -
         type t = (string * Jsont.json) list

     

       21
       21
       -
         (** Unknown or unrecognized JSON object members. Useful for preserving fields

     

       22
       22
       -
             from custom extensions or future spec versions. *)

     

       20
       20
       +
         type t = Jsont.json

     

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

     

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

     

       23
       23
       +
             versions. *)

     

       23
       24
        
       

     

       24
       25
        
         val empty : t

     

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

+5 -30

lib/reference.ml

···

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

     

       5
       5
        
       

     

       6
       6
        
       module Unknown = struct

     

       7
       7
       -
         type t = (string * Jsont.json) list

     

       7
       7
       +
         type t = Jsont.json

     

       8
       8
        
       

     

       9
       9
       -
         let empty = []

     

       10
       10
       -
         let is_empty = function [] -> true | _ -> false

     

       9
       9
       +
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       10
       10
       +
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       11
       11
        
       end

     

       12
       12
        
       

     

       13
       13
        
       type t = {

     
···

       29
       29
        
       let pp ppf t =

     

       30
       30
        
         let open Format in

     

       31
       31
        
         fprintf ppf "%s" t.url;

     

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

     

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

     

       33
       33
        
       

     

       34
       34
        
       let jsont =

     

       35
       35
        
         let kind = "Reference" in

     

       36
       36
        
         let doc = "A reference to a cited source" in

     

       37
       37
       -
         let unknown_mems :

     

       38
       38
       -
             (Unknown.t, Jsont.json, Jsont.mem list) Jsont.Object.Mems.map =

     

       39
       39
       -
           let open Jsont.Object.Mems in

     

       40
       40
       -
           let dec_empty () = [] in

     

       41
       41
       -
           let dec_add _meta (name : string) value acc =

     

       42
       42
       -
             ((name, Jsont.Meta.none), value) :: acc

     

       43
       43
       -
           in

     

       44
       44
       -
           let dec_finish _meta mems =

     

       45
       45
       -
             List.rev_map (fun ((name, _meta), value) -> (name, value)) mems

     

       46
       46
       -
           in

     

       47
       47
       -
           let enc =

     

       48
       48
       -
             {

     

       49
       49
       -
               enc =

     

       50
       50
       -
                 (fun (type acc)

     

       51
       51
       -
                   (f : Jsont.Meta.t -> string -> Jsont.json -> acc -> acc)

     

       52
       52
       -
                   unknown

     

       53
       53
       -
                   (acc : acc)

     

       54
       54
       -
                 ->

     

       55
       55
       -
                   List.fold_left

     

       56
       56
       -
                     (fun acc (name, value) -> f Jsont.Meta.none name value acc)

     

       57
       57
       -
                     acc unknown);

     

       58
       58
       -
             }

     

       59
       59
       -
           in

     

       60
       60
       -
           map ~kind:"Unknown members" Jsont.json ~dec_empty ~dec_add ~dec_finish ~enc

     

       61
       61
       -
         in

     

       62
       37
        
         let create_obj url doi cito unknown = create ~url ?doi ?cito ~unknown () in

     

       63
       38
        
         Jsont.Object.map ~kind ~doc create_obj

     

       64
       39
        
         |> Jsont.Object.mem "url" Jsont.string ~enc:url

     

       65
       40
        
         |> Jsont.Object.opt_mem "doi" Jsont.string ~enc:doi

     

       66
       41
        
         |> Jsont.Object.opt_mem "cito" (Jsont.list Cito.jsont) ~enc:cito

     

       67
       67
       -
         |> Jsont.Object.keep_unknown unknown_mems ~enc:unknown

     

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

     

       68
       43
        
         |> Jsont.Object.finish

+3 -3

lib/reference.mli

···

       19
       19
        
       (** {1 Unknown Fields} *)

     

       20
       20
        
       

     

       21
       21
        
       module Unknown : sig

     

       22
       22
       -
         type t = (string * Jsont.json) list

     

       23
       23
       -
         (** Unknown/unrecognized JSON object members. Useful for preserving fields

     

       24
       24
       -
             from custom extensions or future spec versions. *)

     

       22
       22
       +
         type t = Jsont.json

     

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

     

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

     

       25
       25
        
       

     

       26
       26
        
         val empty : t

     

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

+1 -1

lib/rfc3339.ml

···

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

     

       5
       5
        
       

     

       6
       6
        
       let parse s =

     

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

     

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

     

       8
       8
        
       

     

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

     

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

+182

test/test_jsonfeed.ml

···

       370
       370
        
             test_feed_parse_invalid_missing_content );

     

       371
       371
        
         ]

     

       372
       372
        
       

     

       373
       373
       +
       (* Unknown fields preservation tests *)

     

       374
       374
       +
       

     

       375
       375
       +
       let test_author_unknown_roundtrip () =

     

       376
       376
       +
         let json =

     

       377
       377
       +
           {|{

     

       378
       378
       +
           "name": "Test Author",

     

       379
       379
       +
           "custom_field": "custom value",

     

       380
       380
       +
           "another_extension": 42

     

       381
       381
       +
         }|}

     

       382
       382
       +
         in

     

       383
       383
       +
         match Jsont_bytesrw.decode_string' Author.jsont json with

     

       384
       384
       +
         | Error e ->

     

       385
       385
       +
             Alcotest.fail

     

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

     

       387
       387
       +
         | Ok author -> (

     

       388
       388
       +
             (* Check that unknown fields are preserved *)

     

       389
       389
       +
             let unknown = Author.unknown author in

     

       390
       390
       +
             Alcotest.(check bool)

     

       391
       391
       +
               "has unknown fields" false

     

       392
       392
       +
               (Jsonfeed.Unknown.is_empty unknown);

     

       393
       393
       +
             (* Encode and decode again *)

     

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

     

       395
       395
       +
             | Error e ->

     

       396
       396
       +
                 Alcotest.fail

     

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

     

       398
       398
       +
             | Ok json2 -> (

     

       399
       399
       +
                 match Jsont_bytesrw.decode_string' Author.jsont json2 with

     

       400
       400
       +
                 | Error e ->

     

       401
       401
       +
                     Alcotest.fail

     

       402
       402
       +
                       (Printf.sprintf "Re-parse failed: %s" (Jsont.Error.to_string e))

     

       403
       403
       +
                 | Ok author2 ->

     

       404
       404
       +
                     (* Verify unknown fields survive roundtrip *)

     

       405
       405
       +
                     let unknown2 = Author.unknown author2 in

     

       406
       406
       +
                     Alcotest.(check bool)

     

       407
       407
       +
                       "unknown fields preserved" false

     

       408
       408
       +
                       (Jsonfeed.Unknown.is_empty unknown2)))

     

       409
       409
       +
       

     

       410
       410
       +
       let test_item_unknown_roundtrip () =

     

       411
       411
       +
         let json =

     

       412
       412
       +
           {|{

     

       413
       413
       +
           "id": "https://example.com/1",

     

       414
       414
       +
           "content_html": "<p>Test</p>",

     

       415
       415
       +
           "custom_metadata": "some custom data",

     

       416
       416
       +
           "x_custom_number": 123.45

     

       417
       417
       +
         }|}

     

       418
       418
       +
         in

     

       419
       419
       +
         match Jsont_bytesrw.decode_string' Item.jsont json with

     

       420
       420
       +
         | Error e ->

     

       421
       421
       +
             Alcotest.fail

     

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

     

       423
       423
       +
         | Ok item -> (

     

       424
       424
       +
             (* Check that unknown fields are preserved *)

     

       425
       425
       +
             let unknown = Item.unknown item in

     

       426
       426
       +
             Alcotest.(check bool)

     

       427
       427
       +
               "has unknown fields" false

     

       428
       428
       +
               (Jsonfeed.Unknown.is_empty unknown);

     

       429
       429
       +
             (* Encode and decode again *)

     

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

     

       431
       431
       +
             | Error e ->

     

       432
       432
       +
                 Alcotest.fail

     

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

     

       434
       434
       +
             | Ok json2 -> (

     

       435
       435
       +
                 match Jsont_bytesrw.decode_string' Item.jsont json2 with

     

       436
       436
       +
                 | Error e ->

     

       437
       437
       +
                     Alcotest.fail

     

       438
       438
       +
                       (Printf.sprintf "Re-parse failed: %s" (Jsont.Error.to_string e))

     

       439
       439
       +
                 | Ok item2 ->

     

       440
       440
       +
                     let unknown2 = Item.unknown item2 in

     

       441
       441
       +
                     Alcotest.(check bool)

     

       442
       442
       +
                       "unknown fields preserved" false

     

       443
       443
       +
                       (Jsonfeed.Unknown.is_empty unknown2)))

     

       444
       444
       +
       

     

       445
       445
       +
       let test_feed_unknown_roundtrip () =

     

       446
       446
       +
         let json =

     

       447
       447
       +
           {|{

     

       448
       448
       +
           "version": "https://jsonfeed.org/version/1.1",

     

       449
       449
       +
           "title": "Test Feed",

     

       450
       450
       +
           "items": [],

     

       451
       451
       +
           "custom_extension": "custom value",

     

       452
       452
       +
           "x_another_field": {"nested": "data"}

     

       453
       453
       +
         }|}

     

       454
       454
       +
         in

     

       455
       455
       +
         match Jsonfeed.of_string json with

     

       456
       456
       +
         | Error e ->

     

       457
       457
       +
             Alcotest.fail

     

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

     

       459
       459
       +
         | Ok feed -> (

     

       460
       460
       +
             (* Check that unknown fields are preserved *)

     

       461
       461
       +
             let unknown = Jsonfeed.unknown feed in

     

       462
       462
       +
             Alcotest.(check bool)

     

       463
       463
       +
               "has unknown fields" false

     

       464
       464
       +
               (Jsonfeed.Unknown.is_empty unknown);

     

       465
       465
       +
             (* Encode and decode again *)

     

       466
       466
       +
             match Jsonfeed.to_string feed with

     

       467
       467
       +
             | Error e ->

     

       468
       468
       +
                 Alcotest.fail

     

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

     

       470
       470
       +
             | Ok json2 -> (

     

       471
       471
       +
                 match Jsonfeed.of_string json2 with

     

       472
       472
       +
                 | Error e ->

     

       473
       473
       +
                     Alcotest.fail

     

       474
       474
       +
                       (Printf.sprintf "Re-parse failed: %s" (Jsont.Error.to_string e))

     

       475
       475
       +
                 | Ok feed2 ->

     

       476
       476
       +
                     let unknown2 = Jsonfeed.unknown feed2 in

     

       477
       477
       +
                     Alcotest.(check bool)

     

       478
       478
       +
                       "unknown fields preserved" false

     

       479
       479
       +
                       (Jsonfeed.Unknown.is_empty unknown2)))

     

       480
       480
       +
       

     

       481
       481
       +
       let test_hub_unknown_roundtrip () =

     

       482
       482
       +
         let json =

     

       483
       483
       +
           {|{

     

       484
       484
       +
           "type": "WebSub",

     

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

     

       486
       486
       +
           "custom_field": "test"

     

       487
       487
       +
         }|}

     

       488
       488
       +
         in

     

       489
       489
       +
         match Jsont_bytesrw.decode_string' Hub.jsont json with

     

       490
       490
       +
         | Error e ->

     

       491
       491
       +
             Alcotest.fail

     

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

     

       493
       493
       +
         | Ok hub -> (

     

       494
       494
       +
             let unknown = Hub.unknown hub in

     

       495
       495
       +
             Alcotest.(check bool)

     

       496
       496
       +
               "has unknown fields" false

     

       497
       497
       +
               (Jsonfeed.Unknown.is_empty unknown);

     

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

     

       499
       499
       +
             | Error e ->

     

       500
       500
       +
                 Alcotest.fail

     

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

     

       502
       502
       +
             | Ok json2 -> (

     

       503
       503
       +
                 match Jsont_bytesrw.decode_string' Hub.jsont json2 with

     

       504
       504
       +
                 | Error e ->

     

       505
       505
       +
                     Alcotest.fail

     

       506
       506
       +
                       (Printf.sprintf "Re-parse failed: %s" (Jsont.Error.to_string e))

     

       507
       507
       +
                 | Ok hub2 ->

     

       508
       508
       +
                     let unknown2 = Hub.unknown hub2 in

     

       509
       509
       +
                     Alcotest.(check bool)

     

       510
       510
       +
                       "unknown fields preserved" false

     

       511
       511
       +
                       (Jsonfeed.Unknown.is_empty unknown2)))

     

       512
       512
       +
       

     

       513
       513
       +
       let test_attachment_unknown_roundtrip () =

     

       514
       514
       +
         let json =

     

       515
       515
       +
           {|{

     

       516
       516
       +
           "url": "https://example.com/file.mp3",

     

       517
       517
       +
           "mime_type": "audio/mpeg",

     

       518
       518
       +
           "x_custom": "value"

     

       519
       519
       +
         }|}

     

       520
       520
       +
         in

     

       521
       521
       +
         match Jsont_bytesrw.decode_string' Attachment.jsont json with

     

       522
       522
       +
         | Error e ->

     

       523
       523
       +
             Alcotest.fail

     

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

     

       525
       525
       +
         | Ok att -> (

     

       526
       526
       +
             let unknown = Attachment.unknown att in

     

       527
       527
       +
             Alcotest.(check bool)

     

       528
       528
       +
               "has unknown fields" false

     

       529
       529
       +
               (Jsonfeed.Unknown.is_empty unknown);

     

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

     

       531
       531
       +
             | Error e ->

     

       532
       532
       +
                 Alcotest.fail

     

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

     

       534
       534
       +
             | Ok json2 -> (

     

       535
       535
       +
                 match Jsont_bytesrw.decode_string' Attachment.jsont json2 with

     

       536
       536
       +
                 | Error e ->

     

       537
       537
       +
                     Alcotest.fail

     

       538
       538
       +
                       (Printf.sprintf "Re-parse failed: %s" (Jsont.Error.to_string e))

     

       539
       539
       +
                 | Ok att2 ->

     

       540
       540
       +
                     let unknown2 = Attachment.unknown att2 in

     

       541
       541
       +
                     Alcotest.(check bool)

     

       542
       542
       +
                       "unknown fields preserved" false

     

       543
       543
       +
                       (Jsonfeed.Unknown.is_empty unknown2)))

     

       544
       544
       +
       

     

       545
       545
       +
       let unknown_fields_tests =

     

       546
       546
       +
         [

     

       547
       547
       +
           ("author unknown roundtrip", `Quick, test_author_unknown_roundtrip);

     

       548
       548
       +
           ("item unknown roundtrip", `Quick, test_item_unknown_roundtrip);

     

       549
       549
       +
           ("feed unknown roundtrip", `Quick, test_feed_unknown_roundtrip);

     

       550
       550
       +
           ("hub unknown roundtrip", `Quick, test_hub_unknown_roundtrip);

     

       551
       551
       +
           ("attachment unknown roundtrip", `Quick, test_attachment_unknown_roundtrip);

     

       552
       552
       +
         ]

     

       553
       553
       +
       

     

       373
       554
        
       (* Main test suite *)

     

       374
       555
        
       

     

       375
       556
        
       let () =

     
···

       380
       561
        
             ("Hub", hub_tests);

     

       381
       562
        
             ("Item", item_tests);

     

       382
       563
        
             ("Jsonfeed", jsonfeed_tests);

     

       564
       564
       +
             ("Unknown Fields", unknown_fields_tests);

     

       383
       565
        
           ]

Compare changes