comparing 82053e6ecfb6fa363482bfe5f8d647249d2cbafc and main on anil.recoil.org/ocaml-yamlt

+19 -1

.gitignore

···

       1
       1
       -
       _build

     

       1
       1
       +
       # OCaml build artifacts

     

       2
       2
       +
       _build/

     

       3
       3
       +
       *.install

     

       4
       4
       +
       *.merlin

     

       5
       5
       +
       

     

       6
       6
       +
       # Third-party sources (fetch locally with opam source)

     

       7
       7
       +
       third_party/

     

       8
       8
       +
       

     

       9
       9
       +
       # Symlinked dependencies

     

       2
       10
        
       ocaml-yamlrw

     

       11
       11
       +
       

     

       12
       12
       +
       # Editor and OS files

     

       13
       13
       +
       .DS_Store

     

       14
       14
       +
       *.swp

     

       15
       15
       +
       *~

     

       16
       16
       +
       .vscode/

     

       17
       17
       +
       .idea/

     

       18
       18
       +
       

     

       19
       19
       +
       # Opam local switch

     

       20
       20
       +
       _opam/

.ocamlformat

···

       1
       1
       +
       version=0.28.1

+53

.tangled/workflows/build.yml

···

       1
       1
       +
       when:

     

       2
       2
       +
         - event: ["push", "pull_request"]

     

       3
       3
       +
           branch: ["main"]

     

       4
       4
       +
       

     

       5
       5
       +
       engine: nixery

     

       6
       6
       +
       

     

       7
       7
       +
       dependencies:

     

       8
       8
       +
         nixpkgs:

     

       9
       9
       +
           - shell

     

       10
       10
       +
           - stdenv

     

       11
       11
       +
           - findutils

     

       12
       12
       +
           - binutils

     

       13
       13
       +
           - libunwind

     

       14
       14
       +
           - ncurses

     

       15
       15
       +
           - opam

     

       16
       16
       +
           - git

     

       17
       17
       +
           - gawk

     

       18
       18
       +
           - gnupatch

     

       19
       19
       +
           - gnum4

     

       20
       20
       +
           - gnumake

     

       21
       21
       +
           - gnutar

     

       22
       22
       +
           - gnused

     

       23
       23
       +
           - gnugrep

     

       24
       24
       +
           - diffutils

     

       25
       25
       +
           - gzip

     

       26
       26
       +
           - bzip2

     

       27
       27
       +
           - gcc

     

       28
       28
       +
           - ocaml

     

       29
       29
       +
           - pkg-config

     

       30
       30
       +
       

     

       31
       31
       +
       steps:

     

       32
       32
       +
         - name: opam

     

       33
       33
       +
           command: |

     

       34
       34
       +
              opam init --disable-sandboxing -a -y

     

       35
       35
       +
         - name: repo

     

       36
       36
       +
           command: |

     

       37
       37
       +
              opam repo add aoah https://tangled.org/anil.recoil.org/aoah-opam-repo.git

     

       38
       38
       +
         - name: switch

     

       39
       39
       +
           command: |

     

       40
       40
       +
              opam install . --confirm-level=unsafe-yes --deps-only

     

       41
       41
       +
         - name: build

     

       42
       42
       +
           command: |

     

       43
       43
       +
              opam exec -- dune build

     

       44
       44
       +
         - name: switch-test

     

       45
       45
       +
           command: |

     

       46
       46
       +
              opam install . --confirm-level=unsafe-yes --deps-only --with-test

     

       47
       47
       +
         - name: test

     

       48
       48
       +
           command: |

     

       49
       49
       +
              opam exec -- dune runtest --verbose

     

       50
       50
       +
         - name: doc

     

       51
       51
       +
           command: |

     

       52
       52
       +
              opam install -y odoc

     

       53
       53
       +
              opam exec -- dune build @doc

+15

LICENSE.md

···

       1
       1
       +
       ISC License

     

       2
       2
       +
       

     

       3
       3
       +
       Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>

     

       4
       4
       +
       

     

       5
       5
       +
       Permission to use, copy, modify, and distribute this software for any

     

       6
       6
       +
       purpose with or without fee is hereby granted, provided that the above

     

       7
       7
       +
       copyright notice and this permission notice appear in all copies.

     

       8
       8
       +
       

     

       9
       9
       +
       THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

     

       10
       10
       +
       WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

     

       11
       11
       +
       MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

     

       12
       12
       +
       ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

     

       13
       13
       +
       WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

     

       14
       14
       +
       ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

     

       15
       15
       +
       OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+62

README.md

···

       1
       1
       +
       # yamlt - YAML codec using Jsont type descriptions

     

       2
       2
       +
       

     

       3
       3
       +
       Yamlt provides YAML streaming encode/decode that interprets Jsont.t type descriptions, allowing the same codec definitions to work for both JSON and YAML.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Key Features

     

       6
       6
       +
       

     

       7
       7
       +
       - Use the same Jsont.t codec for both JSON and YAML formats

     

       8
       8
       +
       - Streaming encode/decode with configurable depth and node limits

     

       9
       9
       +
       - Support for YAML-specific features (scalars, sequences, mappings)

     

       10
       10
       +
       - Billion laughs protection with configurable limits

     

       11
       11
       +
       - Multiple output formats (block, flow, layout preservation)

     

       12
       12
       +
       

     

       13
       13
       +
       ## Usage

     

       14
       14
       +
       

     

       15
       15
       +
       ```ocaml

     

       16
       16
       +
       (* Define a codec once using Jsont *)

     

       17
       17
       +
       module Config = struct

     

       18
       18
       +
         type t = { name: string; port: int }

     

       19
       19
       +
         let make name port = { name; port }

     

       20
       20
       +
         let jsont =

     

       21
       21
       +
           Jsont.Object.map ~kind:"Config" make

     

       22
       22
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun c -> c.name)

     

       23
       23
       +
           |> Jsont.Object.mem "port" Jsont.int ~enc:(fun c -> c.port)

     

       24
       24
       +
           |> Jsont.Object.finish

     

       25
       25
       +
       end

     

       26
       26
       +
       

     

       27
       27
       +
       (* Use the same codec for both JSON and YAML *)

     

       28
       28
       +
       let from_json = Jsont_bytesrw.decode_string Config.jsont json_str

     

       29
       29
       +
       let from_yaml = Yamlt.decode_string Config.jsont yaml_str

     

       30
       30
       +
       ```

     

       31
       31
       +
       

     

       32
       32
       +
       For encoding:

     

       33
       33
       +
       

     

       34
       34
       +
       ```ocaml

     

       35
       35
       +
       (* Encode to YAML with different formats *)

     

       36
       36
       +
       let config = Config.make "server" 8080

     

       37
       37
       +
       

     

       38
       38
       +
       (* Block style (default) *)

     

       39
       39
       +
       let yaml_block = Yamlt.encode_string Config.jsont config

     

       40
       40
       +
       

     

       41
       41
       +
       (* Flow style (JSON-like) *)

     

       42
       42
       +
       let yaml_flow = Yamlt.encode_string ~format:Flow Config.jsont config

     

       43
       43
       +
       ```

     

       44
       44
       +
       

     

       45
       45
       +
       ## Installation

     

       46
       46
       +
       

     

       47
       47
       +
       ```

     

       48
       48
       +
       opam install yamlt

     

       49
       49
       +
       ```

     

       50
       50
       +
       

     

       51
       51
       +
       ## Documentation

     

       52
       52
       +
       

     

       53
       53
       +
       API documentation is available at https://tangled.org/@anil.recoil.org/ocaml-yamlt or via:

     

       54
       54
       +
       

     

       55
       55
       +
       ```

     

       56
       56
       +
       opam install yamlt

     

       57
       57
       +
       odig doc yamlt

     

       58
       58
       +
       ```

     

       59
       59
       +
       

     

       60
       60
       +
       ## License

     

       61
       61
       +
       

     

       62
       62
       +
       ISC

dune

···

       1
       1
       +
       ; Root dune file

     

       2
       2
       +
       

     

       3
       3
       +
       ; Ignore third_party directory (for fetched dependency sources)

     

       4
       4
       +
       

     

       5
       5
       +
       (data_only_dirs third_party)

+10 -1

dune-project

···

       1
       1
        
       (lang dune 3.18)

     

       2
       2
       +
       

     

       2
       3
        
       (name yamlt)

     

       3
       4
        
       

     

       4
       5
        
       (generate_opam_files true)

     

       5
       6
        
       

     

       7
       7
       +
       (license ISC)

     

       8
       8
       +
       (authors "Anil Madhavapeddy")

     

       9
       9
       +
       (homepage "https://tangled.org/@anil.recoil.org/ocaml-yamlt")

     

       10
       10
       +
       (maintainers "Anil Madhavapeddy <anil@recoil.org>")

     

       11
       11
       +
       (bug_reports "https://tangled.org/@anil.recoil.org/ocaml-yamlt/issues")

     

       12
       12
       +
       (maintenance_intent "(latest)")

     

       13
       13
       +
       

     

       6
       14
        
       (package

     

       7
       15
        
        (name yamlt)

     

       8
       16
        
        (synopsis "YAML codec using Jsont type descriptions")

     
···

       11
       19
        
         (ocaml (>= 4.14.0))

     

       12
       20
        
         yamlrw

     

       13
       21
        
         jsont

     

       14
       14
       -
         bytesrw))

     

       22
       22
       +
         bytesrw

     

       23
       23
       +
         (odoc :with-doc)))

+549 -450

lib/yamlt.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
       -
       open Bytesrw

     

       7
       6
        
       open Jsont.Repr

     

       8
       7
        
       open Yamlrw

     

       9
       8
        
       

     
···

       26
       25
        
         meta_none : Jsont.Meta.t;

     

       27
       26
        
       }

     

       28
       27
        
       

     

       29
       29
       -
       let make_decoder

     

       30
       30
       -
           ?(locs = false) ?(layout = false) ?(file = "-")

     

       28
       28
       +
       let make_decoder ?(locs = false) ?(layout = false) ?(file = "-")

     

       31
       29
        
           ?(max_depth = 100) ?(max_nodes = 10_000_000) parser =

     

       32
       30
        
         let meta_none = Jsont.Meta.make (Jsont.Textloc.(set_file none) file) in

     

       33
       33
       -
         { parser; file; locs; _layout = layout; max_depth; max_nodes;

     

       34
       34
       -
           node_count = 0; current = None;

     

       35
       35
       -
           _anchors = Hashtbl.create 16; meta_none }

     

       31
       31
       +
         {

     

       32
       32
       +
           parser;

     

       33
       33
       +
           file;

     

       34
       34
       +
           locs;

     

       35
       35
       +
           _layout = layout;

     

       36
       36
       +
           max_depth;

     

       37
       37
       +
           max_nodes;

     

       38
       38
       +
           node_count = 0;

     

       39
       39
       +
           current = None;

     

       40
       40
       +
           _anchors = Hashtbl.create 16;

     

       41
       41
       +
           meta_none;

     

       42
       42
       +
         }

     

       36
       43
        
       

     

       37
       44
        
       (* Decoder helpers *)

     

       38
       45
        
       

     

       46
       46
       +
       (* Local helper to reduce Jsont.Error.msgf boilerplate *)

     

       47
       47
       +
       let err_msg meta fmt = Jsont.Error.msgf meta fmt

     

       48
       48
       +
       let err_msg_none fmt = Jsont.Error.msgf Jsont.Meta.none fmt

     

       49
       49
       +
       

     

       39
       50
        
       let check_depth d ~nest =

     

       40
       51
        
         if nest > d.max_depth then

     

       41
       41
       -
           Jsont.Error.msgf Jsont.Meta.none "Maximum nesting depth %d exceeded" d.max_depth

     

       52
       52
       +
           err_msg_none "Maximum nesting depth %d exceeded" d.max_depth

     

       42
       53
        
       

     

       43
       54
        
       let check_nodes d =

     

       44
       55
        
         d.node_count <- d.node_count + 1;

     

       45
       56
        
         if d.node_count > d.max_nodes then

     

       46
       46
       -
           Jsont.Error.msgf Jsont.Meta.none "Maximum node count %d exceeded" d.max_nodes

     

       57
       57
       +
           err_msg_none "Maximum node count %d exceeded" d.max_nodes

     

       47
       58
        
       

     

       48
       59
        
       let meta_of_span d span =

     

       49
       49
       -
         if not d.locs then d.meta_none else

     

       50
       50
       -
         let start = span.Span.start and stop = span.Span.stop in

     

       51
       51
       -
         let first_byte = start.Position.index in

     

       52
       52
       -
         let last_byte = max first_byte (stop.Position.index - 1) in

     

       53
       53
       -
         (* line_pos is (line_number, byte_position_of_line_start) *)

     

       54
       54
       -
         let first_line = (start.Position.line, start.Position.index - start.Position.column + 1) in

     

       55
       55
       -
         let last_line = (stop.Position.line, stop.Position.index - stop.Position.column + 1) in

     

       56
       56
       -
         let textloc = Jsont.Textloc.make ~file:d.file

     

       57
       57
       -
             ~first_byte ~last_byte ~first_line ~last_line in

     

       58
       58
       -
         Jsont.Meta.make textloc

     

       60
       60
       +
         if not d.locs then d.meta_none

     

       61
       61
       +
         else

     

       62
       62
       +
           let start = span.Span.start and stop = span.Span.stop in

     

       63
       63
       +
           let first_byte = start.Position.index in

     

       64
       64
       +
           let last_byte = max first_byte (stop.Position.index - 1) in

     

       65
       65
       +
           (* line_pos is (line_number, byte_position_of_line_start) *)

     

       66
       66
       +
           let first_line =

     

       67
       67
       +
             (start.Position.line, start.Position.index - start.Position.column + 1)

     

       68
       68
       +
           in

     

       69
       69
       +
           (* Handle case where stop is at the start of a new line (column 1)

     

       70
       70
       +
              This happens when the span includes a trailing newline.

     

       71
       71
       +
              The last_byte is on the previous line, so we need to calculate

     

       72
       72
       +
              the line start position based on last_byte, not stop. *)

     

       73
       73
       +
           let last_line =

     

       74
       74
       +
             if stop.Position.column = 1 && stop.Position.line > start.Position.line then

     

       75
       75
       +
               (* last_byte is on the previous line (stop.line - 1)

     

       76
       76
       +
                  We need to estimate where that line starts. Since we don't have

     

       77
       77
       +
                  the full text, we can't calculate it exactly, but we can use:

     

       78
       78
       +
                  last_byte - (estimated_column - 1)

     

       79
       79
       +
                  For now, we'll use the same line as start if they're close,

     

       80
       80
       +
                  or just report it as the previous line. *)

     

       81
       81
       +
               let last_line_num = stop.Position.line - 1 in

     

       82
       82
       +
               (* Estimate: assume last_byte is somewhere on the previous line.

     

       83
       83
       +
                  We'll use the byte position minus a reasonable offset.

     

       84
       84
       +
                  This is approximate but better than wrapping to the next line. *)

     

       85
       85
       +
               if last_line_num = start.Position.line then

     

       86
       86
       +
                 (* Same line as start - use start's line position *)

     

       87
       87
       +
                 first_line

     

       88
       88
       +
               else

     

       89
       89
       +
                 (* Different line - estimate line start as last_byte minus some offset

     

       90
       90
       +
                    Since we subtracted 1 from stop.index to get last_byte, and stop.column was 1,

     

       91
       91
       +
                    last_byte should be the newline character on the previous line.

     

       92
       92
       +
                    The line likely started much earlier, but we'll estimate conservatively. *)

     

       93
       93
       +
                 (last_line_num, last_byte)

     

       94
       94
       +
             else

     

       95
       95
       +
               (stop.Position.line, stop.Position.index - stop.Position.column + 1)

     

       96
       96
       +
           in

     

       97
       97
       +
           let textloc =

     

       98
       98
       +
             Jsont.Textloc.make ~file:d.file ~first_byte ~last_byte ~first_line

     

       99
       99
       +
               ~last_line

     

       100
       100
       +
           in

     

       101
       101
       +
           Jsont.Meta.make textloc

     

       59
       102
        
       

     

       60
       103
        
       let next_event d =

     

       61
       104
        
         d.current <- Parser.next d.parser;

     

       62
       105
        
         d.current

     

       63
       106
        
       

     

       64
       107
        
       let peek_event d =

     

       65
       65
       -
         match d.current with

     

       66
       66
       -
         | Some _ -> d.current

     

       67
       67
       -
         | None -> next_event d

     

       108
       108
       +
         match d.current with Some _ -> d.current | None -> next_event d

     

       68
       109
        
       

     

       69
       69
       -
       let skip_event d =

     

       70
       70
       -
         d.current <- None

     

       110
       110
       +
       let skip_event d = d.current <- None

     

       71
       111
        
       

     

       72
       112
        
       let _expect_event d pred name =

     

       73
       113
        
         match peek_event d with

     

       74
       74
       -
         | Some ev when pred ev.Event.event -> skip_event d; ev

     

       114
       114
       +
         | Some ev when pred ev.Event.event ->

     

       115
       115
       +
             skip_event d;

     

       116
       116
       +
             ev

     

       75
       117
        
         | Some ev ->

     

       76
       118
        
             let span = ev.Event.span in

     

       77
       119
        
             let meta = meta_of_span d span in

     

       78
       78
       -
             Jsont.Error.msgf meta "Expected %s but found %a" name Event.pp ev.Event.event

     

       79
       79
       -
         | None ->

     

       80
       80
       -
             Jsont.Error.msgf Jsont.Meta.none "Expected %s but reached end of stream" name

     

       120
       120
       +
             err_msg meta "Expected %s but found %a" name Event.pp ev.Event.event

     

       121
       121
       +
         | None -> err_msg_none "Expected %s but reached end of stream" name

     

       81
       122
        
       

     

       82
       123
        
       (* Error helpers *)

     

       83
       124
        
       

     

       84
       125
        
       let _err_expected_scalar d ev =

     

       85
       126
        
         let meta = meta_of_span d ev.Event.span in

     

       86
       86
       -
         Jsont.Error.msgf meta "Expected scalar but found %a" Event.pp ev.Event.event

     

       127
       127
       +
         err_msg meta "Expected scalar but found %a" Event.pp ev.Event.event

     

       87
       128
        
       

     

       88
       129
        
       let err_type_mismatch d span t ~fnd =

     

       130
       130
       +
         let open Jsont.Repr in

     

       89
       131
        
         let meta = meta_of_span d span in

     

       90
       90
       -
         Jsont.Error.msgf meta "Expected %s but found %s"

     

       91
       91
       -
           (Jsont.Repr.kinded_sort t) fnd

     

       132
       132
       +
         err_msg meta "Expected %s but found %s" (kinded_sort t) fnd

     

       92
       133
        
       

     

       93
       134
        
       (* YAML scalar resolution *)

     

       94
       135
        
       

     

       95
       136
        
       let is_null_scalar s =

     

       96
       96
       -
         s = "" || s = "~" ||

     

       97
       97
       -
         s = "null" || s = "Null" || s = "NULL"

     

       137
       137
       +
         s = "" || s = "~" || s = "null" || s = "Null" || s = "NULL"

     

       98
       138
        
       

     

       99
       139
        
       let bool_of_scalar_opt s =

     

       100
       140
        
         match s with

     

       101
       101
       -
         | "true" | "True" | "TRUE"

     

       102
       102
       -
         | "yes" | "Yes" | "YES"

     

       103
       103
       -
         | "on" | "On" | "ON" -> Some true

     

       104
       104
       -
         | "false" | "False" | "FALSE"

     

       105
       105
       -
         | "no" | "No" | "NO"

     

       106
       106
       -
         | "off" | "Off" | "OFF" -> Some false

     

       141
       141
       +
         | "true" | "True" | "TRUE" | "yes" | "Yes" | "YES" | "on" | "On" | "ON" ->

     

       142
       142
       +
             Some true

     

       143
       143
       +
         | "false" | "False" | "FALSE" | "no" | "No" | "NO" | "off" | "Off" | "OFF" ->

     

       144
       144
       +
             Some false

     

       107
       145
        
         | _ -> None

     

       108
       146
        
       

     

       109
       147
        
       let float_of_scalar_opt s =

     
···

       113
       151
        
         | "+.inf" | "+.Inf" | "+.INF" -> Some Float.infinity

     

       114
       152
        
         | "-.inf" | "-.Inf" | "-.INF" -> Some Float.neg_infinity

     

       115
       153
        
         | ".nan" | ".NaN" | ".NAN" -> Some Float.nan

     

       116
       116
       -
         | _ ->

     

       154
       154
       +
         | _ -> (

     

       117
       155
        
             (* Try parsing as number, allowing underscores *)

     

       118
       156
        
             let s' = String.concat "" (String.split_on_char '_' s) in

     

       119
       157
        
             (* Try int first (supports 0o, 0x, 0b) then float *)

     

       120
       158
        
             match int_of_string_opt s' with

     

       121
       159
        
             | Some i -> Some (float_of_int i)

     

       122
       122
       -
             | None -> float_of_string_opt s'

     

       160
       160
       +
             | None -> float_of_string_opt s')

     

       123
       161
        
       

     

       124
       162
        
       let _int_of_scalar_opt s =

     

       125
       163
        
         (* Handle hex, octal, and regular integers with underscores *)

     
···

       127
       165
        
         int_of_string_opt s'

     

       128
       166
        
       

     

       129
       167
        
       (* Decode a scalar value according to expected type *)

     

       130
       130
       -
       let rec decode_scalar_as :

     

       131
       131
       -
         type a. decoder -> Event.spanned -> string -> Scalar_style.t -> a t -> a =

     

       132
       132
       -
         fun d ev value style t ->

     

       168
       168
       +
       let rec decode_scalar_as : type a.

     

       169
       169
       +
           decoder -> Event.spanned -> string -> Scalar_style.t -> a t -> a =

     

       170
       170
       +
        fun d ev value style t ->

     

       133
       171
        
         check_nodes d;

     

       134
       172
        
         let meta = meta_of_span d ev.Event.span in

     

       135
       173
        
         match t with

     

       136
       174
        
         | Null map ->

     

       137
       175
        
             if is_null_scalar value then map.dec meta ()

     

       138
       176
        
             else err_type_mismatch d ev.span t ~fnd:("scalar " ^ value)

     

       139
       139
       -
         | Bool map ->

     

       140
       140
       -
             (match bool_of_scalar_opt value with

     

       141
       141
       -
              | Some b -> map.dec meta b

     

       142
       142
       -
              | None ->

     

       143
       143
       -
                  (* For explicitly quoted strings, fail *)

     

       144
       144
       -
                  if style <> `Plain then

     

       145
       145
       -
                    err_type_mismatch d ev.span t ~fnd:("string " ^ value)

     

       146
       146
       -
                  else

     

       147
       147
       -
                    err_type_mismatch d ev.span t ~fnd:("scalar " ^ value))

     

       148
       148
       -
         | Number map ->

     

       149
       149
       -
             (* Handle null -> nan mapping like jsont *)

     

       150
       150
       -
             if is_null_scalar value then map.dec meta Float.nan

     

       177
       177
       +
         | Bool map -> (

     

       178
       178
       +
             match bool_of_scalar_opt value with

     

       179
       179
       +
             | Some b -> map.dec meta b

     

       180
       180
       +
             | None ->

     

       181
       181
       +
                 (* For explicitly quoted strings, fail *)

     

       182
       182
       +
                 if style <> `Plain then

     

       183
       183
       +
                   err_type_mismatch d ev.span t ~fnd:("string " ^ value)

     

       184
       184
       +
                 else err_type_mismatch d ev.span t ~fnd:("scalar " ^ value))

     

       185
       185
       +
         | Number map -> (

     

       186
       186
       +
             if

     

       187
       187
       +
               (* Handle null -> nan mapping like jsont *)

     

       188
       188
       +
               is_null_scalar value

     

       189
       189
       +
             then map.dec meta Float.nan

     

       151
       190
        
             else

     

       152
       152
       -
               (match float_of_scalar_opt value with

     

       153
       153
       -
                | Some f -> map.dec meta f

     

       154
       154
       -
                | None -> err_type_mismatch d ev.span t ~fnd:("scalar " ^ value))

     

       191
       191
       +
               match float_of_scalar_opt value with

     

       192
       192
       +
               | Some f -> map.dec meta f

     

       193
       193
       +
               | None -> err_type_mismatch d ev.span t ~fnd:("scalar " ^ value))

     

       155
       194
        
         | String map ->

     

       156
       195
        
             (* Don't decode null values as strings - they should fail so outer combinators

     

       157
       157
       -
                like 'option' or 'any' can handle them properly *)

     

       158
       158
       -
             if is_null_scalar value then

     

       196
       196
       +
                like 'option' or 'any' can handle them properly.

     

       197
       197
       +
                BUT: quoted strings should always be treated as strings, even if they

     

       198
       198
       +
                look like null (e.g., "" or "null") *)

     

       199
       199
       +
             if style = `Plain && is_null_scalar value then

     

       159
       200
        
               err_type_mismatch d ev.span t ~fnd:"null"

     

       160
       201
        
             else

     

       161
       161
       -
               (* Strings accept any non-null scalar value *)

     

       202
       202
       +
               (* Strings accept quoted scalars or non-null plain scalars *)

     

       162
       203
        
               map.dec meta value

     

       204
       204
       +
         | Array map ->

     

       205
       205
       +
             (* Treat null as an empty array for convenience *)

     

       206
       206
       +
             if is_null_scalar value then

     

       207
       207
       +
               let end_meta = meta_of_span d ev.Event.span in

     

       208
       208
       +
               map.dec_finish end_meta 0 (map.dec_empty ())

     

       209
       209
       +
             else

     

       210
       210
       +
               err_type_mismatch d ev.span t ~fnd:"scalar"

     

       211
       211
       +
         | Object map ->

     

       212
       212
       +
             (* Treat null as an empty object for convenience *)

     

       213
       213
       +
             if is_null_scalar value then

     

       214
       214
       +
               (* Build a dict with all default values from absent members *)

     

       215
       215
       +
               let add_default _ (Mem_dec mem_map) dict =

     

       216
       216
       +
                 match mem_map.dec_absent with

     

       217
       217
       +
                 | Some v -> Dict.add mem_map.id v dict

     

       218
       218
       +
                 | None ->

     

       219
       219
       +
                     (* Required field without default - error *)

     

       220
       220
       +
                     let exp = String_map.singleton mem_map.name (Mem_dec mem_map) in

     

       221
       221
       +
                     missing_mems_error meta map ~exp ~fnd:[]

     

       222
       222
       +
               in

     

       223
       223
       +
               let dict = String_map.fold add_default map.mem_decs Dict.empty in

     

       224
       224
       +
               let dict = Dict.add object_meta_arg meta dict in

     

       225
       225
       +
               apply_dict map.dec dict

     

       226
       226
       +
             else

     

       227
       227
       +
               err_type_mismatch d ev.span t ~fnd:"scalar"

     

       163
       228
        
         | Map m ->

     

       164
       229
        
             (* Handle Map combinators (e.g., from Jsont.option) *)

     

       165
       230
        
             m.dec (decode_scalar_as d ev value style m.dom)

     

       166
       231
        
         | Rec lazy_t ->

     

       167
       232
        
             (* Handle recursive types *)

     

       168
       233
        
             decode_scalar_as d ev value style (Lazy.force lazy_t)

     

       169
       169
       -
         | _ ->

     

       170
       170
       -
             err_type_mismatch d ev.span t ~fnd:"scalar"

     

       234
       234
       +
         | _ -> err_type_mismatch d ev.span t ~fnd:"scalar"

     

       171
       235
        
       

     

       172
       236
        
       (* Forward declaration for mutual recursion *)

     

       173
       237
        
       let rec decode : type a. decoder -> nest:int -> a t -> a =

     

       174
       174
       -
         fun d ~nest t ->

     

       238
       238
       +
        fun d ~nest t ->

     

       175
       239
        
         check_depth d ~nest;

     

       176
       240
        
         match peek_event d with

     

       177
       177
       -
         | None -> Jsont.Error.msgf Jsont.Meta.none "Unexpected end of YAML stream"

     

       178
       178
       -
         | Some ev ->

     

       179
       179
       -
             match ev.Event.event, t with

     

       241
       241
       +
         | None -> err_msg_none "Unexpected end of YAML stream"

     

       242
       242
       +
         | Some ev -> (

     

       243
       243
       +
             match (ev.Event.event, t) with

     

       180
       244
        
             (* Scalar events *)

     

       181
       245
        
             | Event.Scalar { value; style; anchor; _ }, _ ->

     

       182
       246
        
                 skip_event d;

     

       183
       247
        
                 let result = decode_scalar d ~nest ev value style t in

     

       184
       248
        
                 (* Store anchor if present - TODO: implement anchor storage *)

     

       185
       249
        
                 (match anchor with

     

       186
       186
       -
                  | Some _name ->

     

       187
       187
       -
                      (* We need generic JSON for anchors - decode as json and convert back *)

     

       188
       188
       -
                      ()

     

       189
       189
       -
                  | None -> ());

     

       250
       250
       +
                 | Some _name ->

     

       251
       251
       +
                     (* We need generic JSON for anchors - decode as json and convert back *)

     

       252
       252
       +
                     ()

     

       253
       253
       +
                 | None -> ());

     

       190
       254
        
                 result

     

       191
       191
       -
       

     

       192
       255
        
             (* Alias *)

     

       193
       256
        
             | Event.Alias { anchor }, _ ->

     

       194
       257
        
                 skip_event d;

     

       195
       258
        
                 decode_alias d ev anchor t

     

       196
       196
       -
       

     

       197
       259
        
             (* Map combinator - must come before specific event matches *)

     

       198
       198
       -
             | _, Map m ->

     

       199
       199
       -
                 m.dec (decode d ~nest m.dom)

     

       200
       200
       -
       

     

       260
       260
       +
             | _, Map m -> m.dec (decode d ~nest m.dom)

     

       201
       261
        
             (* Recursive types - must come before specific event matches *)

     

       202
       202
       -
             | _, Rec lazy_t ->

     

       203
       203
       -
                 decode d ~nest (Lazy.force lazy_t)

     

       204
       204
       -
       

     

       262
       262
       +
             | _, Rec lazy_t -> decode d ~nest (Lazy.force lazy_t)

     

       205
       263
        
             (* Sequence -> Array *)

     

       206
       206
       -
             | Event.Sequence_start _, Array map ->

     

       207
       207
       -
                 decode_array d ~nest ev map

     

       208
       208
       -
       

     

       209
       209
       -
             | Event.Sequence_start _, Any map ->

     

       210
       210
       -
                 decode_any_sequence d ~nest ev t map

     

       211
       211
       -
       

     

       264
       264
       +
             | Event.Sequence_start _, Array map -> decode_array d ~nest ev map

     

       265
       265
       +
             | Event.Sequence_start _, Any map -> decode_any_sequence d ~nest ev t map

     

       212
       266
        
             | Event.Sequence_start _, _ ->

     

       213
       267
        
                 err_type_mismatch d ev.span t ~fnd:"sequence"

     

       214
       214
       -
       

     

       215
       268
        
             (* Mapping -> Object *)

     

       216
       216
       -
             | Event.Mapping_start _, Object map ->

     

       217
       217
       -
                 decode_object d ~nest ev map

     

       218
       218
       -
       

     

       219
       219
       -
             | Event.Mapping_start _, Any map ->

     

       220
       220
       -
                 decode_any_mapping d ~nest ev t map

     

       221
       221
       -
       

     

       222
       222
       -
             | Event.Mapping_start _, _ ->

     

       223
       223
       -
                 err_type_mismatch d ev.span t ~fnd:"mapping"

     

       224
       224
       -
       

     

       269
       269
       +
             | Event.Mapping_start _, Object map -> decode_object d ~nest ev map

     

       270
       270
       +
             | Event.Mapping_start _, Any map -> decode_any_mapping d ~nest ev t map

     

       271
       271
       +
             | Event.Mapping_start _, _ -> err_type_mismatch d ev.span t ~fnd:"mapping"

     

       225
       272
        
             (* Unexpected events *)

     

       226
       273
        
             | Event.Sequence_end, _ ->

     

       227
       227
       -
                 Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected sequence end"

     

       274
       274
       +
                 err_msg (meta_of_span d ev.span) "Unexpected sequence end"

     

       228
       275
        
             | Event.Mapping_end, _ ->

     

       229
       229
       -
                 Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected mapping end"

     

       276
       276
       +
                 err_msg (meta_of_span d ev.span) "Unexpected mapping end"

     

       230
       277
        
             | Event.Document_start _, _ ->

     

       231
       231
       -
                 Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected document start"

     

       278
       278
       +
                 err_msg (meta_of_span d ev.span) "Unexpected document start"

     

       232
       279
        
             | Event.Document_end _, _ ->

     

       233
       233
       -
                 Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected document end"

     

       280
       280
       +
                 err_msg (meta_of_span d ev.span) "Unexpected document end"

     

       234
       281
        
             | Event.Stream_start _, _ ->

     

       235
       235
       -
                 Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected stream start"

     

       282
       282
       +
                 err_msg (meta_of_span d ev.span) "Unexpected stream start"

     

       236
       283
        
             | Event.Stream_end, _ ->

     

       237
       237
       -
                 Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected stream end"

     

       284
       284
       +
                 err_msg (meta_of_span d ev.span) "Unexpected stream end")

     

       238
       285
        
       

     

       239
       239
       -
       and decode_scalar : type a. decoder -> nest:int -> Event.spanned -> string -> Scalar_style.t -> a t -> a =

     

       240
       240
       -
         fun d ~nest ev value style t ->

     

       286
       286
       +
       and decode_scalar : type a.

     

       287
       287
       +
           decoder -> nest:int -> Event.spanned -> string -> Scalar_style.t -> a t -> a

     

       288
       288
       +
           =

     

       289
       289
       +
        fun d ~nest ev value style t ->

     

       241
       290
        
         match t with

     

       242
       291
        
         | Any map -> decode_any_scalar d ev value style t map

     

       243
       292
        
         | Map m -> m.dec (decode_scalar d ~nest ev value style m.dom)

     

       244
       293
        
         | Rec lazy_t -> decode_scalar d ~nest ev value style (Lazy.force lazy_t)

     

       245
       294
        
         | _ -> decode_scalar_as d ev value style t

     

       246
       295
        
       

     

       247
       247
       -
       and decode_any_scalar : type a. decoder -> Event.spanned -> string -> Scalar_style.t -> a t -> a any_map -> a =

     

       248
       248
       -
         fun d ev value style t map ->

     

       296
       296
       +
       and decode_any_scalar : type a.

     

       297
       297
       +
           decoder ->

     

       298
       298
       +
           Event.spanned ->

     

       299
       299
       +
           string ->

     

       300
       300
       +
           Scalar_style.t ->

     

       301
       301
       +
           a t ->

     

       302
       302
       +
           a any_map ->

     

       303
       303
       +
           a =

     

       304
       304
       +
        fun d ev value style t map ->

     

       249
       305
        
         check_nodes d;

     

       306
       306
       +
         let meta = meta_of_span d ev.span in

     

       307
       307
       +
         let type_err fnd = Jsont.Repr.type_error meta t ~fnd in

     

       250
       308
        
         (* Determine which decoder to use based on scalar content *)

     

       251
       309
        
         if is_null_scalar value then

     

       252
       310
        
           match map.dec_null with

     

       253
       311
        
           | Some t' -> decode_scalar_as d ev value style t'

     

       254
       254
       -
           | None -> Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Null

     

       312
       312
       +
           | None -> type_err Jsont.Sort.Null

     

       255
       313
        
         else if style = `Plain then

     

       256
       314
        
           (* Try bool, then number, then string *)

     

       257
       315
        
           match bool_of_scalar_opt value with

     

       258
       258
       -
           | Some _ ->

     

       259
       259
       -
               (match map.dec_bool with

     

       260
       260
       -
                | Some t' -> decode_scalar_as d ev value style t'

     

       261
       261
       -
                | None ->

     

       262
       262
       -
                    match map.dec_string with

     

       263
       263
       -
                    | Some t' -> decode_scalar_as d ev value style t'

     

       264
       264
       -
                    | None -> Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Bool)

     

       265
       265
       -
           | None ->

     

       316
       316
       +
           | Some _ -> (

     

       317
       317
       +
               match map.dec_bool with

     

       318
       318
       +
               | Some t' -> decode_scalar_as d ev value style t'

     

       319
       319
       +
               | None -> (

     

       320
       320
       +
                   match map.dec_string with

     

       321
       321
       +
                   | Some t' -> decode_scalar_as d ev value style t'

     

       322
       322
       +
                   | None -> type_err Jsont.Sort.Bool))

     

       323
       323
       +
           | None -> (

     

       266
       324
        
               match float_of_scalar_opt value with

     

       267
       267
       -
               | Some _ ->

     

       268
       268
       -
                   (match map.dec_number with

     

       269
       269
       -
                    | Some t' -> decode_scalar_as d ev value style t'

     

       270
       270
       -
                    | None ->

     

       271
       271
       -
                        match map.dec_string with

     

       272
       272
       -
                        | Some t' -> decode_scalar_as d ev value style t'

     

       273
       273
       -
                        | None -> Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Number)

     

       274
       274
       -
               | None ->

     

       325
       325
       +
               | Some _ -> (

     

       326
       326
       +
                   match map.dec_number with

     

       327
       327
       +
                   | Some t' -> decode_scalar_as d ev value style t'

     

       328
       328
       +
                   | None -> (

     

       329
       329
       +
                       match map.dec_string with

     

       330
       330
       +
                       | Some t' -> decode_scalar_as d ev value style t'

     

       331
       331
       +
                       | None -> type_err Jsont.Sort.Number))

     

       332
       332
       +
               | None -> (

     

       275
       333
        
                   (* Plain scalar that's not bool/number -> string *)

     

       276
       334
        
                   match map.dec_string with

     

       277
       335
        
                   | Some t' -> decode_scalar_as d ev value style t'

     

       278
       278
       -
                   | None -> Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.String

     

       336
       336
       +
                   | None -> type_err Jsont.Sort.String))

     

       279
       337
        
         else

     

       280
       338
        
           (* Quoted scalars are strings *)

     

       281
       339
        
           match map.dec_string with

     

       282
       340
        
           | Some t' -> decode_scalar_as d ev value style t'

     

       283
       283
       -
           | None -> Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.String

     

       341
       341
       +
           | None -> type_err Jsont.Sort.String

     

       284
       342
        
       

     

       285
       343
        
       and decode_alias : type a. decoder -> Event.spanned -> string -> a t -> a =

     

       286
       286
       -
         fun d ev anchor t ->

     

       344
       344
       +
        fun d ev anchor t ->

     

       287
       345
        
         check_nodes d;

     

       288
       346
        
         match Hashtbl.find_opt d._anchors anchor with

     

       289
       347
        
         | None ->

     

       290
       348
        
             let meta = meta_of_span d ev.span in

     

       291
       291
       -
             Jsont.Error.msgf meta "Unknown anchor: %s" anchor

     

       292
       292
       -
         | Some json ->

     

       349
       349
       +
             err_msg meta "Unknown anchor: %s" anchor

     

       350
       350
       +
         | Some json_value ->

     

       293
       351
        
             (* Decode the stored JSON value through the type *)

     

       294
       352
        
             let t' = Jsont.Repr.unsafe_to_t t in

     

       295
       295
       -
             match Jsont.Json.decode' t' json with

     

       353
       353
       +
             match Jsont.Json.decode' t' json_value with

     

       296
       354
        
             | Ok v -> v

     

       297
       355
        
             | Error e -> raise (Jsont.Error e)

     

       298
       356
        
       

     

       299
       299
       -
       and decode_array : type a elt b. decoder -> nest:int -> Event.spanned -> (a, elt, b) array_map -> a =

     

       300
       300
       -
         fun d ~nest start_ev map ->

     

       301
       301
       -
         skip_event d; (* consume Sequence_start *)

     

       357
       357
       +
       and decode_array : type a elt b.

     

       358
       358
       +
           decoder -> nest:int -> Event.spanned -> (a, elt, b) array_map -> a =

     

       359
       359
       +
        fun d ~nest start_ev array_map ->

     

       360
       360
       +
         skip_event d;

     

       361
       361
       +
         (* consume Sequence_start *)

     

       302
       362
        
         check_nodes d;

     

       303
       363
        
         let meta = meta_of_span d start_ev.span in

     

       304
       304
       -
         let builder = ref (map.dec_empty ()) in

     

       364
       364
       +
         let builder = ref (array_map.dec_empty ()) in

     

       305
       365
        
         let idx = ref 0 in

     

       306
       366
        
         let rec loop () =

     

       307
       367
        
           match peek_event d with

     

       308
       368
        
           | Some { Event.event = Event.Sequence_end; span } ->

     

       309
       369
        
               skip_event d;

     

       310
       370
        
               let end_meta = meta_of_span d span in

     

       311
       311
       -
               map.dec_finish end_meta !idx !builder

     

       371
       371
       +
               array_map.dec_finish end_meta !idx !builder

     

       312
       372
        
           | Some _ ->

     

       313
       373
        
               let i = !idx in

     

       314
       374
        
               (try

     

       315
       315
       -
                  if map.dec_skip i !builder then begin

     

       375
       375
       +
                  if array_map.dec_skip i !builder then begin

     

       316
       376
        
                    (* Skip this element by decoding as ignore *)

     

       317
       317
       -
                    let _ : unit = decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.ignore) in

     

       377
       377
       +
                    let _ : unit =

     

       378
       378
       +
                      decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.ignore)

     

       379
       379
       +
                    in

     

       318
       380
        
                    ()

     

       319
       319
       -
                  end else begin

     

       320
       320
       -
                    let elt = decode d ~nest:(nest + 1) map.elt in

     

       321
       321
       -
                    builder := map.dec_add i elt !builder

     

       381
       381
       +
                  end

     

       382
       382
       +
                  else begin

     

       383
       383
       +
                    let elt = decode d ~nest:(nest + 1) array_map.elt in

     

       384
       384
       +
                    builder := array_map.dec_add i elt !builder

     

       322
       385
        
                  end

     

       323
       386
        
                with Jsont.Error e ->

     

       324
       324
       -
                  let imeta = Jsont.Meta.none in

     

       325
       325
       -
                  Jsont.Repr.error_push_array meta map (i, imeta) e);

     

       387
       387
       +
                  Jsont.Repr.error_push_array meta array_map (i, Jsont.Meta.none) e);

     

       326
       388
        
               incr idx;

     

       327
       389
        
               loop ()

     

       328
       328
       -
           | None ->

     

       329
       329
       -
               Jsont.Error.msgf meta "Unclosed sequence"

     

       390
       390
       +
           | None -> err_msg meta "Unclosed sequence"

     

       330
       391
        
         in

     

       331
       392
        
         loop ()

     

       332
       393
        
       

     

       333
       333
       -
       and decode_any_sequence : type a. decoder -> nest:int -> Event.spanned -> a t -> a any_map -> a =

     

       334
       334
       -
         fun d ~nest ev t map ->

     

       394
       394
       +
       and decode_any_sequence : type a.

     

       395
       395
       +
           decoder -> nest:int -> Event.spanned -> a t -> a any_map -> a =

     

       396
       396
       +
        fun d ~nest ev t map ->

     

       335
       397
        
         match map.dec_array with

     

       336
       336
       -
         | Some t' ->

     

       398
       398
       +
         | Some t' -> (

     

       337
       399
        
             (* The t' decoder might be wrapped (e.g., Map for option types)

     

       338
       400
        
                Directly decode the array and let the wrapper handle it *)

     

       339
       339
       -
             (match t' with

     

       340
       340
       -
              | Array array_map ->

     

       341
       341
       -
                  decode_array d ~nest ev array_map

     

       342
       342
       -
              | _ ->

     

       343
       343
       -
                  (* For wrapped types like Map (Array ...), use full decode *)

     

       344
       344
       -
                  decode d ~nest t')

     

       345
       345
       -
         | None -> Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Array

     

       401
       401
       +
             match t' with

     

       402
       402
       +
             | Array array_map -> decode_array d ~nest ev array_map

     

       403
       403
       +
             | _ ->

     

       404
       404
       +
                 (* For wrapped types like Map (Array ...), use full decode *)

     

       405
       405
       +
                 decode d ~nest t')

     

       406
       406
       +
         | None ->

     

       407
       407
       +
             Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Array

     

       346
       408
        
       

     

       347
       347
       -
       and decode_object : type o. decoder -> nest:int -> Event.spanned -> (o, o) object_map -> o =

     

       348
       348
       -
         fun d ~nest start_ev map ->

     

       349
       349
       -
         skip_event d; (* consume Mapping_start *)

     

       409
       409
       +
       and decode_object : type o.

     

       410
       410
       +
           decoder -> nest:int -> Event.spanned -> (o, o) object_map -> o =

     

       411
       411
       +
        fun d ~nest start_ev map ->

     

       412
       412
       +
         skip_event d;

     

       413
       413
       +
         (* consume Mapping_start *)

     

       350
       414
        
         check_nodes d;

     

       351
       415
        
         let meta = meta_of_span d start_ev.span in

     

       352
       352
       -
         let dict = decode_object_members d ~nest meta map String_map.empty Dict.empty in

     

       416
       416
       +
         let dict =

     

       417
       417
       +
           decode_object_members d ~nest meta map String_map.empty Dict.empty

     

       418
       418
       +
         in

     

       353
       419
        
         let dict = Dict.add object_meta_arg meta dict in

     

       354
       420
        
         apply_dict map.dec dict

     

       355
       421
        
       

     

       356
       422
        
       and decode_object_members : type o.

     

       357
       357
       -
         decoder -> nest:int -> Jsont.Meta.t -> (o, o) object_map ->

     

       358
       358
       -
         mem_dec String_map.t -> Dict.t -> Dict.t =

     

       359
       359
       -
         fun d ~nest obj_meta map mem_miss dict ->

     

       423
       423
       +
           decoder ->

     

       424
       424
       +
           nest:int ->

     

       425
       425
       +
           Jsont.Meta.t ->

     

       426
       426
       +
           (o, o) object_map ->

     

       427
       427
       +
           mem_dec String_map.t ->

     

       428
       428
       +
           Dict.t ->

     

       429
       429
       +
           Dict.t =

     

       430
       430
       +
        fun d ~nest obj_meta map mem_miss dict ->

     

       360
       431
        
         (* Merge expected member decoders *)

     

       361
       432
        
         let u _ _ _ = assert false in

     

       362
       433
        
         let mem_miss = String_map.union u mem_miss map.mem_decs in

     
···

       369
       440
        
             decode_object_cases d ~nest obj_meta map umems cases mem_miss [] dict

     

       370
       441
        
       

     

       371
       442
        
       and decode_object_basic : type o mems builder.

     

       372
       372
       -
         decoder -> nest:int -> Jsont.Meta.t -> (o, o) object_map ->

     

       373
       373
       -
         (o, mems, builder) unknown_mems ->

     

       374
       374
       -
         mem_dec String_map.t -> Dict.t -> Dict.t =

     

       375
       375
       -
         fun d ~nest obj_meta map umems mem_miss dict ->

     

       376
       376
       -
         let ubuilder = ref (match umems with

     

       377
       377
       -
           | Unknown_skip | Unknown_error -> Obj.magic ()

     

       378
       378
       -
           | Unknown_keep (mmap, _) -> mmap.dec_empty ()) in

     

       443
       443
       +
           decoder ->

     

       444
       444
       +
           nest:int ->

     

       445
       445
       +
           Jsont.Meta.t ->

     

       446
       446
       +
           (o, o) object_map ->

     

       447
       447
       +
           (o, mems, builder) unknown_mems ->

     

       448
       448
       +
           mem_dec String_map.t ->

     

       449
       449
       +
           Dict.t ->

     

       450
       450
       +
           Dict.t =

     

       451
       451
       +
        fun d ~nest obj_meta object_map umems mem_miss dict ->

     

       452
       452
       +
         let ubuilder =

     

       453
       453
       +
           ref

     

       454
       454
       +
             (match umems with

     

       455
       455
       +
             | Unknown_skip | Unknown_error -> Obj.magic ()

     

       456
       456
       +
             | Unknown_keep (mmap, _) -> mmap.dec_empty ())

     

       457
       457
       +
         in

     

       379
       458
        
         let mem_miss = ref mem_miss in

     

       380
       459
        
         let dict = ref dict in

     

       381
       460
        
         let rec loop () =

     
···

       383
       462
        
           | Some { Event.event = Event.Mapping_end; _ } ->

     

       384
       463
        
               skip_event d;

     

       385
       464
        
               (* Finalize *)

     

       386
       386
       -
               finish_object obj_meta map umems !ubuilder !mem_miss !dict

     

       465
       465
       +
               finish_object obj_meta object_map umems !ubuilder !mem_miss !dict

     

       387
       466
        
           | Some ev ->

     

       388
       467
        
               (* Expect a scalar key *)

     

       389
       468
        
               let name, name_meta = decode_mapping_key d ev in

     

       390
       469
        
               (* Look up member decoder *)

     

       391
       391
       -
               (match String_map.find_opt name map.mem_decs with

     

       392
       392
       -
                | Some (Mem_dec mem) ->

     

       393
       393
       -
                    mem_miss := String_map.remove name !mem_miss;

     

       394
       394
       -
                    (try

     

       395
       395
       -
                       let v = decode d ~nest:(nest + 1) mem.type' in

     

       396
       396
       -
                       dict := Dict.add mem.id v !dict

     

       397
       397
       -
                     with Jsont.Error e ->

     

       398
       398
       -
                       Jsont.Repr.error_push_object obj_meta map (name, name_meta) e)

     

       399
       399
       -
                | None ->

     

       400
       400
       -
                    (* Unknown member *)

     

       401
       401
       -
                    match umems with

     

       402
       402
       -
                    | Unknown_skip ->

     

       403
       403
       -
                        let _ : unit = decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.ignore) in

     

       404
       404
       -
                        ()

     

       405
       405
       -
                    | Unknown_error ->

     

       406
       406
       -
                        Jsont.Repr.unexpected_mems_error obj_meta map ~fnd:[(name, name_meta)]

     

       407
       407
       -
                    | Unknown_keep (mmap, _) ->

     

       408
       408
       -
                        (try

     

       409
       409
       -
                           let v = decode d ~nest:(nest + 1) mmap.mems_type in

     

       410
       410
       -
                           ubuilder := mmap.dec_add name_meta name v !ubuilder

     

       411
       411
       -
                         with Jsont.Error e ->

     

       412
       412
       -
                           Jsont.Repr.error_push_object obj_meta map (name, name_meta) e));

     

       470
       470
       +
               (match String_map.find_opt name object_map.mem_decs with

     

       471
       471
       +
               | Some (Mem_dec mem) -> (

     

       472
       472
       +
                   mem_miss := String_map.remove name !mem_miss;

     

       473
       473
       +
                   try

     

       474
       474
       +
                     let v = decode d ~nest:(nest + 1) mem.type' in

     

       475
       475
       +
                     dict := Dict.add mem.id v !dict

     

       476
       476
       +
                   with Jsont.Error e ->

     

       477
       477
       +
                     Jsont.Repr.error_push_object obj_meta object_map (name, name_meta)

     

       478
       478
       +
                       e)

     

       479
       479
       +
               | None -> (

     

       480
       480
       +
                   (* Unknown member *)

     

       481
       481
       +
                   match umems with

     

       482
       482
       +
                   | Unknown_skip ->

     

       483
       483
       +
                       let _ : unit =

     

       484
       484
       +
                         decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.ignore)

     

       485
       485
       +
                       in

     

       486
       486
       +
                       ()

     

       487
       487
       +
                   | Unknown_error ->

     

       488
       488
       +
                       Jsont.Repr.unexpected_mems_error obj_meta object_map

     

       489
       489
       +
                         ~fnd:[ (name, name_meta) ]

     

       490
       490
       +
                   | Unknown_keep (mmap, _) -> (

     

       491
       491
       +
                       try

     

       492
       492
       +
                         let v = decode d ~nest:(nest + 1) mmap.mems_type in

     

       493
       493
       +
                         ubuilder := mmap.dec_add name_meta name v !ubuilder

     

       494
       494
       +
                       with Jsont.Error e ->

     

       495
       495
       +
                         Jsont.Repr.error_push_object obj_meta object_map

     

       496
       496
       +
                           (name, name_meta) e)));

     

       413
       497
        
               loop ()

     

       414
       414
       -
           | None ->

     

       415
       415
       -
               Jsont.Error.msgf obj_meta "Unclosed mapping"

     

       498
       498
       +
           | None -> err_msg obj_meta "Unclosed mapping"

     

       416
       499
        
         in

     

       417
       500
        
         loop ()

     

       418
       501
        
       

     

       419
       502
        
       and finish_object : type o mems builder.

     

       420
       420
       -
         Jsont.Meta.t -> (o, o) object_map -> (o, mems, builder) unknown_mems ->

     

       421
       421
       -
         builder -> mem_dec String_map.t -> Dict.t -> Dict.t =

     

       422
       422
       -
         fun meta map umems ubuilder mem_miss dict ->

     

       503
       503
       +
           Jsont.Meta.t ->

     

       504
       504
       +
           (o, o) object_map ->

     

       505
       505
       +
           (o, mems, builder) unknown_mems ->

     

       506
       506
       +
           builder ->

     

       507
       507
       +
           mem_dec String_map.t ->

     

       508
       508
       +
           Dict.t ->

     

       509
       509
       +
           Dict.t =

     

       510
       510
       +
        fun meta map umems ubuilder mem_miss dict ->

     

       511
       511
       +
         let open Jsont.Repr in

     

       423
       512
        
         let dict = Dict.add object_meta_arg meta dict in

     

       424
       424
       -
         let dict = match umems with

     

       513
       513
       +
         let dict =

     

       514
       514
       +
           match umems with

     

       425
       515
        
           | Unknown_skip | Unknown_error -> dict

     

       426
       426
       -
           | Unknown_keep (mmap, _) -> Dict.add mmap.id (mmap.dec_finish meta ubuilder) dict

     

       516
       516
       +
           | Unknown_keep (mmap, _) ->

     

       517
       517
       +
               Dict.add mmap.id (mmap.dec_finish meta ubuilder) dict

     

       427
       518
        
         in

     

       428
       519
        
         (* Check for missing required members *)

     

       429
       520
        
         let add_default _ (Mem_dec mem_map) dict =

     
···

       435
       526
        
         with Exit ->

     

       436
       527
        
           let no_default _ (Mem_dec mm) = Option.is_none mm.dec_absent in

     

       437
       528
        
           let exp = String_map.filter no_default mem_miss in

     

       438
       438
       -
           Jsont.Repr.missing_mems_error meta map ~exp ~fnd:[]

     

       529
       529
       +
           missing_mems_error meta map ~exp ~fnd:[]

     

       439
       530
        
       

     

       440
       531
        
       and decode_object_cases : type o cases tag.

     

       441
       441
       -
         decoder -> nest:int -> Jsont.Meta.t -> (o, o) object_map ->

     

       442
       442
       -
         unknown_mems_option ->

     

       443
       443
       -
         (o, cases, tag) object_cases ->

     

       444
       444
       -
         mem_dec String_map.t -> (Jsont.name * Jsont.json) list -> Dict.t -> Dict.t =

     

       445
       445
       -
         fun d ~nest obj_meta map umems cases mem_miss delayed dict ->

     

       532
       532
       +
           decoder ->

     

       533
       533
       +
           nest:int ->

     

       534
       534
       +
           Jsont.Meta.t ->

     

       535
       535
       +
           (o, o) object_map ->

     

       536
       536
       +
           unknown_mems_option ->

     

       537
       537
       +
           (o, cases, tag) object_cases ->

     

       538
       538
       +
           mem_dec String_map.t ->

     

       539
       539
       +
           (Jsont.name * Jsont.json) list ->

     

       540
       540
       +
           Dict.t ->

     

       541
       541
       +
           Dict.t =

     

       542
       542
       +
        fun d ~nest obj_meta object_map umems cases mem_miss delayed dict ->

     

       446
       543
        
         match peek_event d with

     

       447
       447
       -
         | Some { Event.event = Event.Mapping_end; _ } ->

     

       544
       544
       +
         | Some { Event.event = Event.Mapping_end; _ } -> (

     

       448
       545
        
             skip_event d;

     

       449
       546
        
             (* No tag found - use dec_absent if available *)

     

       450
       450
       -
             (match cases.tag.dec_absent with

     

       451
       451
       -
              | Some tag ->

     

       452
       452
       -
                  decode_with_case_tag d ~nest obj_meta map umems cases tag mem_miss delayed dict

     

       453
       453
       -
              | None ->

     

       454
       454
       -
                  (* Missing required case tag *)

     

       455
       455
       -
                  let exp = String_map.singleton cases.tag.name (Mem_dec cases.tag) in

     

       456
       456
       -
                  let fnd = List.map (fun ((n, _), _) -> n) delayed in

     

       457
       457
       -
                  Jsont.Repr.missing_mems_error obj_meta map ~exp ~fnd)

     

       547
       547
       +
             match cases.tag.dec_absent with

     

       548
       548
       +
             | Some tag ->

     

       549
       549
       +
                 decode_with_case_tag d ~nest obj_meta object_map umems cases tag

     

       550
       550
       +
                   mem_miss delayed dict

     

       551
       551
       +
             | None ->

     

       552
       552
       +
                 (* Missing required case tag *)

     

       553
       553
       +
                 let exp = String_map.singleton cases.tag.name (Mem_dec cases.tag) in

     

       554
       554
       +
                 let fnd = List.map (fun ((n, _), _) -> n) delayed in

     

       555
       555
       +
                 Jsont.Repr.missing_mems_error obj_meta object_map ~exp ~fnd)

     

       458
       556
        
         | Some ev ->

     

       459
       557
        
             let name, name_meta = decode_mapping_key d ev in

     

       460
       558
        
             if String.equal name cases.tag.name then begin

     

       461
       559
        
               (* Found the case tag *)

     

       462
       560
        
               let tag = decode d ~nest:(nest + 1) cases.tag.type' in

     

       463
       463
       -
               decode_with_case_tag d ~nest obj_meta map umems cases tag mem_miss delayed dict

     

       464
       464
       -
             end else begin

     

       561
       561
       +
               decode_with_case_tag d ~nest obj_meta object_map umems cases tag

     

       562
       562
       +
                 mem_miss delayed dict

     

       563
       563
       +
             end

     

       564
       564
       +
             else begin

     

       465
       565
        
               (* Not the case tag - check if known member or delay *)

     

       466
       466
       -
               match String_map.find_opt name map.mem_decs with

     

       467
       467
       -
               | Some (Mem_dec mem) ->

     

       566
       566
       +
               match String_map.find_opt name object_map.mem_decs with

     

       567
       567
       +
               | Some (Mem_dec mem) -> (

     

       468
       568
        
                   let mem_miss = String_map.remove name mem_miss in

     

       469
       469
       -
                   (try

     

       470
       470
       -
                      let v = decode d ~nest:(nest + 1) mem.type' in

     

       471
       471
       -
                      let dict = Dict.add mem.id v dict in

     

       472
       472
       -
                      decode_object_cases d ~nest obj_meta map umems cases mem_miss delayed dict

     

       473
       473
       -
                    with Jsont.Error e ->

     

       474
       474
       -
                      Jsont.Repr.error_push_object obj_meta map (name, name_meta) e)

     

       569
       569
       +
                   try

     

       570
       570
       +
                     let v = decode d ~nest:(nest + 1) mem.type' in

     

       571
       571
       +
                     let dict = Dict.add mem.id v dict in

     

       572
       572
       +
                     decode_object_cases d ~nest obj_meta object_map umems cases

     

       573
       573
       +
                       mem_miss delayed dict

     

       574
       574
       +
                   with Jsont.Error e ->

     

       575
       575
       +
                     Jsont.Repr.error_push_object obj_meta object_map (name, name_meta)

     

       576
       576
       +
                       e)

     

       475
       577
        
               | None ->

     

       476
       578
        
                   (* Unknown member - decode as generic JSON and delay *)

     

       477
       477
       -
                   let v = decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.json) in

     

       579
       579
       +
                   let v =

     

       580
       580
       +
                     decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.json)

     

       581
       581
       +
                   in

     

       478
       582
        
                   let delayed = ((name, name_meta), v) :: delayed in

     

       479
       479
       -
                   decode_object_cases d ~nest obj_meta map umems cases mem_miss delayed dict

     

       583
       583
       +
                   decode_object_cases d ~nest obj_meta object_map umems cases

     

       584
       584
       +
                     mem_miss delayed dict

     

       480
       585
        
             end

     

       481
       481
       -
         | None ->

     

       482
       482
       -
             Jsont.Error.msgf obj_meta "Unclosed mapping"

     

       586
       586
       +
         | None -> err_msg obj_meta "Unclosed mapping"

     

       483
       587
        
       

     

       484
       588
        
       and decode_with_case_tag : type o cases tag.

     

       485
       485
       -
         decoder -> nest:int -> Jsont.Meta.t -> (o, o) object_map ->

     

       486
       486
       -
         unknown_mems_option ->

     

       487
       487
       -
         (o, cases, tag) object_cases -> tag ->

     

       488
       488
       -
         mem_dec String_map.t -> (Jsont.name * Jsont.json) list -> Dict.t -> Dict.t =

     

       489
       489
       -
         fun d ~nest obj_meta map umems cases tag mem_miss delayed dict ->

     

       589
       589
       +
           decoder ->

     

       590
       590
       +
           nest:int ->

     

       591
       591
       +
           Jsont.Meta.t ->

     

       592
       592
       +
           (o, o) object_map ->

     

       593
       593
       +
           unknown_mems_option ->

     

       594
       594
       +
           (o, cases, tag) object_cases ->

     

       595
       595
       +
           tag ->

     

       596
       596
       +
           mem_dec String_map.t ->

     

       597
       597
       +
           (Jsont.name * Jsont.json) list ->

     

       598
       598
       +
           Dict.t ->

     

       599
       599
       +
           Dict.t =

     

       600
       600
       +
        fun d ~nest obj_meta map umems cases tag mem_miss delayed dict ->

     

       601
       601
       +
         let open Jsont.Repr in

     

       490
       602
        
         let eq_tag (Case c) = cases.tag_compare c.tag tag = 0 in

     

       491
       603
        
         match List.find_opt eq_tag cases.cases with

     

       492
       492
       -
         | None ->

     

       493
       493
       -
             Jsont.Repr.unexpected_case_tag_error obj_meta map cases tag

     

       604
       604
       +
         | None -> unexpected_case_tag_error obj_meta map cases tag

     

       494
       605
        
         | Some (Case case) ->

     

       495
       606
        
             (* Continue decoding with the case's object map *)

     

       496
       496
       -
             let case_dict = decode_case_remaining d ~nest obj_meta case.object_map

     

       497
       497
       -
                 umems mem_miss delayed dict in

     

       607
       607
       +
             let case_dict =

     

       608
       608
       +
               decode_case_remaining d ~nest obj_meta case.object_map umems mem_miss

     

       609
       609
       +
                 delayed dict

     

       610
       610
       +
             in

     

       498
       611
        
             let case_value = apply_dict case.object_map.dec case_dict in

     

       499
       612
        
             Dict.add cases.id (case.dec case_value) dict

     

       500
       613
        
       

     

       501
       614
        
       and decode_case_remaining : type o.

     

       502
       502
       -
         decoder -> nest:int -> Jsont.Meta.t -> (o, o) object_map ->

     

       503
       503
       -
         unknown_mems_option ->

     

       504
       504
       -
         mem_dec String_map.t -> (Jsont.name * Jsont.json) list -> Dict.t -> Dict.t =

     

       505
       505
       -
         fun d ~nest obj_meta case_map _umems mem_miss delayed dict ->

     

       615
       615
       +
           decoder ->

     

       616
       616
       +
           nest:int ->

     

       617
       617
       +
           Jsont.Meta.t ->

     

       618
       618
       +
           (o, o) object_map ->

     

       619
       619
       +
           unknown_mems_option ->

     

       620
       620
       +
           mem_dec String_map.t ->

     

       621
       621
       +
           (Jsont.name * Jsont.json) list ->

     

       622
       622
       +
           Dict.t ->

     

       623
       623
       +
           Dict.t =

     

       624
       624
       +
        fun d ~nest obj_meta case_map _umems mem_miss delayed dict ->

     

       506
       625
        
         (* First, process delayed members against the case map *)

     

       507
       626
        
         let u _ _ _ = assert false in

     

       508
       627
        
         let mem_miss = String_map.union u mem_miss case_map.mem_decs in

     

       509
       509
       -
         let dict, mem_miss = List.fold_left (fun (dict, mem_miss) ((name, meta), json) ->

     

       510
       510
       -
           match String_map.find_opt name case_map.mem_decs with

     

       511
       511
       -
           | Some (Mem_dec mem) ->

     

       512
       512
       -
               let t' = Jsont.Repr.unsafe_to_t mem.type' in

     

       513
       513
       -
               (match Jsont.Json.decode' t' json with

     

       514
       514
       -
                | Ok v ->

     

       515
       515
       -
                    let dict = Dict.add mem.id v dict in

     

       516
       516
       -
                    let mem_miss = String_map.remove name mem_miss in

     

       517
       517
       -
                    (dict, mem_miss)

     

       518
       518
       -
                | Error e ->

     

       519
       519
       -
                    Jsont.Repr.error_push_object obj_meta case_map (name, meta) e)

     

       520
       520
       -
           | None ->

     

       521
       521
       -
               (* Unknown for case too - skip them *)

     

       522
       522
       -
               (dict, mem_miss)

     

       523
       523
       -
         ) (dict, mem_miss) delayed in

     

       628
       628
       +
         let dict, mem_miss =

     

       629
       629
       +
           List.fold_left

     

       630
       630
       +
             (fun (dict, mem_miss) ((name, meta), json_value) ->

     

       631
       631
       +
               match String_map.find_opt name case_map.mem_decs with

     

       632
       632
       +
               | Some (Mem_dec mem) -> (

     

       633
       633
       +
                   let t' = Jsont.Repr.unsafe_to_t mem.type' in

     

       634
       634
       +
                   match Jsont.Json.decode' t' json_value with

     

       635
       635
       +
                   | Ok v ->

     

       636
       636
       +
                       let dict = Dict.add mem.id v dict in

     

       637
       637
       +
                       let mem_miss = String_map.remove name mem_miss in

     

       638
       638
       +
                       (dict, mem_miss)

     

       639
       639
       +
                   | Error e ->

     

       640
       640
       +
                       Jsont.Repr.error_push_object obj_meta case_map (name, meta) e)

     

       641
       641
       +
               | None ->

     

       642
       642
       +
                   (* Unknown for case too - skip them *)

     

       643
       643
       +
                   (dict, mem_miss))

     

       644
       644
       +
             (dict, mem_miss) delayed

     

       645
       645
       +
         in

     

       524
       646
        
         (* Then continue reading remaining members using case's own unknown handling *)

     

       525
       647
        
         match case_map.shape with

     

       526
       648
        
         | Object_basic case_umems ->

     
···

       529
       651
        
             (* Nested cases shouldn't happen - use skip for safety *)

     

       530
       652
        
             decode_object_basic d ~nest obj_meta case_map Unknown_skip mem_miss dict

     

       531
       653
        
       

     

       532
       532
       -
       and decode_any_mapping : type a. decoder -> nest:int -> Event.spanned -> a t -> a any_map -> a =

     

       533
       533
       -
         fun d ~nest ev t map ->

     

       654
       654
       +
       and decode_any_mapping : type a.

     

       655
       655
       +
           decoder -> nest:int -> Event.spanned -> a t -> a any_map -> a =

     

       656
       656
       +
        fun d ~nest ev t map ->

     

       534
       657
        
         match map.dec_object with

     

       535
       658
        
         | Some t' -> decode d ~nest t'

     

       536
       536
       -
         | None -> Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Object

     

       659
       659
       +
         | None ->

     

       660
       660
       +
             Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Object

     

       537
       661
        
       

     

       538
       662
        
       and decode_mapping_key : decoder -> Event.spanned -> string * Jsont.Meta.t =

     

       539
       539
       -
         fun d ev ->

     

       663
       663
       +
        fun d ev ->

     

       540
       664
        
         match ev.Event.event with

     

       541
       665
        
         | Event.Scalar { value; _ } ->

     

       542
       666
        
             skip_event d;

     
···

       544
       668
        
             (value, meta)

     

       545
       669
        
         | _ ->

     

       546
       670
        
             let meta = meta_of_span d ev.span in

     

       547
       547
       -
             Jsont.Error.msgf meta "Mapping keys must be scalars (strings), found %a"

     

       548
       548
       -
               Event.pp ev.event

     

       671
       671
       +
             err_msg meta "Mapping keys must be scalars (strings), found %a" Event.pp

     

       672
       672
       +
               ev.event

     

       549
       673
        
       

     

       550
       674
        
       (* Skip stream/document wrappers *)

     

       551
       675
        
       let skip_to_content d =

     

       552
       676
        
         let rec loop () =

     

       553
       677
        
           match peek_event d with

     

       554
       554
       -
           | Some { Event.event = Event.Stream_start _; _ } -> skip_event d; loop ()

     

       555
       555
       -
           | Some { Event.event = Event.Document_start _; _ } -> skip_event d; loop ()

     

       678
       678
       +
           | Some { Event.event = Event.Stream_start _; _ } ->

     

       679
       679
       +
               skip_event d;

     

       680
       680
       +
               loop ()

     

       681
       681
       +
           | Some { Event.event = Event.Document_start _; _ } ->

     

       682
       682
       +
               skip_event d;

     

       683
       683
       +
               loop ()

     

       556
       684
        
           | _ -> ()

     

       557
       685
        
         in

     

       558
       686
        
         loop ()

     
···

       560
       688
        
       let skip_end_wrappers d =

     

       561
       689
        
         let rec loop () =

     

       562
       690
        
           match peek_event d with

     

       563
       563
       -
           | Some { Event.event = Event.Document_end _; _ } -> skip_event d; loop ()

     

       564
       564
       -
           | Some { Event.event = Event.Stream_end; _ } -> skip_event d; loop ()

     

       691
       691
       +
           | Some { Event.event = Event.Document_end _; _ } ->

     

       692
       692
       +
               skip_event d;

     

       693
       693
       +
               loop ()

     

       694
       694
       +
           | Some { Event.event = Event.Stream_end; _ } ->

     

       695
       695
       +
               skip_event d;

     

       696
       696
       +
               loop ()

     

       565
       697
        
           | None -> ()

     

       566
       698
        
           | Some ev ->

     

       567
       699
        
               let meta = meta_of_span d ev.span in

     

       568
       568
       -
               Jsont.Error.msgf meta "Expected end of document but found %a" Event.pp ev.event

     

       700
       700
       +
               err_msg meta "Expected end of document but found %a" Event.pp ev.event

     

       569
       701
        
         in

     

       570
       702
        
         loop ()

     

       571
       703
        
       

     

       704
       704
       +
       (* Skip to the end of the current document after an error *)

     

       705
       705
       +
       let skip_to_document_end d =

     

       706
       706
       +
         let rec loop depth =

     

       707
       707
       +
           match peek_event d with

     

       708
       708
       +
           | None -> ()

     

       709
       709
       +
           | Some { Event.event = Event.Stream_end; _ } -> ()

     

       710
       710
       +
           | Some { Event.event = Event.Document_end _; _ } ->

     

       711
       711
       +
               skip_event d;

     

       712
       712
       +
               if depth = 0 then () else loop (depth - 1)

     

       713
       713
       +
           | Some { Event.event = Event.Document_start _; _ } ->

     

       714
       714
       +
               skip_event d;

     

       715
       715
       +
               loop (depth + 1)

     

       716
       716
       +
           | Some _ ->

     

       717
       717
       +
               skip_event d;

     

       718
       718
       +
               loop depth

     

       719
       719
       +
         in

     

       720
       720
       +
         loop 0

     

       721
       721
       +
       

     

       572
       722
        
       (* Public decode API *)

     

       573
       723
        
       

     

       724
       724
       +
       (* Decode all documents from a multi-document YAML stream *)

     

       725
       725
       +
       let decode_all' ?(layout = false) ?(locs = false) ?(file = "-")

     

       726
       726
       +
           ?(max_depth = 100) ?(max_nodes = 10_000_000) t reader =

     

       727
       727
       +
         let parser = Parser.of_reader reader in

     

       728
       728
       +
         let d = make_decoder ~layout ~locs ~file ~max_depth ~max_nodes parser in

     

       729
       729
       +
         let t' = Jsont.Repr.of_t t in

     

       730
       730
       +
         let rec next_doc () =

     

       731
       731
       +
           match peek_event d with

     

       732
       732
       +
           | None -> Seq.Nil

     

       733
       733
       +
           | Some { Event.event = Event.Stream_end; _ } ->

     

       734
       734
       +
               skip_event d;

     

       735
       735
       +
               Seq.Nil

     

       736
       736
       +
           | Some _ -> (

     

       737
       737
       +
               try

     

       738
       738
       +
                 skip_to_content d;

     

       739
       739
       +
                 (* Reset node count for each document *)

     

       740
       740
       +
                 d.node_count <- 0;

     

       741
       741
       +
                 let v = decode d ~nest:0 t' in

     

       742
       742
       +
                 (* Skip document end marker if present *)

     

       743
       743
       +
                 (match peek_event d with

     

       744
       744
       +
                 | Some { Event.event = Event.Document_end _; _ } -> skip_event d

     

       745
       745
       +
                 | _ -> ());

     

       746
       746
       +
                 Seq.Cons (Ok v, next_doc)

     

       747
       747
       +
               with

     

       748
       748
       +
               | Jsont.Error e ->

     

       749
       749
       +
                   skip_to_document_end d;

     

       750
       750
       +
                   Seq.Cons (Error e, next_doc)

     

       751
       751
       +
               | Error.Yamlrw_error err ->

     

       752
       752
       +
                   skip_to_document_end d;

     

       753
       753
       +
                   let msg = Error.to_string err in

     

       754
       754
       +
                   let e = Jsont.(Error.make_msg Error.Context.empty Meta.none msg) in

     

       755
       755
       +
                   Seq.Cons (Error e, next_doc))

     

       756
       756
       +
         in

     

       757
       757
       +
         next_doc

     

       758
       758
       +
       

     

       759
       759
       +
       let decode_all ?layout ?locs ?file ?max_depth ?max_nodes t reader =

     

       760
       760
       +
         decode_all' ?layout ?locs ?file ?max_depth ?max_nodes t reader

     

       761
       761
       +
         |> Seq.map (Result.map_error Jsont.Error.to_string)

     

       762
       762
       +
       

     

       574
       763
        
       let decode' ?layout ?locs ?file ?max_depth ?max_nodes t reader =

     

       575
       764
        
         let parser = Parser.of_reader reader in

     

       576
       765
        
         let d = make_decoder ?layout ?locs ?file ?max_depth ?max_nodes parser in

     
···

       584
       773
        
         | Jsont.Error e -> Error e

     

       585
       774
        
         | Error.Yamlrw_error err ->

     

       586
       775
        
             let msg = Error.to_string err in

     

       587
       587
       -
             Error (Jsont.Error.make_msg Jsont.Error.Context.empty Jsont.Meta.none msg)

     

       776
       776
       +
             Error Jsont.(Error.make_msg Error.Context.empty Meta.none msg)

     

       588
       777
        
       

     

       589
       778
        
       let decode ?layout ?locs ?file ?max_depth ?max_nodes t reader =

     

       590
       779
        
         Result.map_error Jsont.Error.to_string

     

       591
       780
        
           (decode' ?layout ?locs ?file ?max_depth ?max_nodes t reader)

     

       592
       781
        
       

     

       593
       593
       -
       let decode_string' ?layout ?locs ?file ?max_depth ?max_nodes t s =

     

       594
       594
       -
         decode' ?layout ?locs ?file ?max_depth ?max_nodes t (Bytes.Reader.of_string s)

     

       595
       595
       -
       

     

       596
       596
       -
       let decode_string ?layout ?locs ?file ?max_depth ?max_nodes t s =

     

       597
       597
       -
         decode ?layout ?locs ?file ?max_depth ?max_nodes t (Bytes.Reader.of_string s)

     

       598
       598
       -
       

     

       599
       782
        
       (* Encoder *)

     

       600
       783
        
       

     

       601
       784
        
       type encoder = {

     
···

       606
       789
        
         scalar_style : Scalar_style.t;

     

       607
       790
        
       }

     

       608
       791
        
       

     

       609
       609
       -
       let make_encoder

     

       610
       610
       -
           ?(format = Block) ?(indent = 2) ?(explicit_doc = false)

     

       792
       792
       +
       let make_encoder ?(format = Block) ?(indent = 2) ?(explicit_doc = false)

     

       611
       793
        
           ?(scalar_style = `Any) emitter =

     

       612
       794
        
         { emitter; format; _indent = indent; explicit_doc; scalar_style }

     

       613
       795
        
       

     
···

       623
       805
        
         else if String.length s > 80 then `Folded

     

       624
       806
        
         else `Plain

     

       625
       807
        
       

     

       808
       808
       +
       (* Helper to create scalar events with common defaults *)

     

       809
       809
       +
       let scalar_event ?(anchor = None) ?(tag = None) ~value ~style () =

     

       810
       810
       +
         Event.Scalar

     

       811
       811
       +
           {

     

       812
       812
       +
             anchor;

     

       813
       813
       +
             tag;

     

       814
       814
       +
             value;

     

       815
       815
       +
             plain_implicit = true;

     

       816
       816
       +
             quoted_implicit = true;

     

       817
       817
       +
             style;

     

       818
       818
       +
           }

     

       819
       819
       +
       

     

       820
       820
       +
       (* Helper to emit events *)

     

       821
       821
       +
       let emit e = Emitter.emit e.emitter

     

       822
       822
       +
       

     

       626
       823
        
       (* Encode null *)

     

       627
       627
       -
       let encode_null e _meta =

     

       628
       628
       -
         Emitter.emit e.emitter (Event.Scalar {

     

       629
       629
       -
           anchor = None;

     

       630
       630
       -
           tag = None;

     

       631
       631
       -
           value = "null";

     

       632
       632
       -
           plain_implicit = true;

     

       633
       633
       -
           quoted_implicit = true;

     

       634
       634
       -
           style = `Plain;

     

       635
       635
       -
         })

     

       824
       824
       +
       let encode_null e _meta = emit e (scalar_event ~value:"null" ~style:`Plain ())

     

       636
       825
        
       

     

       637
       826
        
       (* Encode boolean *)

     

       638
       827
        
       let encode_bool e _meta b =

     

       639
       639
       -
         Emitter.emit e.emitter (Event.Scalar {

     

       640
       640
       -
           anchor = None;

     

       641
       641
       -
           tag = None;

     

       642
       642
       -
           value = if b then "true" else "false";

     

       643
       643
       -
           plain_implicit = true;

     

       644
       644
       -
           quoted_implicit = true;

     

       645
       645
       -
           style = `Plain;

     

       646
       646
       -
         })

     

       828
       828
       +
         emit e (scalar_event ~value:(if b then "true" else "false") ~style:`Plain ())

     

       647
       829
        
       

     

       648
       830
        
       (* Encode number *)

     

       649
       831
        
       let encode_number e _meta f =

     

       650
       832
        
         let value =

     

       651
       651
       -
           if Float.is_nan f then ".nan"

     

       652
       652
       -
           else if f = Float.infinity then ".inf"

     

       653
       653
       -
           else if f = Float.neg_infinity then "-.inf"

     

       654
       654
       -
           else

     

       655
       655
       -
             let s = Printf.sprintf "%.17g" f in

     

       656
       656
       -
             (* Ensure it looks like a number *)

     

       657
       657
       -
             if String.contains s '.' || String.contains s 'e' || String.contains s 'E'

     

       658
       658
       -
             then s

     

       659
       659
       -
             else s ^ ".0"

     

       833
       833
       +
           match Float.classify_float f with

     

       834
       834
       +
           | FP_nan -> ".nan"

     

       835
       835
       +
           | FP_infinite -> if f > 0.0 then ".inf" else "-.inf"

     

       836
       836
       +
           | _ ->

     

       837
       837
       +
               if Float.is_integer f && Float.abs f < 1e15 then Printf.sprintf "%.0f" f

     

       838
       838
       +
               else Printf.sprintf "%g" f

     

       660
       839
        
         in

     

       661
       661
       -
         Emitter.emit e.emitter (Event.Scalar {

     

       662
       662
       -
           anchor = None;

     

       663
       663
       -
           tag = None;

     

       664
       664
       -
           value;

     

       665
       665
       -
           plain_implicit = true;

     

       666
       666
       -
           quoted_implicit = true;

     

       667
       667
       -
           style = `Plain;

     

       668
       668
       -
         })

     

       840
       840
       +
         emit e (scalar_event ~value ~style:`Plain ())

     

       669
       841
        
       

     

       670
       842
        
       (* Encode string *)

     

       671
       843
        
       let encode_string e _meta s =

     

       672
       844
        
         let style = choose_scalar_style ~preferred:e.scalar_style s in

     

       673
       673
       -
         Emitter.emit e.emitter (Event.Scalar {

     

       674
       674
       -
           anchor = None;

     

       675
       675
       -
           tag = None;

     

       676
       676
       -
           value = s;

     

       677
       677
       -
           plain_implicit = true;

     

       678
       678
       -
           quoted_implicit = true;

     

       679
       679
       -
           style;

     

       680
       680
       -
         })

     

       845
       845
       +
         emit e (scalar_event ~value:s ~style ())

     

       681
       846
        
       

     

       682
       847
        
       let rec encode : type a. encoder -> a t -> a -> unit =

     

       683
       683
       -
         fun e t v ->

     

       848
       848
       +
        fun e t v ->

     

       684
       849
        
         match t with

     

       685
       850
        
         | Null map ->

     

       686
       851
        
             let meta = map.enc_meta v in

     

       687
       852
        
             let () = map.enc v in

     

       688
       853
        
             encode_null e meta

     

       689
       689
       -
       

     

       690
       854
        
         | Bool map ->

     

       691
       855
        
             let meta = map.enc_meta v in

     

       692
       856
        
             let b = map.enc v in

     

       693
       857
        
             encode_bool e meta b

     

       694
       694
       -
       

     

       695
       858
        
         | Number map ->

     

       696
       859
        
             let meta = map.enc_meta v in

     

       697
       860
        
             let f = map.enc v in

     

       698
       861
        
             encode_number e meta f

     

       699
       699
       -
       

     

       700
       862
        
         | String map ->

     

       701
       863
        
             let meta = map.enc_meta v in

     

       702
       864
        
             let s = map.enc v in

     

       703
       865
        
             encode_string e meta s

     

       704
       704
       -
       

     

       705
       705
       -
         | Array map ->

     

       706
       706
       -
             encode_array e map v

     

       707
       707
       -
       

     

       708
       708
       -
         | Object map ->

     

       709
       709
       -
             encode_object e map v

     

       710
       710
       -
       

     

       866
       866
       +
         | Array map -> encode_array e map v

     

       867
       867
       +
         | Object map -> encode_object e map v

     

       711
       868
        
         | Any map ->

     

       712
       869
        
             let t' = map.enc v in

     

       713
       870
        
             encode e t' v

     

       714
       714
       -
       

     

       715
       715
       -
         | Map m ->

     

       716
       716
       -
             encode e m.dom (m.enc v)

     

       717
       717
       -
       

     

       718
       718
       -
         | Rec lazy_t ->

     

       719
       719
       -
             encode e (Lazy.force lazy_t) v

     

       871
       871
       +
         | Map m -> encode e m.dom (m.enc v)

     

       872
       872
       +
         | Rec lazy_t -> encode e (Lazy.force lazy_t) v

     

       720
       873
        
       

     

       721
       874
        
       and encode_array : type a elt b. encoder -> (a, elt, b) array_map -> a -> unit =

     

       722
       722
       -
         fun e map v ->

     

       875
       875
       +
        fun e map v ->

     

       723
       876
        
         let style = layout_style_of_format e.format in

     

       724
       724
       -
         Emitter.emit e.emitter (Event.Sequence_start {

     

       725
       725
       -
           anchor = None;

     

       726
       726
       -
           tag = None;

     

       727
       727
       -
           implicit = true;

     

       728
       728
       -
           style;

     

       729
       729
       -
         });

     

       730
       730
       -
         let _ = map.enc (fun () _idx elt ->

     

       731
       731
       -
           encode e map.elt elt;

     

       732
       732
       -
           ()

     

       733
       733
       -
         ) () v in

     

       734
       734
       -
         Emitter.emit e.emitter Event.Sequence_end

     

       877
       877
       +
         emit e

     

       878
       878
       +
           (Event.Sequence_start { anchor = None; tag = None; implicit = true; style });

     

       879
       879
       +
         let _ =

     

       880
       880
       +
           map.enc

     

       881
       881
       +
             (fun () _idx elt ->

     

       882
       882
       +
               encode e map.elt elt;

     

       883
       883
       +
               ())

     

       884
       884
       +
             () v

     

       885
       885
       +
         in

     

       886
       886
       +
         emit e Event.Sequence_end

     

       735
       887
        
       

     

       736
       888
        
       and encode_object : type o. encoder -> (o, o) object_map -> o -> unit =

     

       737
       737
       -
         fun e map v ->

     

       889
       889
       +
        fun e map v ->

     

       738
       890
        
         let style = layout_style_of_format e.format in

     

       739
       739
       -
         Emitter.emit e.emitter (Event.Mapping_start {

     

       740
       740
       -
           anchor = None;

     

       741
       741
       -
           tag = None;

     

       742
       742
       -
           implicit = true;

     

       743
       743
       -
           style;

     

       744
       744
       -
         });

     

       891
       891
       +
         emit e (Event.Mapping_start { anchor = None; tag = None; implicit = true; style });

     

       745
       892
        
         (* Encode each member *)

     

       746
       746
       -
         List.iter (fun (Mem_enc mem) ->

     

       747
       747
       -
           let mem_v = mem.enc v in

     

       748
       748
       -
           if not (mem.enc_omit mem_v) then begin

     

       749
       749
       -
             (* Emit key *)

     

       750
       750
       -
             Emitter.emit e.emitter (Event.Scalar {

     

       751
       751
       -
               anchor = None;

     

       752
       752
       -
               tag = None;

     

       753
       753
       -
               value = mem.name;

     

       754
       754
       -
               plain_implicit = true;

     

       755
       755
       -
               quoted_implicit = true;

     

       756
       756
       -
               style = `Plain;

     

       757
       757
       -
             });

     

       758
       758
       -
             (* Emit value *)

     

       759
       759
       -
             encode e mem.type' mem_v

     

       760
       760
       -
           end

     

       761
       761
       -
         ) map.mem_encs;

     

       893
       893
       +
         List.iter

     

       894
       894
       +
           (fun (Mem_enc mem) ->

     

       895
       895
       +
             let mem_v = mem.enc v in

     

       896
       896
       +
             if not (mem.enc_omit mem_v) then begin

     

       897
       897
       +
               (* Emit key *)

     

       898
       898
       +
               emit e (scalar_event ~value:mem.name ~style:`Plain ());

     

       899
       899
       +
               (* Emit value *)

     

       900
       900
       +
               encode e mem.type' mem_v

     

       901
       901
       +
             end)

     

       902
       902
       +
           map.mem_encs;

     

       762
       903
        
         (* Handle case objects *)

     

       763
       904
        
         (match map.shape with

     

       764
       764
       -
          | Object_basic _ -> ()

     

       765
       765
       -
          | Object_cases (_, cases) ->

     

       766
       766
       -
              let Case_value (case_map, case_v) = cases.enc_case (cases.enc v) in

     

       767
       767
       -
              (* Emit case tag *)

     

       768
       768
       -
              if not (cases.tag.enc_omit (case_map.tag)) then begin

     

       769
       769
       -
                Emitter.emit e.emitter (Event.Scalar {

     

       770
       770
       -
                  anchor = None;

     

       771
       771
       -
                  tag = None;

     

       772
       772
       -
                  value = cases.tag.name;

     

       773
       773
       -
                  plain_implicit = true;

     

       774
       774
       -
                  quoted_implicit = true;

     

       775
       775
       -
                  style = `Plain;

     

       776
       776
       -
                });

     

       777
       777
       -
                encode e cases.tag.type' case_map.tag

     

       778
       778
       -
              end;

     

       779
       779
       -
              (* Emit case members *)

     

       780
       780
       -
              List.iter (fun (Mem_enc mem) ->

     

       781
       781
       -
                let mem_v = mem.enc case_v in

     

       782
       782
       -
                if not (mem.enc_omit mem_v) then begin

     

       783
       783
       -
                  Emitter.emit e.emitter (Event.Scalar {

     

       784
       784
       -
                    anchor = None;

     

       785
       785
       -
                    tag = None;

     

       786
       786
       -
                    value = mem.name;

     

       787
       787
       -
                    plain_implicit = true;

     

       788
       788
       -
                    quoted_implicit = true;

     

       789
       789
       -
                    style = `Plain;

     

       790
       790
       -
                  });

     

       791
       791
       -
                  encode e mem.type' mem_v

     

       792
       792
       -
                end

     

       793
       793
       -
              ) case_map.object_map.mem_encs);

     

       794
       794
       -
         Emitter.emit e.emitter Event.Mapping_end

     

       905
       905
       +
         | Object_basic _ -> ()

     

       906
       906
       +
         | Object_cases (_, cases) ->

     

       907
       907
       +
             let (Case_value (case_map, case_v)) = cases.enc_case (cases.enc v) in

     

       908
       908
       +
             (* Emit case tag *)

     

       909
       909
       +
             if not (cases.tag.enc_omit case_map.tag) then begin

     

       910
       910
       +
               emit e (scalar_event ~value:cases.tag.name ~style:`Plain ());

     

       911
       911
       +
               encode e cases.tag.type' case_map.tag

     

       912
       912
       +
             end;

     

       913
       913
       +
             (* Emit case members *)

     

       914
       914
       +
             List.iter

     

       915
       915
       +
               (fun (Mem_enc mem) ->

     

       916
       916
       +
                 let mem_v = mem.enc case_v in

     

       917
       917
       +
                 if not (mem.enc_omit mem_v) then begin

     

       918
       918
       +
                   emit e (scalar_event ~value:mem.name ~style:`Plain ());

     

       919
       919
       +
                   encode e mem.type' mem_v

     

       920
       920
       +
                 end)

     

       921
       921
       +
               case_map.object_map.mem_encs);

     

       922
       922
       +
         emit e Event.Mapping_end

     

       795
       923
        
       

     

       796
       924
        
       (* Public encode API *)

     

       797
       925
        
       

     

       798
       926
        
       let encode' ?buf:_ ?format ?indent ?explicit_doc ?scalar_style t v ~eod writer =

     

       799
       799
       -
         let config = {

     

       800
       800
       -
           Emitter.default_config with

     

       801
       801
       -
           indent = Option.value ~default:2 indent;

     

       802
       802
       -
           layout_style = (match format with

     

       803
       803
       -
             | Some Flow -> `Flow

     

       804
       804
       -
             | _ -> `Block);

     

       805
       805
       -
         } in

     

       927
       927
       +
         let config =

     

       928
       928
       +
           {

     

       929
       929
       +
             Emitter.default_config with

     

       930
       930
       +
             indent = Option.value ~default:2 indent;

     

       931
       931
       +
             layout_style = (match format with Some Flow -> `Flow | _ -> `Block);

     

       932
       932
       +
           }

     

       933
       933
       +
         in

     

       806
       934
        
         let emitter = Emitter.of_writer ~config writer in

     

       807
       935
        
         let e = make_encoder ?format ?indent ?explicit_doc ?scalar_style emitter in

     

       808
       936
        
         try

     

       809
       809
       -
           Emitter.emit e.emitter (Event.Stream_start { encoding = `Utf8 });

     

       810
       810
       -
           Emitter.emit e.emitter (Event.Document_start {

     

       811
       811
       -
             version = None;

     

       812
       812
       -
             implicit = not e.explicit_doc;

     

       813
       813
       -
           });

     

       937
       937
       +
           emit e (Event.Stream_start { encoding = `Utf8 });

     

       938
       938
       +
           emit e (Event.Document_start { version = None; implicit = not e.explicit_doc });

     

       814
       939
        
           let t' = Jsont.Repr.of_t t in

     

       815
       940
        
           encode e t' v;

     

       816
       816
       -
           Emitter.emit e.emitter (Event.Document_end { implicit = not e.explicit_doc });

     

       817
       817
       -
           Emitter.emit e.emitter Event.Stream_end;

     

       941
       941
       +
           emit e (Event.Document_end { implicit = not e.explicit_doc });

     

       942
       942
       +
           emit e Event.Stream_end;

     

       818
       943
        
           if eod then Emitter.flush e.emitter;

     

       819
       944
        
           Ok ()

     

       820
       945
        
         with

     

       821
       946
        
         | Jsont.Error err -> Error err

     

       822
       947
        
         | Error.Yamlrw_error err ->

     

       823
       948
        
             let msg = Error.to_string err in

     

       824
       824
       -
             Error (Jsont.Error.make_msg Jsont.Error.Context.empty Jsont.Meta.none msg)

     

       949
       949
       +
             Error Jsont.(Error.make_msg Error.Context.empty Meta.none msg)

     

       825
       950
        
       

     

       826
       951
        
       let encode ?buf ?format ?indent ?explicit_doc ?scalar_style t v ~eod writer =

     

       827
       952
        
         Result.map_error Jsont.Error.to_string

     

       828
       953
        
           (encode' ?buf ?format ?indent ?explicit_doc ?scalar_style t v ~eod writer)

     

       829
       829
       -
       

     

       830
       830
       -
       let encode_string' ?buf ?format ?indent ?explicit_doc ?scalar_style t v =

     

       831
       831
       -
         let b = Buffer.create 256 in

     

       832
       832
       -
         let writer = Bytes.Writer.of_buffer b in

     

       833
       833
       -
         match encode' ?buf ?format ?indent ?explicit_doc ?scalar_style t v ~eod:true writer with

     

       834
       834
       -
         | Ok () -> Ok (Buffer.contents b)

     

       835
       835
       -
         | Error e -> Error e

     

       836
       836
       -
       

     

       837
       837
       -
       let encode_string ?buf ?format ?indent ?explicit_doc ?scalar_style t v =

     

       838
       838
       -
         Result.map_error Jsont.Error.to_string

     

       839
       839
       -
           (encode_string' ?buf ?format ?indent ?explicit_doc ?scalar_style t v)

     

       840
       954
        
       

     

       841
       955
        
       (* Recode *)

     

       842
       956
        
       

     

       843
       843
       -
       let recode ?layout ?locs ?file ?max_depth ?max_nodes

     

       844
       844
       -
           ?buf ?format ?indent ?explicit_doc ?scalar_style t reader writer ~eod =

     

       845
       845
       -
         let format = match layout, format with

     

       846
       846
       -
           | Some true, None -> Some Layout

     

       847
       847
       -
           | _, f -> f

     

       957
       957
       +
       let recode ?layout ?locs ?file ?max_depth ?max_nodes ?buf ?format ?indent

     

       958
       958
       +
           ?explicit_doc ?scalar_style t reader writer ~eod =

     

       959
       959
       +
         let format =

     

       960
       960
       +
           match (layout, format) with Some true, None -> Some Layout | _, f -> f

     

       848
       961
        
         in

     

       849
       849
       -
         let layout = match layout, format with

     

       850
       850
       -
           | None, Some Layout -> Some true

     

       851
       851
       -
           | l, _ -> l

     

       962
       962
       +
         let layout =

     

       963
       963
       +
           match (layout, format) with None, Some Layout -> Some true | l, _ -> l

     

       852
       964
        
         in

     

       853
       965
        
         match decode' ?layout ?locs ?file ?max_depth ?max_nodes t reader with

     

       854
       854
       -
         | Ok v -> encode ?buf ?format ?indent ?explicit_doc ?scalar_style t v ~eod writer

     

       855
       855
       -
         | Error e -> Error (Jsont.Error.to_string e)

     

       856
       856
       -
       

     

       857
       857
       -
       let recode_string ?layout ?locs ?file ?max_depth ?max_nodes

     

       858
       858
       -
           ?buf ?format ?indent ?explicit_doc ?scalar_style t s =

     

       859
       859
       -
         let format = match layout, format with

     

       860
       860
       -
           | Some true, None -> Some Layout

     

       861
       861
       -
           | _, f -> f

     

       862
       862
       -
         in

     

       863
       863
       -
         let layout = match layout, format with

     

       864
       864
       -
           | None, Some Layout -> Some true

     

       865
       865
       -
           | l, _ -> l

     

       866
       866
       -
         in

     

       867
       867
       -
         match decode_string' ?layout ?locs ?file ?max_depth ?max_nodes t s with

     

       868
       868
       -
         | Ok v -> encode_string ?buf ?format ?indent ?explicit_doc ?scalar_style t v

     

       966
       966
       +
         | Ok v ->

     

       967
       967
       +
             encode ?buf ?format ?indent ?explicit_doc ?scalar_style t v ~eod writer

     

       869
       968
        
         | Error e -> Error (Jsont.Error.to_string e)

+176 -104

lib/yamlt.mli

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** YAML codec using Jsont type descriptions.

     

       7
       7
        
       

     

       8
       8
       -
           This module provides YAML streaming encode/decode that interprets

     

       9
       9
       -
           {!Jsont.t} type descriptions, allowing the same codec definitions

     

       10
       10
       -
           to work for both JSON and YAML.

     

       8
       8
       +
           This module provides YAML streaming encode/decode that interprets {!Jsont.t}

     

       9
       9
       +
           type descriptions, allowing the same codec definitions to work for both JSON

     

       10
       10
       +
           and YAML.

     

       11
       11
        
       

     

       12
       12
        
           {b Example:}

     

       13
       13
        
           {[

     

       14
       14
        
             (* Define a codec once using Jsont *)

     

       15
       15
        
             module Config = struct

     

       16
       16
       -
               type t = { name: string; port: int }

     

       16
       16
       +
               type t = { name : string; port : int }

     

       17
       17
       +
       

     

       17
       18
        
               let make name port = { name; port }

     

       19
       19
       +
       

     

       18
       20
        
               let jsont =

     

       19
       21
        
                 Jsont.Object.map ~kind:"Config" make

     

       20
       22
        
                 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun c -> c.name)

     
···

       27
       29
        
             let from_yaml = Yamlt.decode_string Config.jsont yaml_str

     

       28
       30
        
           ]}

     

       29
       31
        
       

     

       30
       30
       -
           See notes about {{!yaml_mapping}YAML to JSON mapping} and

     

       31
       31
       -
           {{!yaml_scalars}YAML scalar resolution}.

     

       32
       32
       -
       *)

     

       32
       32
       +
           See notes about {{!yaml_mapping}YAML to JSON mapping},

     

       33
       33
       +
           {{!yaml_scalars}YAML scalar resolution}, and

     

       34
       34
       +
           {{!null_handling}null value handling}. *)

     

       33
       35
        
       

     

       34
       36
        
       open Bytesrw

     

       35
       37
        
       

     

       36
       38
        
       (** {1:decode Decode} *)

     

       37
       39
        
       

     

       38
       40
        
       val decode :

     

       39
       39
       -
         ?layout:bool -> ?locs:bool -> ?file:Jsont.Textloc.fpath ->

     

       40
       40
       -
         ?max_depth:int -> ?max_nodes:int ->

     

       41
       41
       -
         'a Jsont.t -> Bytes.Reader.t -> ('a, string) result

     

       41
       41
       +
         ?layout:bool ->

     

       42
       42
       +
         ?locs:bool ->

     

       43
       43
       +
         ?file:Jsont.Textloc.fpath ->

     

       44
       44
       +
         ?max_depth:int ->

     

       45
       45
       +
         ?max_nodes:int ->

     

       46
       46
       +
         'a Jsont.t ->

     

       47
       47
       +
         Bytes.Reader.t ->

     

       48
       48
       +
         ('a, string) result

     

       42
       49
        
       (** [decode t r] decodes a value from YAML reader [r] according to type [t].

     

       43
       43
       -
           {ul

     

       44
       44
       -
           {- If [layout] is [true], style information is preserved in {!Jsont.Meta.t}

     

       45
       45
       -
              values (for potential round-tripping). Defaults to [false].}

     

       46
       46
       -
           {- If [locs] is [true], source locations are preserved in {!Jsont.Meta.t}

     

       47
       47
       -
              values and error messages are precisely located. Defaults to [false].}

     

       48
       48
       -
           {- [file] is the file path for error messages.

     

       49
       49
       -
              Defaults to {!Jsont.Textloc.file_none}.}

     

       50
       50
       -
           {- [max_depth] limits nesting depth to prevent stack overflow

     

       51
       51
       -
              (billion laughs protection). Defaults to [100].}

     

       52
       52
       -
           {- [max_nodes] limits total decoded nodes

     

       53
       53
       -
              (billion laughs protection). Defaults to [10_000_000].}}

     

       50
       50
       +
           - If [layout] is [true], style information is preserved in {!Jsont.Meta.t}

     

       51
       51
       +
             values (for potential round-tripping). Defaults to [false].

     

       52
       52
       +
           - If [locs] is [true], source locations are preserved in {!Jsont.Meta.t}

     

       53
       53
       +
             values and error messages are precisely located. Defaults to [false].

     

       54
       54
       +
           - [file] is the file path for error messages. Defaults to

     

       55
       55
       +
             {!Jsont.Textloc.file_none}.

     

       56
       56
       +
           - [max_depth] limits nesting depth to prevent stack overflow (billion laughs

     

       57
       57
       +
             protection). Defaults to [100].

     

       58
       58
       +
           - [max_nodes] limits total decoded nodes (billion laughs protection).

     

       59
       59
       +
             Defaults to [10_000_000].

     

       54
       60
        
       

     

       55
       55
       -
           The YAML input must contain exactly one document. Multi-document

     

       56
       56
       -
           streams are not supported; use {!decode_all} for those. *)

     

       61
       61
       +
           The YAML input must contain exactly one document. Multi-document streams are

     

       62
       62
       +
           not supported; use {!decode_all} for those. *)

     

       57
       63
        
       

     

       58
       64
        
       val decode' :

     

       59
       59
       -
         ?layout:bool -> ?locs:bool -> ?file:Jsont.Textloc.fpath ->

     

       60
       60
       -
         ?max_depth:int -> ?max_nodes:int ->

     

       61
       61
       -
         'a Jsont.t -> Bytes.Reader.t -> ('a, Jsont.Error.t) result

     

       65
       65
       +
         ?layout:bool ->

     

       66
       66
       +
         ?locs:bool ->

     

       67
       67
       +
         ?file:Jsont.Textloc.fpath ->

     

       68
       68
       +
         ?max_depth:int ->

     

       69
       69
       +
         ?max_nodes:int ->

     

       70
       70
       +
         'a Jsont.t ->

     

       71
       71
       +
         Bytes.Reader.t ->

     

       72
       72
       +
         ('a, Jsont.Error.t) result

     

       62
       73
        
       (** [decode'] is like {!val-decode} but preserves the error structure. *)

     

       63
       74
        
       

     

       64
       64
       -
       val decode_string :

     

       65
       65
       -
         ?layout:bool -> ?locs:bool -> ?file:Jsont.Textloc.fpath ->

     

       66
       66
       -
         ?max_depth:int -> ?max_nodes:int ->

     

       67
       67
       -
         'a Jsont.t -> string -> ('a, string) result

     

       68
       68
       -
       (** [decode_string] is like {!val-decode} but decodes directly from a string. *)

     

       75
       75
       +
       val decode_all :

     

       76
       76
       +
         ?layout:bool ->

     

       77
       77
       +
         ?locs:bool ->

     

       78
       78
       +
         ?file:Jsont.Textloc.fpath ->

     

       79
       79
       +
         ?max_depth:int ->

     

       80
       80
       +
         ?max_nodes:int ->

     

       81
       81
       +
         'a Jsont.t ->

     

       82
       82
       +
         Bytes.Reader.t ->

     

       83
       83
       +
         ('a, string) result Seq.t

     

       84
       84
       +
       (** [decode_all t r] decodes all documents from a multi-document YAML stream.

     

       85
       85
       +
           Returns a sequence where each element is a result of decoding one document.

     

       86
       86
       +
           Parameters are as in {!val-decode}. Use this for YAML streams containing

     

       87
       87
       +
           multiple documents separated by [---]. *)

     

       69
       88
        
       

     

       70
       70
       -
       val decode_string' :

     

       71
       71
       -
         ?layout:bool -> ?locs:bool -> ?file:Jsont.Textloc.fpath ->

     

       72
       72
       -
         ?max_depth:int -> ?max_nodes:int ->

     

       73
       73
       -
         'a Jsont.t -> string -> ('a, Jsont.Error.t) result

     

       74
       74
       -
       (** [decode_string'] is like {!val-decode'} but decodes directly from a string. *)

     

       89
       89
       +
       val decode_all' :

     

       90
       90
       +
         ?layout:bool ->

     

       91
       91
       +
         ?locs:bool ->

     

       92
       92
       +
         ?file:Jsont.Textloc.fpath ->

     

       93
       93
       +
         ?max_depth:int ->

     

       94
       94
       +
         ?max_nodes:int ->

     

       95
       95
       +
         'a Jsont.t ->

     

       96
       96
       +
         Bytes.Reader.t ->

     

       97
       97
       +
         ('a, Jsont.Error.t) result Seq.t

     

       98
       98
       +
       (** [decode_all'] is like {!val-decode_all} but preserves the error structure. *)

     

       75
       99
        
       

     

       76
       100
        
       (** {1:encode Encode} *)

     

       77
       101
        
       

     

       78
       102
        
       (** YAML output format. *)

     

       79
       103
        
       type yaml_format =

     

       80
       80
       -
         | Block   (** Block style (indented) - default. Clean, readable YAML. *)

     

       81
       81
       -
         | Flow    (** Flow style (JSON-like). Compact, single-line collections. *)

     

       104
       104
       +
         | Block  (** Block style (indented) - default. Clean, readable YAML. *)

     

       105
       105
       +
         | Flow  (** Flow style (JSON-like). Compact, single-line collections. *)

     

       82
       106
        
         | Layout  (** Preserve layout from {!Jsont.Meta.t} when available. *)

     

       83
       107
        
       

     

       84
       108
        
       val encode :

     

       85
       85
       -
         ?buf:Stdlib.Bytes.t -> ?format:yaml_format -> ?indent:int ->

     

       86
       86
       -
         ?explicit_doc:bool -> ?scalar_style:Yamlrw.Scalar_style.t ->

     

       87
       87
       -
         'a Jsont.t -> 'a -> eod:bool -> Bytes.Writer.t -> (unit, string) result

     

       109
       109
       +
         ?buf:Stdlib.Bytes.t ->

     

       110
       110
       +
         ?format:yaml_format ->

     

       111
       111
       +
         ?indent:int ->

     

       112
       112
       +
         ?explicit_doc:bool ->

     

       113
       113
       +
         ?scalar_style:Yamlrw.Scalar_style.t ->

     

       114
       114
       +
         'a Jsont.t ->

     

       115
       115
       +
         'a ->

     

       116
       116
       +
         eod:bool ->

     

       117
       117
       +
         Bytes.Writer.t ->

     

       118
       118
       +
         (unit, string) result

     

       88
       119
        
       (** [encode t v w] encodes value [v] according to type [t] to YAML on [w].

     

       89
       89
       -
           {ul

     

       90
       90
       -
           {- If [buf] is specified, it is used as a buffer for output slices.

     

       91
       91
       -
              Defaults to a buffer of length {!Bytesrw.Bytes.Writer.slice_length}[ w].}

     

       92
       92
       -
           {- [format] controls the output style. Defaults to {!Block}.}

     

       93
       93
       -
           {- [indent] is the indentation width in spaces. Defaults to [2].}

     

       94
       94
       -
           {- [explicit_doc] if [true], emits explicit document markers

     

       95
       95
       -
              ([---] and [...]). Defaults to [false].}

     

       96
       96
       -
           {- [scalar_style] is the preferred style for string scalars.

     

       97
       97
       -
              Defaults to [`Any] (auto-detect based on content).}

     

       98
       98
       -
           {- [eod] indicates whether {!Bytesrw.Bytes.Slice.eod} should be

     

       99
       99
       -
              written on [w] after encoding.}} *)

     

       120
       120
       +
           - If [buf] is specified, it is used as a buffer for output slices. Defaults

     

       121
       121
       +
             to a buffer of length {!Bytesrw.Bytes.Writer.slice_length}[ w].

     

       122
       122
       +
           - [format] controls the output style. Defaults to {!Block}.

     

       123
       123
       +
           - [indent] is the indentation width in spaces. Defaults to [2].

     

       124
       124
       +
           - [explicit_doc] if [true], emits explicit document markers ([---] and

     

       125
       125
       +
             [...]). Defaults to [false].

     

       126
       126
       +
           - [scalar_style] is the preferred style for string scalars. Defaults to

     

       127
       127
       +
             [`Any] (auto-detect based on content).

     

       128
       128
       +
           - [eod] indicates whether {!Bytesrw.Bytes.Slice.eod} should be written on

     

       129
       129
       +
             [w] after encoding. *)

     

       100
       130
        
       

     

       101
       131
        
       val encode' :

     

       102
       102
       -
         ?buf:Stdlib.Bytes.t -> ?format:yaml_format -> ?indent:int ->

     

       103
       103
       -
         ?explicit_doc:bool -> ?scalar_style:Yamlrw.Scalar_style.t ->

     

       104
       104
       -
         'a Jsont.t -> 'a -> eod:bool -> Bytes.Writer.t -> (unit, Jsont.Error.t) result

     

       132
       132
       +
         ?buf:Stdlib.Bytes.t ->

     

       133
       133
       +
         ?format:yaml_format ->

     

       134
       134
       +
         ?indent:int ->

     

       135
       135
       +
         ?explicit_doc:bool ->

     

       136
       136
       +
         ?scalar_style:Yamlrw.Scalar_style.t ->

     

       137
       137
       +
         'a Jsont.t ->

     

       138
       138
       +
         'a ->

     

       139
       139
       +
         eod:bool ->

     

       140
       140
       +
         Bytes.Writer.t ->

     

       141
       141
       +
         (unit, Jsont.Error.t) result

     

       105
       142
        
       (** [encode'] is like {!val-encode} but preserves the error structure. *)

     

       106
       143
        
       

     

       107
       107
       -
       val encode_string :

     

       108
       108
       -
         ?buf:Stdlib.Bytes.t -> ?format:yaml_format -> ?indent:int ->

     

       109
       109
       -
         ?explicit_doc:bool -> ?scalar_style:Yamlrw.Scalar_style.t ->

     

       110
       110
       -
         'a Jsont.t -> 'a -> (string, string) result

     

       111
       111
       -
       (** [encode_string] is like {!val-encode} but writes to a string. *)

     

       112
       112
       -
       

     

       113
       113
       -
       val encode_string' :

     

       114
       114
       -
         ?buf:Stdlib.Bytes.t -> ?format:yaml_format -> ?indent:int ->

     

       115
       115
       -
         ?explicit_doc:bool -> ?scalar_style:Yamlrw.Scalar_style.t ->

     

       116
       116
       -
         'a Jsont.t -> 'a -> (string, Jsont.Error.t) result

     

       117
       117
       -
       (** [encode_string'] is like {!val-encode'} but writes to a string. *)

     

       118
       118
       -
       

     

       119
       144
        
       (** {1:recode Recode}

     

       120
       145
        
       

     

       121
       146
        
           The defaults in these functions are those of {!val-decode} and

     

       122
       122
       -
           {!val-encode}, except if [layout] is [true], [format] defaults to

     

       123
       123
       -
           {!Layout} and vice-versa. *)

     

       147
       147
       +
           {!val-encode}, except if [layout] is [true], [format] defaults to {!Layout}

     

       148
       148
       +
           and vice-versa. *)

     

       124
       149
        
       

     

       125
       150
        
       val recode :

     

       126
       126
       -
         ?layout:bool -> ?locs:bool -> ?file:Jsont.Textloc.fpath ->

     

       127
       127
       -
         ?max_depth:int -> ?max_nodes:int ->

     

       128
       128
       -
         ?buf:Stdlib.Bytes.t -> ?format:yaml_format -> ?indent:int ->

     

       129
       129
       -
         ?explicit_doc:bool -> ?scalar_style:Yamlrw.Scalar_style.t ->

     

       130
       130
       -
         'a Jsont.t -> Bytes.Reader.t -> Bytes.Writer.t -> eod:bool ->

     

       151
       151
       +
         ?layout:bool ->

     

       152
       152
       +
         ?locs:bool ->

     

       153
       153
       +
         ?file:Jsont.Textloc.fpath ->

     

       154
       154
       +
         ?max_depth:int ->

     

       155
       155
       +
         ?max_nodes:int ->

     

       156
       156
       +
         ?buf:Stdlib.Bytes.t ->

     

       157
       157
       +
         ?format:yaml_format ->

     

       158
       158
       +
         ?indent:int ->

     

       159
       159
       +
         ?explicit_doc:bool ->

     

       160
       160
       +
         ?scalar_style:Yamlrw.Scalar_style.t ->

     

       161
       161
       +
         'a Jsont.t ->

     

       162
       162
       +
         Bytes.Reader.t ->

     

       163
       163
       +
         Bytes.Writer.t ->

     

       164
       164
       +
         eod:bool ->

     

       131
       165
        
         (unit, string) result

     

       132
       166
        
       (** [recode t r w] is {!val-decode} followed by {!val-encode}. *)

     

       133
       167
        
       

     

       134
       134
       -
       val recode_string :

     

       135
       135
       -
         ?layout:bool -> ?locs:bool -> ?file:Jsont.Textloc.fpath ->

     

       136
       136
       -
         ?max_depth:int -> ?max_nodes:int ->

     

       137
       137
       -
         ?buf:Stdlib.Bytes.t -> ?format:yaml_format -> ?indent:int ->

     

       138
       138
       -
         ?explicit_doc:bool -> ?scalar_style:Yamlrw.Scalar_style.t ->

     

       139
       139
       -
         'a Jsont.t -> string -> (string, string) result

     

       140
       140
       -
       (** [recode_string] is like {!val-recode} but operates on strings. *)

     

       141
       141
       -
       

     

       142
       168
        
       (** {1:yaml_mapping YAML to JSON Mapping}

     

       143
       169
        
       

     

       144
       144
       -
           YAML is a superset of JSON. This module maps YAML structures to

     

       145
       145
       -
           the JSON data model that {!Jsont.t} describes:

     

       170
       170
       +
           YAML is a superset of JSON. This module maps YAML structures to the JSON

     

       171
       171
       +
           data model that {!Jsont.t} describes:

     

       146
       172
        
       

     

       147
       147
       -
           {ul

     

       148
       148
       -
           {- YAML scalars map to JSON null, boolean, number, or string

     

       149
       149
       -
              depending on content and the expected type}

     

       150
       150
       -
           {- YAML sequences map to JSON arrays}

     

       151
       151
       -
           {- YAML mappings map to JSON objects (keys must be strings)}

     

       152
       152
       -
           {- YAML aliases are resolved during decoding}

     

       153
       153
       -
           {- YAML tags are used to guide type resolution when present}}

     

       173
       173
       +
           - YAML scalars map to JSON null, boolean, number, or string depending on

     

       174
       174
       +
             content and the expected type

     

       175
       175
       +
           - YAML sequences map to JSON arrays

     

       176
       176
       +
           - YAML mappings map to JSON objects (keys must be strings)

     

       177
       177
       +
           - YAML aliases are resolved during decoding

     

       178
       178
       +
           - YAML tags are used to guide type resolution when present

     

       154
       179
        
       

     

       155
       180
        
           {b Limitations:}

     

       156
       156
       -
           {ul

     

       157
       157
       -
           {- Only string keys are supported in mappings (JSON object compatibility)}

     

       158
       158
       -
           {- Anchors and aliases are resolved; the alias structure is not preserved}

     

       159
       159
       -
           {- Multi-document streams require {!decode_all}}} *)

     

       181
       181
       +
           - Only string keys are supported in mappings (JSON object compatibility)

     

       182
       182
       +
           - Anchors and aliases are resolved; the alias structure is not preserved

     

       183
       183
       +
           - Multi-document streams require {!decode_all} *)

     

       160
       184
        
       

     

       161
       185
        
       (** {1:yaml_scalars YAML Scalar Resolution}

     

       162
       186
        
       

     
···

       164
       188
        
       

     

       165
       189
        
           {b Null:} [null], [Null], [NULL], [~], or empty string

     

       166
       190
        
       

     

       167
       167
       -
           {b Boolean:} [true], [True], [TRUE], [false], [False], [FALSE],

     

       168
       168
       -
           [yes], [Yes], [YES], [no], [No], [NO], [on], [On], [ON],

     

       169
       169
       -
           [off], [Off], [OFF]

     

       191
       191
       +
           {b Boolean:} [true], [True], [TRUE], [false], [False], [FALSE], [yes],

     

       192
       192
       +
           [Yes], [YES], [no], [No], [NO], [on], [On], [ON], [off], [Off], [OFF]

     

       170
       193
        
       

     

       171
       194
        
           {b Number:} Decimal integers, floats, hex ([0x...]), octal ([0o...]),

     

       172
       195
        
           infinity ([.inf], [-.inf]), NaN ([.nan])

     

       173
       196
        
       

     

       174
       197
        
           {b String:} Anything else, or explicitly quoted scalars

     

       175
       198
        
       

     

       176
       176
       -
           When decoding against a specific {!Jsont.t} type, the expected type

     

       177
       177
       -
           takes precedence over automatic resolution. For example, decoding

     

       178
       178
       -
           ["yes"] against {!Jsont.string} yields the string ["yes"], not [true]. *)

     

       199
       199
       +
           When decoding against a specific {!Jsont.t} type, the expected type takes

     

       200
       200
       +
           precedence over automatic resolution. For example, decoding ["yes"] against

     

       201
       201
       +
           {!Jsont.string} yields the string ["yes"], not [true]. *)

     

       202
       202
       +
       

     

       203
       203
       +
       (** {1:null_handling Null Value Handling}

     

       204
       204
       +
       

     

       205
       205
       +
           YAML null values are handled according to the expected type to provide

     

       206
       206
       +
           friendly defaults while maintaining type safety:

     

       207
       207
       +
       

     

       208
       208
       +
           {b Collections (Arrays and Objects):}

     

       209
       209
       +
       

     

       210
       210
       +
           Null values decode as empty collections when the codec expects a collection

     

       211
       211
       +
           type. This provides convenient defaults for optional collection fields in

     

       212
       212
       +
           YAML:

     

       213
       213
       +
           {[

     

       214
       214
       +
             # YAML with null collection fields

     

       215
       215
       +
             config:

     

       216
       216
       +
               items: null      # Decodes as []

     

       217
       217
       +
               settings: ~      # Decodes as {}

     

       218
       218
       +
               tags:            # Missing value = null, decodes as []

     

       219
       219
       +
           ]}

     

       220
       220
       +
       

     

       221
       221
       +
           For arrays, null decodes to an empty array. For objects, null decodes to an

     

       222
       222
       +
           object with all fields set to their [dec_absent] defaults. If any required

     

       223
       223
       +
           field lacks a default, decoding fails with a missing member error.

     

       224
       224
       +
       

     

       225
       225
       +
           This behavior makes yamlt more forgiving for schemas with many optional

     

       226
       226
       +
           collection fields, where writing [field:] (which parses as null) is natural

     

       227
       227
       +
           and semantically equivalent to [field: []].

     

       228
       228
       +
       

     

       229
       229
       +
           {b Numbers:}

     

       230
       230
       +
       

     

       231
       231
       +
           Null values decode to [Float.nan] when the codec expects a number.

     

       232
       232
       +
       

     

       233
       233
       +
           {b Primitive Types (Int, Bool, String):}

     

       234
       234
       +
       

     

       235
       235
       +
           Null values {e fail} when decoding into primitive scalar types ([int],

     

       236
       236
       +
           [bool], [string]). Null typically indicates genuinely missing or incorrect

     

       237
       237
       +
           data for these types, and silent conversion could clash with a manual

     

       238
       238
       +
           setting of the default value (e.g. 0 and [null] for an integer would be

     

       239
       239
       +
           indistinguishable).

     

       240
       240
       +
       

     

       241
       241
       +
           To accept null for primitive fields, explicitly use {!Jsont.option}:

     

       242
       242
       +
           {[

     

       243
       243
       +
             (* Accepts null, decodes as None *)

     

       244
       244
       +
             Jsont.Object.mem "count" (Jsont.option Jsont.int) ~dec_absent:None

     

       245
       245
       +
       

     

       246
       246
       +
             (* Rejects null, requires a number *)

     

       247
       247
       +
             Jsont.Object.mem "count" Jsont.int ~dec_absent:0

     

       248
       248
       +
           ]}

     

       249
       249
       +
       

     

       250
       250
       +
       *)

+27 -1

tests/bin/dune

···

       32
       32
        
        (name test_edge)

     

       33
       33
        
        (public_name test_edge)

     

       34
       34
        
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       35
       35
       -
       (executable (name test_null_fix) (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       35
       35
       +
       

     

       36
       36
       +
       (executable

     

       37
       37
       +
        (name test_null_fix)

     

       38
       38
       +
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       36
       39
        
       

     

       37
       40
        
       (executable

     

       38
       41
        
        (name test_null_complete)

     

       39
       42
        
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       40
       43
        
       

     

       41
       44
        
       (executable

     

       45
       45
       +
        (name test_null_collections)

     

       46
       46
       +
        (public_name test_null_collections)

     

       47
       47
       +
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       48
       48
       +
       

     

       49
       49
       +
       (executable

     

       42
       50
        
        (name test_opt_array)

     

       43
       51
        
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       44
       52
        
       

     
···

       49
       57
        
       (executable

     

       50
       58
        
        (name test_some_vs_option)

     

       51
       59
        
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       60
       60
       +
       

     

       61
       61
       +
       (executable

     

       62
       62
       +
        (name test_comprehensive)

     

       63
       63
       +
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       64
       64
       +
       

     

       65
       65
       +
       (executable

     

       66
       66
       +
        (name test_flow_newline)

     

       67
       67
       +
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       68
       68
       +
       

     

       69
       69
       +
       (executable

     

       70
       70
       +
        (name test_locations)

     

       71
       71
       +
        (public_name test_locations)

     

       72
       72
       +
        (libraries yamlt jsont jsont.bytesrw bytesrw))

     

       73
       73
       +
       

     

       74
       74
       +
       (executable

     

       75
       75
       +
        (name test_multidoc)

     

       76
       76
       +
        (public_name test_multidoc)

     

       77
       77
       +
        (libraries yamlt jsont jsont.bytesrw bytesrw))

+16 -11

tests/bin/test_array_variants.ml

···

       1
       1
       +
       open Bytesrw

     

       2
       2
       +
       

     

       1
       3
        
       let () =

     

       2
       4
        
         let codec1 =

     

       3
       5
        
           Jsont.Object.map ~kind:"Test" (fun arr -> arr)

     

       4
       4
       -
           |> Jsont.Object.mem "values" (Jsont.array Jsont.string) ~enc:(fun arr -> arr)

     

       6
       6
       +
           |> Jsont.Object.mem "values" (Jsont.array Jsont.string) ~enc:(fun arr ->

     

       7
       7
       +
               arr)

     

       5
       8
        
           |> Jsont.Object.finish

     

       6
       9
        
         in

     

       7
       10
        
       

     

       8
       11
        
         let yaml1 = "values: [a, b, c]" in

     

       9
       12
        
       

     

       10
       13
        
         Printf.printf "Test 1: Non-optional array:\n";

     

       11
       11
       -
         (match Yamlt.decode_string codec1 yaml1 with

     

       12
       12
       -
          | Ok arr -> Printf.printf "Result: [%d items]\n" (Array.length arr)

     

       13
       13
       -
          | Error e -> Printf.printf "Error: %s\n" e);

     

       14
       14
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string yaml1) with

     

       15
       15
       +
         | Ok arr -> Printf.printf "Result: [%d items]\n" (Array.length arr)

     

       16
       16
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       14
       17
        
       

     

       15
       18
        
         let codec2 =

     

       16
       19
        
           Jsont.Object.map ~kind:"Test" (fun arr -> arr)

     

       17
       17
       -
           |> Jsont.Object.mem "values" (Jsont.option (Jsont.array Jsont.string)) ~enc:(fun arr -> arr)

     

       20
       20
       +
           |> Jsont.Object.mem "values"

     

       21
       21
       +
                (Jsont.option (Jsont.array Jsont.string))

     

       22
       22
       +
                ~enc:(fun arr -> arr)

     

       18
       23
        
           |> Jsont.Object.finish

     

       19
       24
        
         in

     

       20
       25
        
       

     

       21
       26
        
         Printf.printf "\nTest 2: Jsont.option (Jsont.array):\n";

     

       22
       22
       -
         (match Yamlt.decode_string codec2 yaml1 with

     

       23
       23
       -
          | Ok arr ->

     

       24
       24
       -
              (match arr with

     

       25
       25
       -
               | None -> Printf.printf "Result: None\n"

     

       26
       26
       -
               | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       27
       27
       -
          | Error e -> Printf.printf "Error: %s\n" e)

     

       27
       27
       +
         match Yamlt.decode codec2 (Bytes.Reader.of_string yaml1) with

     

       28
       28
       +
         | Ok arr -> (

     

       29
       29
       +
             match arr with

     

       30
       30
       +
             | None -> Printf.printf "Result: None\n"

     

       31
       31
       +
             | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       32
       32
       +
         | Error e -> Printf.printf "Error: %s\n" e

+88 -92

tests/bin/test_arrays.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** Test array codec functionality with Yamlt *)

     

       7
       7
        
       

     

       8
       8
       +
       open Bytesrw

     

       8
       9
        
       

     

       9
       10
        
       (* Helper to read file *)

     

       10
       11
        
       let read_file path =

     
···

       28
       29
        
       (* Test: Simple int array *)

     

       29
       30
        
       let test_int_array file =

     

       30
       31
        
         let module M = struct

     

       31
       31
       -
           type numbers = { values: int array }

     

       32
       32
       +
           type numbers = { values : int array }

     

       32
       33
        
       

     

       33
       34
        
           let numbers_codec =

     

       34
       35
        
             Jsont.Object.map ~kind:"Numbers" (fun values -> { values })

     

       35
       35
       -
             |> Jsont.Object.mem "values" (Jsont.array Jsont.int) ~enc:(fun n -> n.values)

     

       36
       36
       +
             |> Jsont.Object.mem "values" (Jsont.array Jsont.int) ~enc:(fun n ->

     

       37
       37
       +
                 n.values)

     

       36
       38
        
             |> Jsont.Object.finish

     

       37
       39
        
       

     

       38
       40
        
           let show n =

     

       39
       39
       -
             Printf.sprintf "[%s]" (String.concat "; " (Array.to_list (Array.map string_of_int n.values)))

     

       41
       41
       +
             Printf.sprintf "[%s]"

     

       42
       42
       +
               (String.concat "; " (Array.to_list (Array.map string_of_int n.values)))

     

       40
       43
        
         end in

     

       41
       41
       -
       

     

       42
       44
        
         let yaml = read_file file in

     

       43
       45
        
         let json = read_file (file ^ ".json") in

     

       44
       46
        
         let json_result = Jsont_bytesrw.decode_string M.numbers_codec json in

     

       45
       45
       -
         let yaml_result = Yamlt.decode_string M.numbers_codec yaml in

     

       47
       47
       +
         let yaml_result = Yamlt.decode M.numbers_codec (Bytes.Reader.of_string yaml) in

     

       46
       48
        
       

     

       47
       49
        
         show_result_both "int_array"

     

       48
       50
        
           (Result.map M.show json_result)

     
···

       51
       53
        
       (* Test: String array *)

     

       52
       54
        
       let test_string_array file =

     

       53
       55
        
         let module M = struct

     

       54
       54
       -
           type tags = { items: string array }

     

       56
       56
       +
           type tags = { items : string array }

     

       55
       57
        
       

     

       56
       58
        
           let tags_codec =

     

       57
       59
        
             Jsont.Object.map ~kind:"Tags" (fun items -> { items })

     

       58
       58
       -
             |> Jsont.Object.mem "items" (Jsont.array Jsont.string) ~enc:(fun t -> t.items)

     

       60
       60
       +
             |> Jsont.Object.mem "items" (Jsont.array Jsont.string) ~enc:(fun t ->

     

       61
       61
       +
                 t.items)

     

       59
       62
        
             |> Jsont.Object.finish

     

       60
       63
        
       

     

       61
       64
        
           let show t =

     

       62
       62
       -
             Printf.sprintf "[%s]" (String.concat "; " (Array.to_list (Array.map (Printf.sprintf "%S") t.items)))

     

       65
       65
       +
             Printf.sprintf "[%s]"

     

       66
       66
       +
               (String.concat "; "

     

       67
       67
       +
                  (Array.to_list (Array.map (Printf.sprintf "%S") t.items)))

     

       63
       68
        
         end in

     

       64
       64
       -
       

     

       65
       69
        
         let yaml = read_file file in

     

       66
       70
        
         let json = read_file (file ^ ".json") in

     

       67
       71
        
         let json_result = Jsont_bytesrw.decode_string M.tags_codec json in

     

       68
       68
       -
         let yaml_result = Yamlt.decode_string M.tags_codec yaml in

     

       72
       72
       +
         let yaml_result = Yamlt.decode M.tags_codec (Bytes.Reader.of_string yaml) in

     

       69
       73
        
       

     

       70
       74
        
         show_result_both "string_array"

     

       71
       75
        
           (Result.map M.show json_result)

     
···

       74
       78
        
       (* Test: Float/number array *)

     

       75
       79
        
       let test_float_array file =

     

       76
       80
        
         let module M = struct

     

       77
       77
       -
           type measurements = { values: float array }

     

       81
       81
       +
           type measurements = { values : float array }

     

       78
       82
        
       

     

       79
       83
        
           let measurements_codec =

     

       80
       84
        
             Jsont.Object.map ~kind:"Measurements" (fun values -> { values })

     

       81
       81
       -
             |> Jsont.Object.mem "values" (Jsont.array Jsont.number) ~enc:(fun m -> m.values)

     

       85
       85
       +
             |> Jsont.Object.mem "values" (Jsont.array Jsont.number) ~enc:(fun m ->

     

       86
       86
       +
                 m.values)

     

       82
       87
        
             |> Jsont.Object.finish

     

       83
       88
        
       

     

       84
       89
        
           let show m =

     

       85
       90
        
             Printf.sprintf "[%s]"

     

       86
       86
       -
               (String.concat "; " (Array.to_list (Array.map (Printf.sprintf "%.2f") m.values)))

     

       91
       91
       +
               (String.concat "; "

     

       92
       92
       +
                  (Array.to_list (Array.map (Printf.sprintf "%.2f") m.values)))

     

       87
       93
        
         end in

     

       88
       88
       -
       

     

       89
       94
        
         let yaml = read_file file in

     

       90
       95
        
         let json = read_file (file ^ ".json") in

     

       91
       96
        
         let json_result = Jsont_bytesrw.decode_string M.measurements_codec json in

     

       92
       92
       -
         let yaml_result = Yamlt.decode_string M.measurements_codec yaml in

     

       97
       97
       +
         let yaml_result = Yamlt.decode M.measurements_codec (Bytes.Reader.of_string yaml) in

     

       93
       98
        
       

     

       94
       99
        
         show_result_both "float_array"

     

       95
       100
        
           (Result.map M.show json_result)

     
···

       98
       103
        
       (* Test: Empty array *)

     

       99
       104
        
       let test_empty_array file =

     

       100
       105
        
         let module M = struct

     

       101
       101
       -
           type empty = { items: int array }

     

       106
       106
       +
           type empty = { items : int array }

     

       102
       107
        
       

     

       103
       108
        
           let empty_codec =

     

       104
       109
        
             Jsont.Object.map ~kind:"Empty" (fun items -> { items })

     

       105
       105
       -
             |> Jsont.Object.mem "items" (Jsont.array Jsont.int) ~enc:(fun e -> e.items)

     

       110
       110
       +
             |> Jsont.Object.mem "items" (Jsont.array Jsont.int) ~enc:(fun e ->

     

       111
       111
       +
                 e.items)

     

       106
       112
        
             |> Jsont.Object.finish

     

       107
       113
        
       

     

       108
       108
       -
           let show e =

     

       109
       109
       -
             Printf.sprintf "length=%d" (Stdlib.Array.length e.items)

     

       114
       114
       +
           let show e = Printf.sprintf "length=%d" (Stdlib.Array.length e.items)

     

       110
       115
        
         end in

     

       111
       111
       -
       

     

       112
       116
        
         let yaml = read_file file in

     

       113
       117
        
         let json = read_file (file ^ ".json") in

     

       114
       118
        
         let json_result = Jsont_bytesrw.decode_string M.empty_codec json in

     

       115
       115
       -
         let yaml_result = Yamlt.decode_string M.empty_codec yaml in

     

       119
       119
       +
         let yaml_result = Yamlt.decode M.empty_codec (Bytes.Reader.of_string yaml) in

     

       116
       120
        
       

     

       117
       121
        
         show_result_both "empty_array"

     

       118
       122
        
           (Result.map M.show json_result)

     
···

       121
       125
        
       (* Test: Array of objects *)

     

       122
       126
        
       let test_object_array file =

     

       123
       127
        
         let module M = struct

     

       124
       124
       -
           type person = { name: string; age: int }

     

       125
       125
       -
           type people = { persons: person array }

     

       128
       128
       +
           type person = { name : string; age : int }

     

       129
       129
       +
           type people = { persons : person array }

     

       126
       130
        
       

     

       127
       131
        
           let person_codec =

     

       128
       132
        
             Jsont.Object.map ~kind:"Person" (fun name age -> { name; age })

     
···

       132
       136
        
       

     

       133
       137
        
           let people_codec =

     

       134
       138
        
             Jsont.Object.map ~kind:"People" (fun persons -> { persons })

     

       135
       135
       -
             |> Jsont.Object.mem "persons" (Jsont.array person_codec) ~enc:(fun p -> p.persons)

     

       139
       139
       +
             |> Jsont.Object.mem "persons" (Jsont.array person_codec) ~enc:(fun p ->

     

       140
       140
       +
                 p.persons)

     

       136
       141
        
             |> Jsont.Object.finish

     

       137
       142
        
       

     

       138
       143
        
           let show_person p = Printf.sprintf "{%s,%d}" p.name p.age

     

       144
       144
       +
       

     

       139
       145
        
           let show ps =

     

       140
       146
        
             Printf.sprintf "[%s]"

     

       141
       147
        
               (String.concat "; " (Array.to_list (Array.map show_person ps.persons)))

     

       142
       148
        
         end in

     

       143
       143
       -
       

     

       144
       149
        
         let yaml = read_file file in

     

       145
       150
        
         let json = read_file (file ^ ".json") in

     

       146
       151
        
         let json_result = Jsont_bytesrw.decode_string M.people_codec json in

     

       147
       147
       -
         let yaml_result = Yamlt.decode_string M.people_codec yaml in

     

       152
       152
       +
         let yaml_result = Yamlt.decode M.people_codec (Bytes.Reader.of_string yaml) in

     

       148
       153
        
       

     

       149
       154
        
         show_result_both "object_array"

     

       150
       155
        
           (Result.map M.show json_result)

     
···

       153
       158
        
       (* Test: Nested arrays *)

     

       154
       159
        
       let test_nested_arrays file =

     

       155
       160
        
         let module M = struct

     

       156
       156
       -
           type matrix = { data: int array array }

     

       161
       161
       +
           type matrix = { data : int array array }

     

       157
       162
        
       

     

       158
       163
        
           let matrix_codec =

     

       159
       164
        
             Jsont.Object.map ~kind:"Matrix" (fun data -> { data })

     

       160
       160
       -
             |> Jsont.Object.mem "data" (Jsont.array (Jsont.array Jsont.int))

     

       161
       161
       -
                 ~enc:(fun m -> m.data)

     

       165
       165
       +
             |> Jsont.Object.mem "data"

     

       166
       166
       +
                  (Jsont.array (Jsont.array Jsont.int))

     

       167
       167
       +
                  ~enc:(fun m -> m.data)

     

       162
       168
        
             |> Jsont.Object.finish

     

       163
       169
        
       

     

       164
       170
        
           let show_row row =

     

       165
       165
       -
             Printf.sprintf "[%s]" (String.concat "; " (Array.to_list (Array.map string_of_int row)))

     

       171
       171
       +
             Printf.sprintf "[%s]"

     

       172
       172
       +
               (String.concat "; " (Array.to_list (Array.map string_of_int row)))

     

       166
       173
        
       

     

       167
       174
        
           let show m =

     

       168
       168
       -
             Printf.sprintf "[%s]" (String.concat "; " (Array.to_list (Array.map show_row m.data)))

     

       175
       175
       +
             Printf.sprintf "[%s]"

     

       176
       176
       +
               (String.concat "; " (Array.to_list (Array.map show_row m.data)))

     

       169
       177
        
         end in

     

       170
       170
       -
       

     

       171
       178
        
         let yaml = read_file file in

     

       172
       179
        
         let json = read_file (file ^ ".json") in

     

       173
       180
        
         let json_result = Jsont_bytesrw.decode_string M.matrix_codec json in

     

       174
       174
       -
         let yaml_result = Yamlt.decode_string M.matrix_codec yaml in

     

       181
       181
       +
         let yaml_result = Yamlt.decode M.matrix_codec (Bytes.Reader.of_string yaml) in

     

       175
       182
        
       

     

       176
       183
        
         show_result_both "nested_arrays"

     

       177
       184
        
           (Result.map M.show json_result)

     
···

       180
       187
        
       (* Test: Mixed types in array (should fail with homogeneous codec) *)

     

       181
       188
        
       let test_type_mismatch file =

     

       182
       189
        
         let module M = struct

     

       183
       183
       -
           type numbers = { values: int array }

     

       190
       190
       +
           type numbers = { values : int array }

     

       184
       191
        
       

     

       185
       192
        
           let numbers_codec =

     

       186
       193
        
             Jsont.Object.map ~kind:"Numbers" (fun values -> { values })

     

       187
       187
       -
             |> Jsont.Object.mem "values" (Jsont.array Jsont.int) ~enc:(fun n -> n.values)

     

       194
       194
       +
             |> Jsont.Object.mem "values" (Jsont.array Jsont.int) ~enc:(fun n ->

     

       195
       195
       +
                 n.values)

     

       188
       196
        
             |> Jsont.Object.finish

     

       189
       197
        
         end in

     

       190
       190
       -
       

     

       191
       198
        
         let yaml = read_file file in

     

       192
       192
       -
         let result = Yamlt.decode_string M.numbers_codec yaml in

     

       199
       199
       +
         let result = Yamlt.decode M.numbers_codec (Bytes.Reader.of_string yaml) in

     

       193
       200
        
         match result with

     

       194
       201
        
         | Ok _ -> Printf.printf "Unexpected success\n"

     

       195
       202
        
         | Error e -> Printf.printf "Expected error: %s\n" e

     
···

       197
       204
        
       (* Test: Bool array *)

     

       198
       205
        
       let test_bool_array file =

     

       199
       206
        
         let module M = struct

     

       200
       200
       -
           type flags = { values: bool array }

     

       207
       207
       +
           type flags = { values : bool array }

     

       201
       208
        
       

     

       202
       209
        
           let flags_codec =

     

       203
       210
        
             Jsont.Object.map ~kind:"Flags" (fun values -> { values })

     

       204
       204
       -
             |> Jsont.Object.mem "values" (Jsont.array Jsont.bool) ~enc:(fun f -> f.values)

     

       211
       211
       +
             |> Jsont.Object.mem "values" (Jsont.array Jsont.bool) ~enc:(fun f ->

     

       212
       212
       +
                 f.values)

     

       205
       213
        
             |> Jsont.Object.finish

     

       206
       214
        
       

     

       207
       215
        
           let show f =

     

       208
       216
        
             Printf.sprintf "[%s]"

     

       209
       217
        
               (String.concat "; " (Array.to_list (Array.map string_of_bool f.values)))

     

       210
       218
        
         end in

     

       211
       211
       -
       

     

       212
       219
        
         let yaml = read_file file in

     

       213
       220
        
         let json = read_file (file ^ ".json") in

     

       214
       221
        
         let json_result = Jsont_bytesrw.decode_string M.flags_codec json in

     

       215
       215
       -
         let yaml_result = Yamlt.decode_string M.flags_codec yaml in

     

       222
       222
       +
         let yaml_result = Yamlt.decode M.flags_codec (Bytes.Reader.of_string yaml) in

     

       216
       223
        
       

     

       217
       224
        
         show_result_both "bool_array"

     

       218
       225
        
           (Result.map M.show json_result)

     
···

       221
       228
        
       (* Test: Array with nulls *)

     

       222
       229
        
       let test_nullable_array file =

     

       223
       230
        
         let module M = struct

     

       224
       224
       -
           type nullable = { values: string option array }

     

       231
       231
       +
           type nullable = { values : string option array }

     

       225
       232
        
       

     

       226
       233
        
           let nullable_codec =

     

       227
       234
        
             Jsont.Object.map ~kind:"Nullable" (fun values -> { values })

     

       228
       228
       -
             |> Jsont.Object.mem "values" (Jsont.array (Jsont.some Jsont.string))

     

       229
       229
       -
                 ~enc:(fun n -> n.values)

     

       235
       235
       +
             |> Jsont.Object.mem "values"

     

       236
       236
       +
                  (Jsont.array (Jsont.some Jsont.string))

     

       237
       237
       +
                  ~enc:(fun n -> n.values)

     

       230
       238
        
             |> Jsont.Object.finish

     

       231
       239
        
       

     

       232
       232
       -
           let show_opt = function

     

       233
       233
       -
             | None -> "null"

     

       234
       234
       -
             | Some s -> Printf.sprintf "%S" s

     

       240
       240
       +
           let show_opt = function None -> "null" | Some s -> Printf.sprintf "%S" s

     

       235
       241
        
       

     

       236
       242
        
           let show n =

     

       237
       237
       -
             Printf.sprintf "[%s]" (String.concat "; " (Array.to_list (Array.map show_opt n.values)))

     

       243
       243
       +
             Printf.sprintf "[%s]"

     

       244
       244
       +
               (String.concat "; " (Array.to_list (Array.map show_opt n.values)))

     

       238
       245
        
         end in

     

       239
       239
       -
       

     

       240
       246
        
         let yaml = read_file file in

     

       241
       247
        
         let json = read_file (file ^ ".json") in

     

       242
       248
        
         let json_result = Jsont_bytesrw.decode_string M.nullable_codec json in

     

       243
       243
       -
         let yaml_result = Yamlt.decode_string M.nullable_codec yaml in

     

       249
       249
       +
         let yaml_result = Yamlt.decode M.nullable_codec (Bytes.Reader.of_string yaml) in

     

       244
       250
        
       

     

       245
       251
        
         show_result_both "nullable_array"

     

       246
       252
        
           (Result.map M.show json_result)

     
···

       249
       255
        
       (* Test: Encoding arrays to different formats *)

     

       250
       256
        
       let test_encode_arrays () =

     

       251
       257
        
         let module M = struct

     

       252
       252
       -
           type data = { numbers: int array; strings: string array }

     

       258
       258
       +
           type data = { numbers : int array; strings : string array }

     

       253
       259
        
       

     

       254
       260
        
           let data_codec =

     

       255
       255
       -
             Jsont.Object.map ~kind:"Data" (fun numbers strings -> { numbers; strings })

     

       256
       256
       -
             |> Jsont.Object.mem "numbers" (Jsont.array Jsont.int) ~enc:(fun d -> d.numbers)

     

       257
       257
       -
             |> Jsont.Object.mem "strings" (Jsont.array Jsont.string) ~enc:(fun d -> d.strings)

     

       261
       261
       +
             Jsont.Object.map ~kind:"Data" (fun numbers strings ->

     

       262
       262
       +
                 { numbers; strings })

     

       263
       263
       +
             |> Jsont.Object.mem "numbers" (Jsont.array Jsont.int) ~enc:(fun d ->

     

       264
       264
       +
                 d.numbers)

     

       265
       265
       +
             |> Jsont.Object.mem "strings" (Jsont.array Jsont.string) ~enc:(fun d ->

     

       266
       266
       +
                 d.strings)

     

       258
       267
        
             |> Jsont.Object.finish

     

       259
       268
        
         end in

     

       260
       260
       -
       

     

       261
       261
       -
         let data = { M.numbers = [|1; 2; 3; 4; 5|]; strings = [|"hello"; "world"|] } in

     

       269
       269
       +
         let data =

     

       270
       270
       +
           { M.numbers = [| 1; 2; 3; 4; 5 |]; strings = [| "hello"; "world" |] }

     

       271
       271
       +
         in

     

       262
       272
        
       

     

       263
       273
        
         (* Encode to JSON *)

     

       264
       274
        
         (match Jsont_bytesrw.encode_string M.data_codec data with

     

       265
       265
       -
          | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       266
       266
       -
          | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       275
       275
       +
         | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       276
       276
       +
         | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       267
       277
        
       

     

       268
       278
        
         (* Encode to YAML Block *)

     

       269
       269
       -
         (match Yamlt.encode_string ~format:Yamlt.Block M.data_codec data with

     

       270
       270
       -
          | Ok s -> Printf.printf "YAML Block:\n%s" s

     

       279
       279
       +
         (let b = Buffer.create 256 in

     

       280
       280
       +
          let writer = Bytes.Writer.of_buffer b in

     

       281
       281
       +
          match Yamlt.encode ~format:Yamlt.Block M.data_codec data ~eod:true writer with

     

       282
       282
       +
          | Ok () -> Printf.printf "YAML Block:\n%s" (Buffer.contents b)

     

       271
       283
        
          | Error e -> Printf.printf "YAML Block ERROR: %s\n" e);

     

       272
       284
        
       

     

       273
       285
        
         (* Encode to YAML Flow *)

     

       274
       274
       -
         (match Yamlt.encode_string ~format:Yamlt.Flow M.data_codec data with

     

       275
       275
       -
          | Ok s -> Printf.printf "YAML Flow: %s" s

     

       276
       276
       -
          | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       286
       286
       +
         let b = Buffer.create 256 in

     

       287
       287
       +
         let writer = Bytes.Writer.of_buffer b in

     

       288
       288
       +
         match Yamlt.encode ~format:Yamlt.Flow M.data_codec data ~eod:true writer with

     

       289
       289
       +
         | Ok () -> Printf.printf "YAML Flow: %s" (Buffer.contents b)

     

       290
       290
       +
         | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e

     

       277
       291
        
       

     

       278
       292
        
       let () =

     

       279
       293
        
         let usage = "Usage: test_arrays <command> [args...]" in

     
···

       284
       298
        
         end;

     

       285
       299
        
       

     

       286
       300
        
         match Sys.argv.(1) with

     

       287
       287
       -
         | "int" when Array.length Sys.argv = 3 ->

     

       288
       288
       -
             test_int_array Sys.argv.(2)

     

       289
       289
       -
       

     

       290
       290
       -
         | "string" when Array.length Sys.argv = 3 ->

     

       291
       291
       -
             test_string_array Sys.argv.(2)

     

       292
       292
       -
       

     

       293
       293
       -
         | "float" when Array.length Sys.argv = 3 ->

     

       294
       294
       -
             test_float_array Sys.argv.(2)

     

       295
       295
       -
       

     

       296
       296
       -
         | "empty" when Array.length Sys.argv = 3 ->

     

       297
       297
       -
             test_empty_array Sys.argv.(2)

     

       298
       298
       -
       

     

       299
       299
       -
         | "objects" when Array.length Sys.argv = 3 ->

     

       300
       300
       -
             test_object_array Sys.argv.(2)

     

       301
       301
       -
       

     

       302
       302
       -
         | "nested" when Array.length Sys.argv = 3 ->

     

       303
       303
       -
             test_nested_arrays Sys.argv.(2)

     

       304
       304
       -
       

     

       301
       301
       +
         | "int" when Array.length Sys.argv = 3 -> test_int_array Sys.argv.(2)

     

       302
       302
       +
         | "string" when Array.length Sys.argv = 3 -> test_string_array Sys.argv.(2)

     

       303
       303
       +
         | "float" when Array.length Sys.argv = 3 -> test_float_array Sys.argv.(2)

     

       304
       304
       +
         | "empty" when Array.length Sys.argv = 3 -> test_empty_array Sys.argv.(2)

     

       305
       305
       +
         | "objects" when Array.length Sys.argv = 3 -> test_object_array Sys.argv.(2)

     

       306
       306
       +
         | "nested" when Array.length Sys.argv = 3 -> test_nested_arrays Sys.argv.(2)

     

       305
       307
        
         | "type-mismatch" when Array.length Sys.argv = 3 ->

     

       306
       308
        
             test_type_mismatch Sys.argv.(2)

     

       307
       307
       -
       

     

       308
       308
       -
         | "bool" when Array.length Sys.argv = 3 ->

     

       309
       309
       -
             test_bool_array Sys.argv.(2)

     

       310
       310
       -
       

     

       309
       309
       +
         | "bool" when Array.length Sys.argv = 3 -> test_bool_array Sys.argv.(2)

     

       311
       310
        
         | "nullable" when Array.length Sys.argv = 3 ->

     

       312
       311
        
             test_nullable_array Sys.argv.(2)

     

       313
       313
       -
       

     

       314
       314
       -
         | "encode" when Array.length Sys.argv = 2 ->

     

       315
       315
       -
             test_encode_arrays ()

     

       316
       316
       -
       

     

       312
       312
       +
         | "encode" when Array.length Sys.argv = 2 -> test_encode_arrays ()

     

       317
       313
        
         | _ ->

     

       318
       314
        
             prerr_endline usage;

     

       319
       315
        
             prerr_endline "Commands:";

+58 -45

tests/bin/test_complex.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** Test complex nested types with Yamlt *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Bytesrw

     

       7
       9
        
       

     

       8
       10
        
       (* Helper to read file *)

     

       9
       11
        
       let read_file path =

     
···

       27
       29
        
       (* Test: Deeply nested objects *)

     

       28
       30
        
       let test_deep_nesting file =

     

       29
       31
        
         let module M = struct

     

       30
       30
       -
           type level3 = { value: int }

     

       31
       31
       -
           type level2 = { data: level3 }

     

       32
       32
       -
           type level1 = { nested: level2 }

     

       33
       33
       -
           type root = { top: level1 }

     

       32
       32
       +
           type level3 = { value : int }

     

       33
       33
       +
           type level2 = { data : level3 }

     

       34
       34
       +
           type level1 = { nested : level2 }

     

       35
       35
       +
           type root = { top : level1 }

     

       34
       36
        
       

     

       35
       37
        
           let level3_codec =

     

       36
       38
        
             Jsont.Object.map ~kind:"Level3" (fun value -> { value })

     
···

       54
       56
        
       

     

       55
       57
        
           let show r = Printf.sprintf "depth=4, value=%d" r.top.nested.data.value

     

       56
       58
        
         end in

     

       57
       57
       -
       

     

       58
       59
        
         let yaml = read_file file in

     

       59
       60
        
         let json = read_file (file ^ ".json") in

     

       60
       61
        
         let json_result = Jsont_bytesrw.decode_string M.root_codec json in

     

       61
       61
       -
         let yaml_result = Yamlt.decode_string M.root_codec yaml in

     

       62
       62
       +
         let yaml_result = Yamlt.decode M.root_codec (Bytes.Reader.of_string yaml) in

     

       62
       63
        
       

     

       63
       64
        
         show_result_both "deep_nesting"

     

       64
       65
        
           (Result.map M.show json_result)

     
···

       67
       68
        
       (* Test: Array of objects with nested arrays *)

     

       68
       69
        
       let test_mixed_structure file =

     

       69
       70
        
         let module M = struct

     

       70
       70
       -
           type item = { id: int; tags: string array }

     

       71
       71
       -
           type collection = { name: string; items: item array }

     

       71
       71
       +
           type item = { id : int; tags : string array }

     

       72
       72
       +
           type collection = { name : string; items : item array }

     

       72
       73
        
       

     

       73
       74
        
           let item_codec =

     

       74
       75
        
             Jsont.Object.map ~kind:"Item" (fun id tags -> { id; tags })

     

       75
       76
        
             |> Jsont.Object.mem "id" Jsont.int ~enc:(fun i -> i.id)

     

       76
       76
       -
             |> Jsont.Object.mem "tags" (Jsont.array Jsont.string) ~enc:(fun i -> i.tags)

     

       77
       77
       +
             |> Jsont.Object.mem "tags" (Jsont.array Jsont.string) ~enc:(fun i ->

     

       78
       78
       +
                 i.tags)

     

       77
       79
        
             |> Jsont.Object.finish

     

       78
       80
        
       

     

       79
       81
        
           let collection_codec =

     

       80
       82
        
             Jsont.Object.map ~kind:"Collection" (fun name items -> { name; items })

     

       81
       83
        
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun c -> c.name)

     

       82
       82
       -
             |> Jsont.Object.mem "items" (Jsont.array item_codec) ~enc:(fun c -> c.items)

     

       84
       84
       +
             |> Jsont.Object.mem "items" (Jsont.array item_codec) ~enc:(fun c ->

     

       85
       85
       +
                 c.items)

     

       83
       86
        
             |> Jsont.Object.finish

     

       84
       87
        
       

     

       85
       88
        
           let show c =

     

       86
       86
       -
             let total_tags = Stdlib.Array.fold_left (fun acc item ->

     

       87
       87
       -
               acc + Stdlib.Array.length item.tags) 0 c.items in

     

       88
       88
       -
             Printf.sprintf "name=%S, items=%d, total_tags=%d"

     

       89
       89
       -
               c.name (Stdlib.Array.length c.items) total_tags

     

       89
       89
       +
             let total_tags =

     

       90
       90
       +
               Stdlib.Array.fold_left

     

       91
       91
       +
                 (fun acc item -> acc + Stdlib.Array.length item.tags)

     

       92
       92
       +
                 0 c.items

     

       93
       93
       +
             in

     

       94
       94
       +
             Printf.sprintf "name=%S, items=%d, total_tags=%d" c.name

     

       95
       95
       +
               (Stdlib.Array.length c.items)

     

       96
       96
       +
               total_tags

     

       90
       97
        
         end in

     

       91
       91
       -
       

     

       92
       98
        
         let yaml = read_file file in

     

       93
       99
        
         let json = read_file (file ^ ".json") in

     

       94
       100
        
         let json_result = Jsont_bytesrw.decode_string M.collection_codec json in

     

       95
       95
       -
         let yaml_result = Yamlt.decode_string M.collection_codec yaml in

     

       101
       101
       +
         let yaml_result = Yamlt.decode M.collection_codec (Bytes.Reader.of_string yaml) in

     

       96
       102
        
       

     

       97
       103
        
         show_result_both "mixed_structure"

     

       98
       104
        
           (Result.map M.show json_result)

     
···

       102
       108
        
       let test_complex_optional file =

     

       103
       109
        
         let module M = struct

     

       104
       110
        
           type config = {

     

       105
       105
       -
             host: string;

     

       106
       106
       -
             port: int option;

     

       107
       107
       -
             ssl: bool option;

     

       108
       108
       -
             cert_path: string option;

     

       109
       109
       -
             fallback_hosts: string array option;

     

       111
       111
       +
             host : string;

     

       112
       112
       +
             port : int option;

     

       113
       113
       +
             ssl : bool option;

     

       114
       114
       +
             cert_path : string option;

     

       115
       115
       +
             fallback_hosts : string array option;

     

       110
       116
        
           }

     

       111
       117
        
       

     

       112
       118
        
           let config_codec =

     
···

       116
       122
        
             |> Jsont.Object.mem "host" Jsont.string ~enc:(fun c -> c.host)

     

       117
       123
        
             |> Jsont.Object.opt_mem "port" Jsont.int ~enc:(fun c -> c.port)

     

       118
       124
        
             |> Jsont.Object.opt_mem "ssl" Jsont.bool ~enc:(fun c -> c.ssl)

     

       119
       119
       -
             |> Jsont.Object.opt_mem "cert_path" Jsont.string ~enc:(fun c -> c.cert_path)

     

       125
       125
       +
             |> Jsont.Object.opt_mem "cert_path" Jsont.string ~enc:(fun c ->

     

       126
       126
       +
                 c.cert_path)

     

       120
       127
        
             |> Jsont.Object.opt_mem "fallback_hosts" (Jsont.array Jsont.string)

     

       121
       121
       -
                 ~enc:(fun c -> c.fallback_hosts)

     

       128
       128
       +
                  ~enc:(fun c -> c.fallback_hosts)

     

       122
       129
        
             |> Jsont.Object.finish

     

       123
       130
        
       

     

       124
       131
        
           let show c =

     

       125
       125
       -
             let port_str = match c.port with None -> "None" | Some p -> string_of_int p in

     

       126
       126
       -
             let ssl_str = match c.ssl with None -> "None" | Some b -> string_of_bool b in

     

       127
       127
       -
             let fallbacks = match c.fallback_hosts with

     

       132
       132
       +
             let port_str =

     

       133
       133
       +
               match c.port with None -> "None" | Some p -> string_of_int p

     

       134
       134
       +
             in

     

       135
       135
       +
             let ssl_str =

     

       136
       136
       +
               match c.ssl with None -> "None" | Some b -> string_of_bool b

     

       137
       137
       +
             in

     

       138
       138
       +
             let fallbacks =

     

       139
       139
       +
               match c.fallback_hosts with

     

       128
       140
        
               | None -> 0

     

       129
       129
       -
               | Some arr -> Stdlib.Array.length arr in

     

       130
       130
       -
             Printf.sprintf "host=%S, port=%s, ssl=%s, fallbacks=%d"

     

       131
       131
       -
               c.host port_str ssl_str fallbacks

     

       141
       141
       +
               | Some arr -> Stdlib.Array.length arr

     

       142
       142
       +
             in

     

       143
       143
       +
             Printf.sprintf "host=%S, port=%s, ssl=%s, fallbacks=%d" c.host port_str

     

       144
       144
       +
               ssl_str fallbacks

     

       132
       145
        
         end in

     

       133
       133
       -
       

     

       134
       146
        
         let yaml = read_file file in

     

       135
       147
        
         let json = read_file (file ^ ".json") in

     

       136
       148
        
         let json_result = Jsont_bytesrw.decode_string M.config_codec json in

     

       137
       137
       -
         let yaml_result = Yamlt.decode_string M.config_codec yaml in

     

       149
       149
       +
         let yaml_result = Yamlt.decode M.config_codec (Bytes.Reader.of_string yaml) in

     

       138
       150
        
       

     

       139
       151
        
         show_result_both "complex_optional"

     

       140
       152
        
           (Result.map M.show json_result)

     
···

       143
       155
        
       (* Test: Heterogeneous data via any type *)

     

       144
       156
        
       let test_heterogeneous file =

     

       145
       157
        
         let module M = struct

     

       146
       146
       -
           type data = { mixed: Jsont.json array }

     

       158
       158
       +
           type data = { mixed : Jsont.json array }

     

       147
       159
        
       

     

       148
       160
        
           let data_codec =

     

       149
       161
        
             Jsont.Object.map ~kind:"Data" (fun mixed -> { mixed })

     

       150
       150
       -
             |> Jsont.Object.mem "mixed" (Jsont.array (Jsont.any ())) ~enc:(fun d -> d.mixed)

     

       162
       162
       +
             |> Jsont.Object.mem "mixed"

     

       163
       163
       +
                  (Jsont.array (Jsont.any ()))

     

       164
       164
       +
                  ~enc:(fun d -> d.mixed)

     

       151
       165
        
             |> Jsont.Object.finish

     

       152
       166
        
       

     

       153
       167
        
           let show d = Printf.sprintf "items=%d" (Stdlib.Array.length d.mixed)

     

       154
       168
        
         end in

     

       155
       155
       -
       

     

       156
       169
        
         let yaml = read_file file in

     

       157
       170
        
         let json = read_file (file ^ ".json") in

     

       158
       171
        
         let json_result = Jsont_bytesrw.decode_string M.data_codec json in

     

       159
       159
       -
         let yaml_result = Yamlt.decode_string M.data_codec yaml in

     

       172
       172
       +
         let yaml_result = Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml) in

     

       160
       173
        
       

     

       161
       174
        
         show_result_both "heterogeneous"

     

       162
       175
        
           (Result.map M.show json_result)

     
···

       173
       186
        
         match Sys.argv.(1) with

     

       174
       187
        
         | "deep-nesting" when Stdlib.Array.length Sys.argv = 3 ->

     

       175
       188
        
             test_deep_nesting Sys.argv.(2)

     

       176
       176
       -
       

     

       177
       189
        
         | "mixed-structure" when Stdlib.Array.length Sys.argv = 3 ->

     

       178
       190
        
             test_mixed_structure Sys.argv.(2)

     

       179
       179
       -
       

     

       180
       191
        
         | "complex-optional" when Stdlib.Array.length Sys.argv = 3 ->

     

       181
       192
        
             test_complex_optional Sys.argv.(2)

     

       182
       182
       -
       

     

       183
       193
        
         | "heterogeneous" when Stdlib.Array.length Sys.argv = 3 ->

     

       184
       194
        
             test_heterogeneous Sys.argv.(2)

     

       185
       185
       -
       

     

       186
       195
        
         | _ ->

     

       187
       196
        
             prerr_endline usage;

     

       188
       197
        
             prerr_endline "Commands:";

     

       189
       198
        
             prerr_endline "  deep-nesting <file>      - Test deeply nested objects";

     

       190
       190
       -
             prerr_endline "  mixed-structure <file>   - Test arrays of objects with nested arrays";

     

       191
       191
       -
             prerr_endline "  complex-optional <file>  - Test complex optional/nullable combinations";

     

       192
       192
       -
             prerr_endline "  heterogeneous <file>     - Test heterogeneous data via any type";

     

       199
       199
       +
             prerr_endline

     

       200
       200
       +
               "  mixed-structure <file>   - Test arrays of objects with nested arrays";

     

       201
       201
       +
             prerr_endline

     

       202
       202
       +
               "  complex-optional <file>  - Test complex optional/nullable \

     

       203
       203
       +
                combinations";

     

       204
       204
       +
             prerr_endline

     

       205
       205
       +
               "  heterogeneous <file>     - Test heterogeneous data via any type";

     

       193
       206
        
             exit 1

+96

tests/bin/test_comprehensive.ml

···

       1
       1
       +
       open Bytesrw

     

       2
       2
       +
       

     

       3
       3
       +
       let () =

     

       4
       4
       +
         (* Test 1: Null handling with option types *)

     

       5
       5
       +
         Printf.printf "=== NULL HANDLING ===\n";

     

       6
       6
       +
         let opt_codec =

     

       7
       7
       +
           Jsont.Object.map ~kind:"Test" (fun v -> v)

     

       8
       8
       +
           |> Jsont.Object.mem "value" (Jsont.option Jsont.string) ~enc:(fun v -> v)

     

       9
       9
       +
           |> Jsont.Object.finish

     

       10
       10
       +
         in

     

       11
       11
       +
       

     

       12
       12
       +
         (match Yamlt.decode opt_codec (Bytes.Reader.of_string "value: null") with

     

       13
       13
       +
         | Ok None -> Printf.printf "✓ Plain 'null' with option codec: None\n"

     

       14
       14
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       15
       15
       +
       

     

       16
       16
       +
         (match Yamlt.decode opt_codec (Bytes.Reader.of_string "value: hello") with

     

       17
       17
       +
         | Ok (Some "hello") ->

     

       18
       18
       +
             Printf.printf "✓ Plain 'hello' with option codec: Some(hello)\n"

     

       19
       19
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       20
       20
       +
       

     

       21
       21
       +
         let string_codec =

     

       22
       22
       +
           Jsont.Object.map ~kind:"Test" (fun v -> v)

     

       23
       23
       +
           |> Jsont.Object.mem "value" Jsont.string ~enc:(fun v -> v)

     

       24
       24
       +
           |> Jsont.Object.finish

     

       25
       25
       +
         in

     

       26
       26
       +
       

     

       27
       27
       +
         (match Yamlt.decode string_codec (Bytes.Reader.of_string "value: null") with

     

       28
       28
       +
         | Error _ ->

     

       29
       29
       +
             Printf.printf "✓ Plain 'null' with string codec: ERROR (expected)\n"

     

       30
       30
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       31
       31
       +
       

     

       32
       32
       +
         (match Yamlt.decode string_codec (Bytes.Reader.of_string "value: \"\"") with

     

       33
       33
       +
         | Ok "" -> Printf.printf "✓ Quoted empty string: \"\"\n"

     

       34
       34
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       35
       35
       +
       

     

       36
       36
       +
         (match Yamlt.decode string_codec (Bytes.Reader.of_string "value: \"null\"") with

     

       37
       37
       +
         | Ok "null" -> Printf.printf "✓ Quoted 'null': \"null\"\n"

     

       38
       38
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       39
       39
       +
       

     

       40
       40
       +
         (* Test 2: Number formats *)

     

       41
       41
       +
         Printf.printf "\n=== NUMBER FORMATS ===\n";

     

       42
       42
       +
         let num_codec =

     

       43
       43
       +
           Jsont.Object.map ~kind:"Test" (fun v -> v)

     

       44
       44
       +
           |> Jsont.Object.mem "value" Jsont.number ~enc:(fun v -> v)

     

       45
       45
       +
           |> Jsont.Object.finish

     

       46
       46
       +
         in

     

       47
       47
       +
       

     

       48
       48
       +
         (match Yamlt.decode num_codec (Bytes.Reader.of_string "value: 0xFF") with

     

       49
       49
       +
         | Ok 255. -> Printf.printf "✓ Hex 0xFF: 255\n"

     

       50
       50
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       51
       51
       +
       

     

       52
       52
       +
         (match Yamlt.decode num_codec (Bytes.Reader.of_string "value: 0o77") with

     

       53
       53
       +
         | Ok 63. -> Printf.printf "✓ Octal 0o77: 63\n"

     

       54
       54
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       55
       55
       +
       

     

       56
       56
       +
         (match Yamlt.decode num_codec (Bytes.Reader.of_string "value: 0b1010") with

     

       57
       57
       +
         | Ok 10. -> Printf.printf "✓ Binary 0b1010: 10\n"

     

       58
       58
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       59
       59
       +
       

     

       60
       60
       +
         (* Test 3: Optional arrays *)

     

       61
       61
       +
         Printf.printf "\n=== OPTIONAL ARRAYS ===\n";

     

       62
       62
       +
         let opt_array_codec =

     

       63
       63
       +
           Jsont.Object.map ~kind:"Test" (fun v -> v)

     

       64
       64
       +
           |> Jsont.Object.opt_mem "values" (Jsont.array Jsont.string) ~enc:(fun v ->

     

       65
       65
       +
               v)

     

       66
       66
       +
           |> Jsont.Object.finish

     

       67
       67
       +
         in

     

       68
       68
       +
       

     

       69
       69
       +
         (match Yamlt.decode opt_array_codec (Bytes.Reader.of_string "values: [a, b, c]") with

     

       70
       70
       +
         | Ok (Some arr) when Array.length arr = 3 ->

     

       71
       71
       +
             Printf.printf "✓ Optional array [a, b, c]: Some([3 items])\n"

     

       72
       72
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       73
       73
       +
       

     

       74
       74
       +
         (match Yamlt.decode opt_array_codec (Bytes.Reader.of_string "{}") with

     

       75
       75
       +
         | Ok None -> Printf.printf "✓ Missing optional array: None\n"

     

       76
       76
       +
         | _ -> Printf.printf "✗ FAIL\n");

     

       77
       77
       +
       

     

       78
       78
       +
         (* Test 4: Flow encoding *)

     

       79
       79
       +
         Printf.printf "\n=== FLOW ENCODING ===\n";

     

       80
       80
       +
         let encode_codec =

     

       81
       81
       +
           Jsont.Object.map ~kind:"Test" (fun name values -> (name, values))

     

       82
       82
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:fst

     

       83
       83
       +
           |> Jsont.Object.mem "values" (Jsont.array Jsont.number) ~enc:snd

     

       84
       84
       +
           |> Jsont.Object.finish

     

       85
       85
       +
         in

     

       86
       86
       +
       

     

       87
       87
       +
         let b = Buffer.create 256 in

     

       88
       88
       +
         let writer = Bytes.Writer.of_buffer b in

     

       89
       89
       +
         match

     

       90
       90
       +
           Yamlt.encode ~format:Flow encode_codec ("test", [| 1.; 2.; 3. |]) ~eod:true writer

     

       91
       91
       +
         with

     

       92
       92
       +
         | Ok ()

     

       93
       93
       +
           when String.equal (Buffer.contents b) "{name: test, values: [1.0, 2.0, 3.0]}\n" ->

     

       94
       94
       +
             Printf.printf "✓ Flow encoding with comma separator\n"

     

       95
       95
       +
         | Ok () -> Printf.printf "✗ FAIL: %S\n" (Buffer.contents b)

     

       96
       96
       +
         | Error e -> Printf.printf "✗ ERROR: %s\n" e

+40 -38

tests/bin/test_edge.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** Test edge cases with Yamlt *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Bytesrw

     

       7
       9
        
       

     

       8
       10
        
       (* Helper to read file *)

     

       9
       11
        
       let read_file path =

     
···

       27
       29
        
       (* Test: Very large numbers *)

     

       28
       30
        
       let test_large_numbers file =

     

       29
       31
        
         let module M = struct

     

       30
       30
       -
           type numbers = { large_int: float; large_float: float; small_float: float }

     

       32
       32
       +
           type numbers = {

     

       33
       33
       +
             large_int : float;

     

       34
       34
       +
             large_float : float;

     

       35
       35
       +
             small_float : float;

     

       36
       36
       +
           }

     

       31
       37
        
       

     

       32
       38
        
           let numbers_codec =

     

       33
       39
        
             Jsont.Object.map ~kind:"Numbers" (fun large_int large_float small_float ->

     

       34
       34
       -
               { large_int; large_float; small_float })

     

       40
       40
       +
                 { large_int; large_float; small_float })

     

       35
       41
        
             |> Jsont.Object.mem "large_int" Jsont.number ~enc:(fun n -> n.large_int)

     

       36
       36
       -
             |> Jsont.Object.mem "large_float" Jsont.number ~enc:(fun n -> n.large_float)

     

       37
       37
       -
             |> Jsont.Object.mem "small_float" Jsont.number ~enc:(fun n -> n.small_float)

     

       42
       42
       +
             |> Jsont.Object.mem "large_float" Jsont.number ~enc:(fun n ->

     

       43
       43
       +
                 n.large_float)

     

       44
       44
       +
             |> Jsont.Object.mem "small_float" Jsont.number ~enc:(fun n ->

     

       45
       45
       +
                 n.small_float)

     

       38
       46
        
             |> Jsont.Object.finish

     

       39
       47
        
       

     

       40
       48
        
           let show n =

     

       41
       49
        
             Printf.sprintf "large_int=%.0f, large_float=%e, small_float=%e"

     

       42
       50
        
               n.large_int n.large_float n.small_float

     

       43
       51
        
         end in

     

       44
       44
       -
       

     

       45
       52
        
         let yaml = read_file file in

     

       46
       53
        
         let json = read_file (file ^ ".json") in

     

       47
       54
        
         let json_result = Jsont_bytesrw.decode_string M.numbers_codec json in

     

       48
       48
       -
         let yaml_result = Yamlt.decode_string M.numbers_codec yaml in

     

       55
       55
       +
         let yaml_result = Yamlt.decode M.numbers_codec (Bytes.Reader.of_string yaml) in

     

       49
       56
        
       

     

       50
       57
        
         show_result_both "large_numbers"

     

       51
       58
        
           (Result.map M.show json_result)

     
···

       54
       61
        
       (* Test: Special characters in strings *)

     

       55
       62
        
       let test_special_chars file =

     

       56
       63
        
         let module M = struct

     

       57
       57
       -
           type text = { content: string }

     

       64
       64
       +
           type text = { content : string }

     

       58
       65
        
       

     

       59
       66
        
           let text_codec =

     

       60
       67
        
             Jsont.Object.map ~kind:"Text" (fun content -> { content })

     
···

       67
       74
        
               (String.contains t.content '\n')

     

       68
       75
        
               (String.contains t.content '\t')

     

       69
       76
        
         end in

     

       70
       70
       -
       

     

       71
       77
        
         let yaml = read_file file in

     

       72
       78
        
         let json = read_file (file ^ ".json") in

     

       73
       79
        
         let json_result = Jsont_bytesrw.decode_string M.text_codec json in

     

       74
       74
       -
         let yaml_result = Yamlt.decode_string M.text_codec yaml in

     

       80
       80
       +
         let yaml_result = Yamlt.decode M.text_codec (Bytes.Reader.of_string yaml) in

     

       75
       81
        
       

     

       76
       82
        
         show_result_both "special_chars"

     

       77
       83
        
           (Result.map M.show json_result)

     
···

       80
       86
        
       (* Test: Unicode strings *)

     

       81
       87
        
       let test_unicode file =

     

       82
       88
        
         let module M = struct

     

       83
       83
       -
           type text = { emoji: string; chinese: string; rtl: string }

     

       89
       89
       +
           type text = { emoji : string; chinese : string; rtl : string }

     

       84
       90
        
       

     

       85
       91
        
           let text_codec =

     

       86
       86
       -
             Jsont.Object.map ~kind:"Text" (fun emoji chinese rtl -> { emoji; chinese; rtl })

     

       92
       92
       +
             Jsont.Object.map ~kind:"Text" (fun emoji chinese rtl ->

     

       93
       93
       +
                 { emoji; chinese; rtl })

     

       87
       94
        
             |> Jsont.Object.mem "emoji" Jsont.string ~enc:(fun t -> t.emoji)

     

       88
       95
        
             |> Jsont.Object.mem "chinese" Jsont.string ~enc:(fun t -> t.chinese)

     

       89
       96
        
             |> Jsont.Object.mem "rtl" Jsont.string ~enc:(fun t -> t.rtl)

     
···

       92
       99
        
           let show t =

     

       93
       100
        
             Printf.sprintf "emoji=%S, chinese=%S, rtl=%S" t.emoji t.chinese t.rtl

     

       94
       101
        
         end in

     

       95
       95
       -
       

     

       96
       102
        
         let yaml = read_file file in

     

       97
       103
        
         let json = read_file (file ^ ".json") in

     

       98
       104
        
         let json_result = Jsont_bytesrw.decode_string M.text_codec json in

     

       99
       99
       -
         let yaml_result = Yamlt.decode_string M.text_codec yaml in

     

       105
       105
       +
         let yaml_result = Yamlt.decode M.text_codec (Bytes.Reader.of_string yaml) in

     

       100
       106
        
       

     

       101
       107
        
         show_result_both "unicode"

     

       102
       108
        
           (Result.map M.show json_result)

     
···

       105
       111
        
       (* Test: Empty collections *)

     

       106
       112
        
       let test_empty_collections file =

     

       107
       113
        
         let module M = struct

     

       108
       108
       -
           type data = { empty_array: int array; empty_object_array: unit array }

     

       114
       114
       +
           type data = { empty_array : int array; empty_object_array : unit array }

     

       109
       115
        
       

     

       110
       116
        
           let data_codec =

     

       111
       117
        
             Jsont.Object.map ~kind:"Data" (fun empty_array empty_object_array ->

     

       112
       112
       -
               { empty_array; empty_object_array })

     

       113
       113
       -
             |> Jsont.Object.mem "empty_array" (Jsont.array Jsont.int) ~enc:(fun d -> d.empty_array)

     

       114
       114
       -
             |> Jsont.Object.mem "empty_object_array" (Jsont.array (Jsont.null ())) ~enc:(fun d -> d.empty_object_array)

     

       118
       118
       +
                 { empty_array; empty_object_array })

     

       119
       119
       +
             |> Jsont.Object.mem "empty_array" (Jsont.array Jsont.int) ~enc:(fun d ->

     

       120
       120
       +
                 d.empty_array)

     

       121
       121
       +
             |> Jsont.Object.mem "empty_object_array"

     

       122
       122
       +
                  (Jsont.array (Jsont.null ()))

     

       123
       123
       +
                  ~enc:(fun d -> d.empty_object_array)

     

       115
       124
        
             |> Jsont.Object.finish

     

       116
       125
        
       

     

       117
       126
        
           let show d =

     
···

       119
       128
        
               (Stdlib.Array.length d.empty_array)

     

       120
       129
        
               (Stdlib.Array.length d.empty_object_array)

     

       121
       130
        
         end in

     

       122
       122
       -
       

     

       123
       131
        
         let yaml = read_file file in

     

       124
       132
        
         let json = read_file (file ^ ".json") in

     

       125
       133
        
         let json_result = Jsont_bytesrw.decode_string M.data_codec json in

     

       126
       126
       -
         let yaml_result = Yamlt.decode_string M.data_codec yaml in

     

       134
       134
       +
         let yaml_result = Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml) in

     

       127
       135
        
       

     

       128
       136
        
         show_result_both "empty_collections"

     

       129
       137
        
           (Result.map M.show json_result)

     
···

       138
       146
        
             | Ok _ -> "not_object"

     

       139
       147
        
             | Error _ -> "decode_error"

     

       140
       148
        
         end in

     

       141
       141
       -
       

     

       142
       149
        
         let yaml = read_file file in

     

       143
       150
        
         let json = read_file (file ^ ".json") in

     

       144
       151
        
         let json_result = Jsont_bytesrw.decode_string (Jsont.any ()) json in

     

       145
       145
       -
         let yaml_result = Yamlt.decode_string (Jsont.any ()) yaml in

     

       152
       152
       +
         let yaml_result = Yamlt.decode (Jsont.any ()) (Bytes.Reader.of_string yaml) in

     

       146
       153
        
       

     

       147
       154
        
         show_result_both "special_keys"

     

       148
       155
        
           (Result.map M.show json_result)

     
···

       151
       158
        
       (* Test: Single-element arrays *)

     

       152
       159
        
       let test_single_element file =

     

       153
       160
        
         let module M = struct

     

       154
       154
       -
           type data = { single: int array }

     

       161
       161
       +
           type data = { single : int array }

     

       155
       162
        
       

     

       156
       163
        
           let data_codec =

     

       157
       164
        
             Jsont.Object.map ~kind:"Data" (fun single -> { single })

     

       158
       158
       -
             |> Jsont.Object.mem "single" (Jsont.array Jsont.int) ~enc:(fun d -> d.single)

     

       165
       165
       +
             |> Jsont.Object.mem "single" (Jsont.array Jsont.int) ~enc:(fun d ->

     

       166
       166
       +
                 d.single)

     

       159
       167
        
             |> Jsont.Object.finish

     

       160
       168
        
       

     

       161
       169
        
           let show d =

     
···

       163
       171
        
               (Stdlib.Array.length d.single)

     

       164
       172
        
               (if Stdlib.Array.length d.single > 0 then d.single.(0) else 0)

     

       165
       173
        
         end in

     

       166
       166
       -
       

     

       167
       174
        
         let yaml = read_file file in

     

       168
       175
        
         let json = read_file (file ^ ".json") in

     

       169
       176
        
         let json_result = Jsont_bytesrw.decode_string M.data_codec json in

     

       170
       170
       -
         let yaml_result = Yamlt.decode_string M.data_codec yaml in

     

       177
       177
       +
         let yaml_result = Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml) in

     

       171
       178
        
       

     

       172
       179
        
         show_result_both "single_element"

     

       173
       180
        
           (Result.map M.show json_result)

     
···

       184
       191
        
         match Sys.argv.(1) with

     

       185
       192
        
         | "large-numbers" when Stdlib.Array.length Sys.argv = 3 ->

     

       186
       193
        
             test_large_numbers Sys.argv.(2)

     

       187
       187
       -
       

     

       188
       194
        
         | "special-chars" when Stdlib.Array.length Sys.argv = 3 ->

     

       189
       195
        
             test_special_chars Sys.argv.(2)

     

       190
       190
       -
       

     

       191
       191
       -
         | "unicode" when Stdlib.Array.length Sys.argv = 3 ->

     

       192
       192
       -
             test_unicode Sys.argv.(2)

     

       193
       193
       -
       

     

       196
       196
       +
         | "unicode" when Stdlib.Array.length Sys.argv = 3 -> test_unicode Sys.argv.(2)

     

       194
       197
        
         | "empty-collections" when Stdlib.Array.length Sys.argv = 3 ->

     

       195
       198
        
             test_empty_collections Sys.argv.(2)

     

       196
       196
       -
       

     

       197
       199
        
         | "special-keys" when Stdlib.Array.length Sys.argv = 3 ->

     

       198
       200
        
             test_special_keys Sys.argv.(2)

     

       199
       199
       -
       

     

       200
       201
        
         | "single-element" when Stdlib.Array.length Sys.argv = 3 ->

     

       201
       202
        
             test_single_element Sys.argv.(2)

     

       202
       202
       -
       

     

       203
       203
        
         | _ ->

     

       204
       204
        
             prerr_endline usage;

     

       205
       205
        
             prerr_endline "Commands:";

     

       206
       206
        
             prerr_endline "  large-numbers <file>      - Test very large numbers";

     

       207
       207
       -
             prerr_endline "  special-chars <file>      - Test special characters in strings";

     

       207
       207
       +
             prerr_endline

     

       208
       208
       +
               "  special-chars <file>      - Test special characters in strings";

     

       208
       209
        
             prerr_endline "  unicode <file>            - Test Unicode strings";

     

       209
       210
        
             prerr_endline "  empty-collections <file>  - Test empty collections";

     

       210
       210
       -
             prerr_endline "  special-keys <file>       - Test special characters in keys";

     

       211
       211
       +
             prerr_endline

     

       212
       212
       +
               "  special-keys <file>       - Test special characters in keys";

     

       211
       213
        
             prerr_endline "  single-element <file>     - Test single-element arrays";

     

       212
       214
        
             exit 1

+21

tests/bin/test_flow_newline.ml

···

       1
       1
       +
       open Bytesrw

     

       2
       2
       +
       

     

       3
       3
       +
       let () =

     

       4
       4
       +
         let encode_codec =

     

       5
       5
       +
           Jsont.Object.map ~kind:"Test" (fun name values -> (name, values))

     

       6
       6
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:fst

     

       7
       7
       +
           |> Jsont.Object.mem "values" (Jsont.array Jsont.number) ~enc:snd

     

       8
       8
       +
           |> Jsont.Object.finish

     

       9
       9
       +
         in

     

       10
       10
       +
       

     

       11
       11
       +
         let b = Buffer.create 256 in

     

       12
       12
       +
         let writer = Bytes.Writer.of_buffer b in

     

       13
       13
       +
         match

     

       14
       14
       +
           Yamlt.encode ~format:Flow encode_codec ("test", [| 1.; 2.; 3. |]) ~eod:true writer

     

       15
       15
       +
         with

     

       16
       16
       +
         | Ok () ->

     

       17
       17
       +
             let yaml_flow = Buffer.contents b in

     

       18
       18
       +
             Printf.printf "Length: %d\n" (String.length yaml_flow);

     

       19
       19
       +
             Printf.printf "Repr: %S\n" yaml_flow;

     

       20
       20
       +
             Printf.printf "Output:\n%s" yaml_flow

     

       21
       21
       +
         | Error e -> Printf.printf "Error: %s\n" e

+52 -58

tests/bin/test_formats.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** Test format-specific features with Yamlt *)

     

       7
       7
        
       

     

       8
       8
       +
       open Bytesrw

     

       9
       9
       +
       

     

       8
       10
        
       (* Helper to read file *)

     

       9
       11
        
       let read_file path =

     

       10
       12
        
         let ic = open_in path in

     
···

       27
       29
        
       (* Test: Multi-line strings - literal style *)

     

       28
       30
        
       let test_literal_string file =

     

       29
       31
        
         let module M = struct

     

       30
       30
       -
           type text = { content: string }

     

       32
       32
       +
           type text = { content : string }

     

       31
       33
        
       

     

       32
       34
        
           let text_codec =

     

       33
       35
        
             Jsont.Object.map ~kind:"Text" (fun content -> { content })

     
···

       39
       41
        
               (List.length (String.split_on_char '\n' t.content))

     

       40
       42
        
               (String.length t.content)

     

       41
       43
        
         end in

     

       42
       42
       -
       

     

       43
       44
        
         let yaml = read_file file in

     

       44
       45
        
         let json = read_file (file ^ ".json") in

     

       45
       46
        
         let json_result = Jsont_bytesrw.decode_string M.text_codec json in

     

       46
       46
       -
         let yaml_result = Yamlt.decode_string M.text_codec yaml in

     

       47
       47
       +
         let yaml_result = Yamlt.decode M.text_codec (Bytes.Reader.of_string yaml) in

     

       47
       48
        
       

     

       48
       49
        
         show_result_both "literal_string"

     

       49
       50
        
           (Result.map M.show json_result)

     
···

       52
       53
        
       (* Test: Multi-line strings - folded style *)

     

       53
       54
        
       let test_folded_string file =

     

       54
       55
        
         let module M = struct

     

       55
       55
       -
           type text = { content: string }

     

       56
       56
       +
           type text = { content : string }

     

       56
       57
        
       

     

       57
       58
        
           let text_codec =

     

       58
       59
        
             Jsont.Object.map ~kind:"Text" (fun content -> { content })

     
···

       60
       61
        
             |> Jsont.Object.finish

     

       61
       62
        
       

     

       62
       63
        
           let show t =

     

       63
       63
       -
             Printf.sprintf "length=%d, newlines=%d"

     

       64
       64
       -
               (String.length t.content)

     

       65
       65
       -
               (List.length (List.filter (fun c -> c = '\n')

     

       66
       66
       -
                 (List.init (String.length t.content) (String.get t.content))))

     

       64
       64
       +
             Printf.sprintf "length=%d, newlines=%d" (String.length t.content)

     

       65
       65
       +
               (List.length

     

       66
       66
       +
                  (List.filter

     

       67
       67
       +
                     (fun c -> c = '\n')

     

       68
       68
       +
                     (List.init (String.length t.content) (String.get t.content))))

     

       67
       69
        
         end in

     

       68
       68
       -
       

     

       69
       70
        
         let yaml = read_file file in

     

       70
       71
        
         let json = read_file (file ^ ".json") in

     

       71
       72
        
         let json_result = Jsont_bytesrw.decode_string M.text_codec json in

     

       72
       72
       -
         let yaml_result = Yamlt.decode_string M.text_codec yaml in

     

       73
       73
       +
         let yaml_result = Yamlt.decode M.text_codec (Bytes.Reader.of_string yaml) in

     

       73
       74
        
       

     

       74
       75
        
         show_result_both "folded_string"

     

       75
       76
        
           (Result.map M.show json_result)

     
···

       78
       79
        
       (* Test: Number formats - hex, octal, binary *)

     

       79
       80
        
       let test_number_formats file =

     

       80
       81
        
         let module M = struct

     

       81
       81
       -
           type numbers = { hex: float; octal: float; binary: float }

     

       82
       82
       +
           type numbers = { hex : float; octal : float; binary : float }

     

       82
       83
        
       

     

       83
       84
        
           let numbers_codec =

     

       84
       84
       -
             Jsont.Object.map ~kind:"Numbers" (fun hex octal binary -> { hex; octal; binary })

     

       85
       85
       +
             Jsont.Object.map ~kind:"Numbers" (fun hex octal binary ->

     

       86
       86
       +
                 { hex; octal; binary })

     

       85
       87
        
             |> Jsont.Object.mem "hex" Jsont.number ~enc:(fun n -> n.hex)

     

       86
       88
        
             |> Jsont.Object.mem "octal" Jsont.number ~enc:(fun n -> n.octal)

     

       87
       89
        
             |> Jsont.Object.mem "binary" Jsont.number ~enc:(fun n -> n.binary)

     
···

       90
       92
        
           let show n =

     

       91
       93
        
             Printf.sprintf "hex=%.0f, octal=%.0f, binary=%.0f" n.hex n.octal n.binary

     

       92
       94
        
         end in

     

       93
       93
       -
       

     

       94
       95
        
         let yaml = read_file file in

     

       95
       96
        
         let json = read_file (file ^ ".json") in

     

       96
       97
        
         let json_result = Jsont_bytesrw.decode_string M.numbers_codec json in

     

       97
       97
       -
         let yaml_result = Yamlt.decode_string M.numbers_codec yaml in

     

       98
       98
       +
         let yaml_result = Yamlt.decode M.numbers_codec (Bytes.Reader.of_string yaml) in

     

       98
       99
        
       

     

       99
       100
        
         show_result_both "number_formats"

     

       100
       101
        
           (Result.map M.show json_result)

     
···

       103
       104
        
       (* Test: Block vs Flow style encoding *)

     

       104
       105
        
       let test_encode_styles () =

     

       105
       106
        
         let module M = struct

     

       106
       106
       -
           type data = {

     

       107
       107
       -
             name: string;

     

       108
       108
       -
             values: int array;

     

       109
       109
       -
             nested: nested_data;

     

       110
       110
       -
           }

     

       111
       111
       -
           and nested_data = {

     

       112
       112
       -
             enabled: bool;

     

       113
       113
       -
             count: int;

     

       114
       114
       -
           }

     

       107
       107
       +
           type data = { name : string; values : int array; nested : nested_data }

     

       108
       108
       +
           and nested_data = { enabled : bool; count : int }

     

       115
       109
        
       

     

       116
       110
        
           let nested_codec =

     

       117
       111
        
             Jsont.Object.map ~kind:"Nested" (fun enabled count -> { enabled; count })

     
···

       120
       114
        
             |> Jsont.Object.finish

     

       121
       115
        
       

     

       122
       116
        
           let data_codec =

     

       123
       123
       -
             Jsont.Object.map ~kind:"Data" (fun name values nested -> { name; values; nested })

     

       117
       117
       +
             Jsont.Object.map ~kind:"Data" (fun name values nested ->

     

       118
       118
       +
                 { name; values; nested })

     

       124
       119
        
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun d -> d.name)

     

       125
       125
       -
             |> Jsont.Object.mem "values" (Jsont.array Jsont.int) ~enc:(fun d -> d.values)

     

       120
       120
       +
             |> Jsont.Object.mem "values" (Jsont.array Jsont.int) ~enc:(fun d ->

     

       121
       121
       +
                 d.values)

     

       126
       122
        
             |> Jsont.Object.mem "nested" nested_codec ~enc:(fun d -> d.nested)

     

       127
       123
        
             |> Jsont.Object.finish

     

       128
       124
        
         end in

     

       129
       129
       -
       

     

       130
       130
       -
         let data = {

     

       131
       131
       -
           M.name = "test";

     

       132
       132
       -
           values = [|1; 2; 3|];

     

       133
       133
       -
           nested = { enabled = true; count = 5 };

     

       134
       134
       -
         } in

     

       125
       125
       +
         let data =

     

       126
       126
       +
           {

     

       127
       127
       +
             M.name = "test";

     

       128
       128
       +
             values = [| 1; 2; 3 |];

     

       129
       129
       +
             nested = { enabled = true; count = 5 };

     

       130
       130
       +
           }

     

       131
       131
       +
         in

     

       135
       132
        
       

     

       136
       133
        
         (* Encode to YAML Block style *)

     

       137
       137
       -
         (match Yamlt.encode_string ~format:Yamlt.Block M.data_codec data with

     

       138
       138
       -
          | Ok s -> Printf.printf "YAML Block:\n%s\n" s

     

       134
       134
       +
         (let b = Buffer.create 256 in

     

       135
       135
       +
          let writer = Bytes.Writer.of_buffer b in

     

       136
       136
       +
          match Yamlt.encode ~format:Yamlt.Block M.data_codec data ~eod:true writer with

     

       137
       137
       +
          | Ok () -> Printf.printf "YAML Block:\n%s\n" (Buffer.contents b)

     

       139
       138
        
          | Error e -> Printf.printf "YAML Block ERROR: %s\n" e);

     

       140
       139
        
       

     

       141
       140
        
         (* Encode to YAML Flow style *)

     

       142
       142
       -
         (match Yamlt.encode_string ~format:Yamlt.Flow M.data_codec data with

     

       143
       143
       -
          | Ok s -> Printf.printf "YAML Flow:\n%s\n" s

     

       144
       144
       -
          | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       141
       141
       +
         let b = Buffer.create 256 in

     

       142
       142
       +
         let writer = Bytes.Writer.of_buffer b in

     

       143
       143
       +
         match Yamlt.encode ~format:Yamlt.Flow M.data_codec data ~eod:true writer with

     

       144
       144
       +
         | Ok () -> Printf.printf "YAML Flow:\n%s\n" (Buffer.contents b)

     

       145
       145
       +
         | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e

     

       145
       146
        
       

     

       146
       147
        
       (* Test: Comments in YAML (should be ignored) *)

     

       147
       148
        
       let test_comments file =

     

       148
       149
        
         let module M = struct

     

       149
       149
       -
           type config = { host: string; port: int; debug: bool }

     

       150
       150
       +
           type config = { host : string; port : int; debug : bool }

     

       150
       151
        
       

     

       151
       152
        
           let config_codec =

     

       152
       152
       -
             Jsont.Object.map ~kind:"Config" (fun host port debug -> { host; port; debug })

     

       153
       153
       +
             Jsont.Object.map ~kind:"Config" (fun host port debug ->

     

       154
       154
       +
                 { host; port; debug })

     

       153
       155
        
             |> Jsont.Object.mem "host" Jsont.string ~enc:(fun c -> c.host)

     

       154
       156
        
             |> Jsont.Object.mem "port" Jsont.int ~enc:(fun c -> c.port)

     

       155
       157
        
             |> Jsont.Object.mem "debug" Jsont.bool ~enc:(fun c -> c.debug)

     
···

       158
       160
        
           let show c =

     

       159
       161
        
             Printf.sprintf "host=%S, port=%d, debug=%b" c.host c.port c.debug

     

       160
       162
        
         end in

     

       161
       161
       -
       

     

       162
       163
        
         let yaml = read_file file in

     

       163
       163
       -
         let yaml_result = Yamlt.decode_string M.config_codec yaml in

     

       164
       164
       +
         let yaml_result = Yamlt.decode M.config_codec (Bytes.Reader.of_string yaml) in

     

       164
       165
        
       

     

       165
       166
        
         match yaml_result with

     

       166
       167
        
         | Ok v -> Printf.printf "YAML (with comments): %s\n" (M.show v)

     
···

       169
       170
        
       (* Test: Empty documents and null documents *)

     

       170
       171
        
       let test_empty_document file =

     

       171
       172
        
         let module M = struct

     

       172
       172
       -
           type wrapper = { value: string option }

     

       173
       173
       +
           type wrapper = { value : string option }

     

       173
       174
        
       

     

       174
       175
        
           let wrapper_codec =

     

       175
       176
        
             Jsont.Object.map ~kind:"Wrapper" (fun value -> { value })

     

       176
       176
       -
             |> Jsont.Object.mem "value" (Jsont.some Jsont.string) ~enc:(fun w -> w.value)

     

       177
       177
       +
             |> Jsont.Object.mem "value" (Jsont.some Jsont.string) ~enc:(fun w ->

     

       178
       178
       +
                 w.value)

     

       177
       179
        
             |> Jsont.Object.finish

     

       178
       180
        
       

     

       179
       181
        
           let show w =

     
···

       181
       183
        
             | None -> "value=None"

     

       182
       184
        
             | Some s -> Printf.sprintf "value=Some(%S)" s

     

       183
       185
        
         end in

     

       184
       184
       -
       

     

       185
       186
        
         let yaml = read_file file in

     

       186
       187
        
         let json = read_file (file ^ ".json") in

     

       187
       188
        
         let json_result = Jsont_bytesrw.decode_string M.wrapper_codec json in

     

       188
       188
       -
         let yaml_result = Yamlt.decode_string M.wrapper_codec yaml in

     

       189
       189
       +
         let yaml_result = Yamlt.decode M.wrapper_codec (Bytes.Reader.of_string yaml) in

     

       189
       190
        
       

     

       190
       191
        
         show_result_both "empty_document"

     

       191
       192
        
           (Result.map M.show json_result)

     
···

       194
       195
        
       (* Test: Explicit typing with tags (if supported) *)

     

       195
       196
        
       let test_explicit_tags file =

     

       196
       197
        
         let module M = struct

     

       197
       197
       -
           type value_holder = { data: string }

     

       198
       198
       +
           type value_holder = { data : string }

     

       198
       199
        
       

     

       199
       200
        
           let value_codec =

     

       200
       201
        
             Jsont.Object.map ~kind:"ValueHolder" (fun data -> { data })

     
···

       203
       204
        
       

     

       204
       205
        
           let show v = Printf.sprintf "data=%S" v.data

     

       205
       206
        
         end in

     

       206
       206
       -
       

     

       207
       207
        
         let yaml = read_file file in

     

       208
       208
       -
         let yaml_result = Yamlt.decode_string M.value_codec yaml in

     

       208
       208
       +
         let yaml_result = Yamlt.decode M.value_codec (Bytes.Reader.of_string yaml) in

     

       209
       209
        
       

     

       210
       210
        
         match yaml_result with

     

       211
       211
        
         | Ok v -> Printf.printf "YAML (with tags): %s\n" (M.show v)

     
···

       222
       222
        
         match Sys.argv.(1) with

     

       223
       223
        
         | "literal" when Stdlib.Array.length Sys.argv = 3 ->

     

       224
       224
        
             test_literal_string Sys.argv.(2)

     

       225
       225
       -
       

     

       226
       225
        
         | "folded" when Stdlib.Array.length Sys.argv = 3 ->

     

       227
       226
        
             test_folded_string Sys.argv.(2)

     

       228
       228
       -
       

     

       229
       227
        
         | "number-formats" when Stdlib.Array.length Sys.argv = 3 ->

     

       230
       228
        
             test_number_formats Sys.argv.(2)

     

       231
       231
       -
       

     

       232
       229
        
         | "encode-styles" when Stdlib.Array.length Sys.argv = 2 ->

     

       233
       230
        
             test_encode_styles ()

     

       234
       234
       -
       

     

       235
       231
        
         | "comments" when Stdlib.Array.length Sys.argv = 3 ->

     

       236
       232
        
             test_comments Sys.argv.(2)

     

       237
       237
       -
       

     

       238
       233
        
         | "empty-doc" when Stdlib.Array.length Sys.argv = 3 ->

     

       239
       234
        
             test_empty_document Sys.argv.(2)

     

       240
       240
       -
       

     

       241
       235
        
         | "explicit-tags" when Stdlib.Array.length Sys.argv = 3 ->

     

       242
       236
        
             test_explicit_tags Sys.argv.(2)

     

       243
       243
       -
       

     

       244
       237
        
         | _ ->

     

       245
       238
        
             prerr_endline usage;

     

       246
       239
        
             prerr_endline "Commands:";

     

       247
       240
        
             prerr_endline "  literal <file>         - Test literal multi-line strings";

     

       248
       241
        
             prerr_endline "  folded <file>          - Test folded multi-line strings";

     

       249
       249
       -
             prerr_endline "  number-formats <file>  - Test hex/octal/binary number formats";

     

       242
       242
       +
             prerr_endline

     

       243
       243
       +
               "  number-formats <file>  - Test hex/octal/binary number formats";

     

       250
       244
        
             prerr_endline "  encode-styles          - Test block vs flow encoding";

     

       251
       245
        
             prerr_endline "  comments <file>        - Test YAML with comments";

     

       252
       246
        
             prerr_endline "  empty-doc <file>       - Test empty documents";

+270

tests/bin/test_locations.ml

···

       1
       1
       +
       (*---------------------------------------------------------------------------

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
       +
       

     

       6
       6
       +
       (** Test location and layout preservation options with Yamlt codec *)

     

       7
       7
       +
       

     

       8
       8
       +
       (* Helper to read file *)

     

       9
       9
       +
       open Bytesrw

     

       10
       10
       +
       

     

       11
       11
       +
       let read_file path =

     

       12
       12
       +
         let ic = open_in path in

     

       13
       13
       +
         let len = in_channel_length ic in

     

       14
       14
       +
         let s = really_input_string ic len in

     

       15
       15
       +
         close_in ic;

     

       16
       16
       +
         s

     

       17
       17
       +
       

     

       18
       18
       +
       (* Helper to show results *)

     

       19
       19
       +
       let show_result label = function

     

       20
       20
       +
         | Ok _ -> Printf.printf "%s: OK\n" label

     

       21
       21
       +
         | Error e -> Printf.printf "%s:\n%s\n" label e

     

       22
       22
       +
       

     

       23
       23
       +
       (* Test: Compare error messages with and without locs *)

     

       24
       24
       +
       let test_error_precision file =

     

       25
       25
       +
         let yaml = read_file file in

     

       26
       26
       +
       

     

       27
       27
       +
         (* Define a codec that will fail on type mismatch *)

     

       28
       28
       +
         let codec =

     

       29
       29
       +
           Jsont.Object.map ~kind:"Person" (fun name age -> (name, age))

     

       30
       30
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:fst

     

       31
       31
       +
           |> Jsont.Object.mem "age" Jsont.int ~enc:snd

     

       32
       32
       +
           |> Jsont.Object.finish

     

       33
       33
       +
         in

     

       34
       34
       +
       

     

       35
       35
       +
         Printf.printf "=== Without locs (default) ===\n";

     

       36
       36
       +
         let result_no_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:false in

     

       37
       37
       +
         show_result "Error message" result_no_locs;

     

       38
       38
       +
       

     

       39
       39
       +
         Printf.printf "\n=== With locs=true ===\n";

     

       40
       40
       +
         let result_with_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true in

     

       41
       41
       +
         show_result "Error message" result_with_locs

     

       42
       42
       +
       

     

       43
       43
       +
       (* Test: Show error locations for nested structures *)

     

       44
       44
       +
       let test_nested_error file =

     

       45
       45
       +
         let yaml = read_file file in

     

       46
       46
       +
       

     

       47
       47
       +
         (* Nested object codec *)

     

       48
       48
       +
         let address_codec =

     

       49
       49
       +
           Jsont.Object.map ~kind:"Address" (fun street city zip ->

     

       50
       50
       +
               (street, city, zip))

     

       51
       51
       +
           |> Jsont.Object.mem "street" Jsont.string ~enc:(fun (s, _, _) -> s)

     

       52
       52
       +
           |> Jsont.Object.mem "city" Jsont.string ~enc:(fun (_, c, _) -> c)

     

       53
       53
       +
           |> Jsont.Object.mem "zip" Jsont.int ~enc:(fun (_, _, z) -> z)

     

       54
       54
       +
           |> Jsont.Object.finish

     

       55
       55
       +
         in

     

       56
       56
       +
       

     

       57
       57
       +
         let codec =

     

       58
       58
       +
           Jsont.Object.map ~kind:"Employee" (fun name address -> (name, address))

     

       59
       59
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:fst

     

       60
       60
       +
           |> Jsont.Object.mem "address" address_codec ~enc:snd

     

       61
       61
       +
           |> Jsont.Object.finish

     

       62
       62
       +
         in

     

       63
       63
       +
       

     

       64
       64
       +
         Printf.printf "=== Without locs (default) ===\n";

     

       65
       65
       +
         let result_no_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:false in

     

       66
       66
       +
         show_result "Nested error" result_no_locs;

     

       67
       67
       +
       

     

       68
       68
       +
         Printf.printf "\n=== With locs=true ===\n";

     

       69
       69
       +
         let result_with_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true in

     

       70
       70
       +
         show_result "Nested error" result_with_locs

     

       71
       71
       +
       

     

       72
       72
       +
       (* Test: Array element error locations *)

     

       73
       73
       +
       let test_array_error file =

     

       74
       74
       +
         let yaml = read_file file in

     

       75
       75
       +
       

     

       76
       76
       +
         (* Array codec *)

     

       77
       77
       +
         let codec =

     

       78
       78
       +
           Jsont.Object.map ~kind:"Numbers" (fun nums -> nums)

     

       79
       79
       +
           |> Jsont.Object.mem "values" (Jsont.array Jsont.int) ~enc:(fun n -> n)

     

       80
       80
       +
           |> Jsont.Object.finish

     

       81
       81
       +
         in

     

       82
       82
       +
       

     

       83
       83
       +
         Printf.printf "=== Without locs (default) ===\n";

     

       84
       84
       +
         let result_no_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:false in

     

       85
       85
       +
         show_result "Array error" result_no_locs;

     

       86
       86
       +
       

     

       87
       87
       +
         Printf.printf "\n=== With locs=true ===\n";

     

       88
       88
       +
         let result_with_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true in

     

       89
       89
       +
         show_result "Array error" result_with_locs

     

       90
       90
       +
       

     

       91
       91
       +
       (* Test: Layout preservation - check if we can decode with layout info *)

     

       92
       92
       +
       let test_layout_preservation file =

     

       93
       93
       +
         let yaml = read_file file in

     

       94
       94
       +
       

     

       95
       95
       +
         let codec =

     

       96
       96
       +
           Jsont.Object.map ~kind:"Config" (fun host port -> (host, port))

     

       97
       97
       +
           |> Jsont.Object.mem "host" Jsont.string ~enc:fst

     

       98
       98
       +
           |> Jsont.Object.mem "port" Jsont.int ~enc:snd

     

       99
       99
       +
           |> Jsont.Object.finish

     

       100
       100
       +
         in

     

       101
       101
       +
       

     

       102
       102
       +
         Printf.printf "=== Without layout (default) ===\n";

     

       103
       103
       +
         (match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~layout:false with

     

       104
       104
       +
         | Ok (host, port) ->

     

       105
       105
       +
             Printf.printf "Decoded: host=%s, port=%d\n" host port;

     

       106
       106
       +
             Printf.printf "Meta preserved: no\n"

     

       107
       107
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       108
       108
       +
       

     

       109
       109
       +
         Printf.printf "\n=== With layout=true ===\n";

     

       110
       110
       +
         match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~layout:true with

     

       111
       111
       +
         | Ok (host, port) ->

     

       112
       112
       +
             Printf.printf "Decoded: host=%s, port=%d\n" host port;

     

       113
       113
       +
             Printf.printf

     

       114
       114
       +
               "Meta preserved: yes (style info available for round-tripping)\n"

     

       115
       115
       +
         | Error e -> Printf.printf "Error: %s\n" e

     

       116
       116
       +
       

     

       117
       117
       +
       (* Test: Round-trip with layout preservation *)

     

       118
       118
       +
       let test_roundtrip_layout file =

     

       119
       119
       +
         let yaml = read_file file in

     

       120
       120
       +
       

     

       121
       121
       +
         let codec =

     

       122
       122
       +
           Jsont.Object.map ~kind:"Data" (fun items -> items)

     

       123
       123
       +
           |> Jsont.Object.mem "items" (Jsont.array Jsont.string) ~enc:(fun x -> x)

     

       124
       124
       +
           |> Jsont.Object.finish

     

       125
       125
       +
         in

     

       126
       126
       +
       

     

       127
       127
       +
         Printf.printf "=== Original YAML ===\n";

     

       128
       128
       +
         Printf.printf "%s\n" (String.trim yaml);

     

       129
       129
       +
       

     

       130
       130
       +
         Printf.printf "\n=== Decode without layout, re-encode ===\n";

     

       131
       131
       +
         (match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~layout:false with

     

       132
       132
       +
         | Ok items -> (

     

       133
       133
       +
             let b = Buffer.create 256 in

     

       134
       134
       +
             let writer = Bytes.Writer.of_buffer b in

     

       135
       135
       +
             match Yamlt.encode ~format:Yamlt.Block codec items ~eod:true writer with

     

       136
       136
       +
             | Ok () -> Printf.printf "%s" (Buffer.contents b)

     

       137
       137
       +
             | Error e -> Printf.printf "Encode error: %s\n" e)

     

       138
       138
       +
         | Error e -> Printf.printf "Decode error: %s\n" e);

     

       139
       139
       +
       

     

       140
       140
       +
         Printf.printf

     

       141
       141
       +
           "\n=== Decode with layout=true, re-encode with Layout format ===\n";

     

       142
       142
       +
         match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~layout:true with

     

       143
       143
       +
         | Ok items -> (

     

       144
       144
       +
             let b = Buffer.create 256 in

     

       145
       145
       +
             let writer = Bytes.Writer.of_buffer b in

     

       146
       146
       +
             match Yamlt.encode ~format:Yamlt.Layout codec items ~eod:true writer with

     

       147
       147
       +
             | Ok () -> Printf.printf "%s" (Buffer.contents b)

     

       148
       148
       +
             | Error e -> Printf.printf "Encode error: %s\n" e)

     

       149
       149
       +
         | Error e -> Printf.printf "Decode error: %s\n" e

     

       150
       150
       +
       

     

       151
       151
       +
       (* Test: File path in error messages *)

     

       152
       152
       +
       let test_file_path () =

     

       153
       153
       +
         let yaml = "name: Alice\nage: not-a-number\n" in

     

       154
       154
       +
       

     

       155
       155
       +
         let codec =

     

       156
       156
       +
           Jsont.Object.map ~kind:"Person" (fun name age -> (name, age))

     

       157
       157
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:fst

     

       158
       158
       +
           |> Jsont.Object.mem "age" Jsont.int ~enc:snd

     

       159
       159
       +
           |> Jsont.Object.finish

     

       160
       160
       +
         in

     

       161
       161
       +
       

     

       162
       162
       +
         Printf.printf "=== Without file path ===\n";

     

       163
       163
       +
         let result1 = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true in

     

       164
       164
       +
         show_result "Error" result1;

     

       165
       165
       +
       

     

       166
       166
       +
         Printf.printf "\n=== With file path ===\n";

     

       167
       167
       +
         let result2 = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true ~file:"test.yml" in

     

       168
       168
       +
         show_result "Error" result2

     

       169
       169
       +
       

     

       170
       170
       +
       (* Test: Missing field error with locs *)

     

       171
       171
       +
       let test_missing_field file =

     

       172
       172
       +
         let yaml = read_file file in

     

       173
       173
       +
       

     

       174
       174
       +
         let codec =

     

       175
       175
       +
           Jsont.Object.map ~kind:"Complete" (fun a b c -> (a, b, c))

     

       176
       176
       +
           |> Jsont.Object.mem "field_a" Jsont.string ~enc:(fun (a, _, _) -> a)

     

       177
       177
       +
           |> Jsont.Object.mem "field_b" Jsont.int ~enc:(fun (_, b, _) -> b)

     

       178
       178
       +
           |> Jsont.Object.mem "field_c" Jsont.bool ~enc:(fun (_, _, c) -> c)

     

       179
       179
       +
           |> Jsont.Object.finish

     

       180
       180
       +
         in

     

       181
       181
       +
       

     

       182
       182
       +
         Printf.printf "=== Without locs ===\n";

     

       183
       183
       +
         let result_no_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:false in

     

       184
       184
       +
         show_result "Missing field" result_no_locs;

     

       185
       185
       +
       

     

       186
       186
       +
         Printf.printf "\n=== With locs=true ===\n";

     

       187
       187
       +
         let result_with_locs = Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true in

     

       188
       188
       +
         show_result "Missing field" result_with_locs

     

       189
       189
       +
       

     

       190
       190
       +
       (* Test: Both locs and layout together *)

     

       191
       191
       +
       let test_combined_options file =

     

       192
       192
       +
         let yaml = read_file file in

     

       193
       193
       +
       

     

       194
       194
       +
         let codec =

     

       195
       195
       +
           Jsont.Object.map ~kind:"Settings" (fun timeout retries ->

     

       196
       196
       +
               (timeout, retries))

     

       197
       197
       +
           |> Jsont.Object.mem "timeout" Jsont.int ~enc:fst

     

       198
       198
       +
           |> Jsont.Object.mem "retries" Jsont.int ~enc:snd

     

       199
       199
       +
           |> Jsont.Object.finish

     

       200
       200
       +
         in

     

       201
       201
       +
       

     

       202
       202
       +
         Printf.printf "=== locs=false, layout=false (defaults) ===\n";

     

       203
       203
       +
         (match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:false ~layout:false with

     

       204
       204
       +
         | Ok (timeout, retries) ->

     

       205
       205
       +
             Printf.printf "OK: timeout=%d, retries=%d\n" timeout retries

     

       206
       206
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       207
       207
       +
       

     

       208
       208
       +
         Printf.printf "\n=== locs=true, layout=false ===\n";

     

       209
       209
       +
         (match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true ~layout:false with

     

       210
       210
       +
         | Ok (timeout, retries) ->

     

       211
       211
       +
             Printf.printf "OK: timeout=%d, retries=%d (with precise locations)\n"

     

       212
       212
       +
               timeout retries

     

       213
       213
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       214
       214
       +
       

     

       215
       215
       +
         Printf.printf "\n=== locs=false, layout=true ===\n";

     

       216
       216
       +
         (match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:false ~layout:true with

     

       217
       217
       +
         | Ok (timeout, retries) ->

     

       218
       218
       +
             Printf.printf "OK: timeout=%d, retries=%d (with layout metadata)\n"

     

       219
       219
       +
               timeout retries

     

       220
       220
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       221
       221
       +
       

     

       222
       222
       +
         Printf.printf "\n=== locs=true, layout=true (both enabled) ===\n";

     

       223
       223
       +
         match Yamlt.decode codec (Bytes.Reader.of_string yaml) ~locs:true ~layout:true with

     

       224
       224
       +
         | Ok (timeout, retries) ->

     

       225
       225
       +
             Printf.printf "OK: timeout=%d, retries=%d (with locations and layout)\n"

     

       226
       226
       +
               timeout retries

     

       227
       227
       +
         | Error e -> Printf.printf "Error: %s\n" e

     

       228
       228
       +
       

     

       229
       229
       +
       let () =

     

       230
       230
       +
         let usage = "Usage: test_locations <command> [args...]" in

     

       231
       231
       +
       

     

       232
       232
       +
         if Stdlib.Array.length Sys.argv < 2 then begin

     

       233
       233
       +
           prerr_endline usage;

     

       234
       234
       +
           exit 1

     

       235
       235
       +
         end;

     

       236
       236
       +
       

     

       237
       237
       +
         match Sys.argv.(1) with

     

       238
       238
       +
         | "error-precision" when Array.length Sys.argv = 3 ->

     

       239
       239
       +
             test_error_precision Sys.argv.(2)

     

       240
       240
       +
         | "nested-error" when Array.length Sys.argv = 3 ->

     

       241
       241
       +
             test_nested_error Sys.argv.(2)

     

       242
       242
       +
         | "array-error" when Array.length Sys.argv = 3 ->

     

       243
       243
       +
             test_array_error Sys.argv.(2)

     

       244
       244
       +
         | "layout" when Array.length Sys.argv = 3 ->

     

       245
       245
       +
             test_layout_preservation Sys.argv.(2)

     

       246
       246
       +
         | "roundtrip" when Array.length Sys.argv = 3 ->

     

       247
       247
       +
             test_roundtrip_layout Sys.argv.(2)

     

       248
       248
       +
         | "file-path" -> test_file_path ()

     

       249
       249
       +
         | "missing-field" when Array.length Sys.argv = 3 ->

     

       250
       250
       +
             test_missing_field Sys.argv.(2)

     

       251
       251
       +
         | "combined" when Array.length Sys.argv = 3 ->

     

       252
       252
       +
             test_combined_options Sys.argv.(2)

     

       253
       253
       +
         | _ ->

     

       254
       254
       +
             prerr_endline usage;

     

       255
       255
       +
             prerr_endline "Commands:";

     

       256
       256
       +
             prerr_endline

     

       257
       257
       +
               "  error-precision <file>   - Compare error messages with/without locs";

     

       258
       258
       +
             prerr_endline

     

       259
       259
       +
               "  nested-error <file>      - Test error locations in nested objects";

     

       260
       260
       +
             prerr_endline

     

       261
       261
       +
               "  array-error <file>       - Test error locations in arrays";

     

       262
       262
       +
             prerr_endline "  layout <file>            - Test layout preservation";

     

       263
       263
       +
             prerr_endline

     

       264
       264
       +
               "  roundtrip <file>         - Test round-tripping with layout";

     

       265
       265
       +
             prerr_endline

     

       266
       266
       +
               "  file-path                - Test file path in error messages";

     

       267
       267
       +
             prerr_endline

     

       268
       268
       +
               "  missing-field <file>     - Test missing field errors with locs";

     

       269
       269
       +
             prerr_endline "  combined <file>          - Test locs and layout together";

     

       270
       270
       +
             exit 1

+240

tests/bin/test_multidoc.ml

···

       1
       1
       +
       (*---------------------------------------------------------------------------

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
       +
       

     

       6
       6
       +
       (** Test multi-document YAML streams with decode_all *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Bytesrw

     

       9
       9
       +
       

     

       10
       10
       +
       (* Helper to read file *)

     

       11
       11
       +
       let read_file path =

     

       12
       12
       +
         let ic = open_in path in

     

       13
       13
       +
         let len = in_channel_length ic in

     

       14
       14
       +
         let s = really_input_string ic len in

     

       15
       15
       +
         close_in ic;

     

       16
       16
       +
         s

     

       17
       17
       +
       

     

       18
       18
       +
       (* Helper to show results *)

     

       19
       19
       +
       let show_result label = function

     

       20
       20
       +
         | Ok v -> Printf.printf "%s: %s\n" label v

     

       21
       21
       +
         | Error e -> Printf.printf "%s: ERROR: %s\n" label e

     

       22
       22
       +
       

     

       23
       23
       +
       (* Test: Simple multi-document stream *)

     

       24
       24
       +
       let test_simple file =

     

       25
       25
       +
         let module M = struct

     

       26
       26
       +
           type person = { name : string; age : int }

     

       27
       27
       +
       

     

       28
       28
       +
           let person_codec =

     

       29
       29
       +
             Jsont.Object.map ~kind:"Person" (fun name age -> { name; age })

     

       30
       30
       +
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)

     

       31
       31
       +
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun p -> p.age)

     

       32
       32
       +
             |> Jsont.Object.finish

     

       33
       33
       +
       

     

       34
       34
       +
           let show p = Printf.sprintf "%s (age %d)" p.name p.age

     

       35
       35
       +
         end in

     

       36
       36
       +
         let yaml = read_file file in

     

       37
       37
       +
         let reader = Bytes.Reader.of_string yaml in

     

       38
       38
       +
         let seq = Yamlt.decode_all M.person_codec reader in

     

       39
       39
       +
         Printf.printf "Documents:\n";

     

       40
       40
       +
         seq |> Seq.iteri (fun i result ->

     

       41
       41
       +
           Printf.printf "  [%d] " i;

     

       42
       42
       +
           show_result "" (Result.map M.show result)

     

       43
       43
       +
         )

     

       44
       44
       +
       

     

       45
       45
       +
       (* Test: Count documents *)

     

       46
       46
       +
       let test_count file =

     

       47
       47
       +
         let yaml = read_file file in

     

       48
       48
       +
         let reader = Bytes.Reader.of_string yaml in

     

       49
       49
       +
         let seq = Yamlt.decode_all Jsont.json reader in

     

       50
       50
       +
         let count = Seq.fold_left (fun acc _ -> acc + 1) 0 seq in

     

       51
       51
       +
         Printf.printf "Document count: %d\n" count

     

       52
       52
       +
       

     

       53
       53
       +
       (* Test: Error tracking - show which documents succeed and which fail *)

     

       54
       54
       +
       let test_errors file =

     

       55
       55
       +
         let module M = struct

     

       56
       56
       +
           type person = { name : string; age : int }

     

       57
       57
       +
       

     

       58
       58
       +
           let person_codec =

     

       59
       59
       +
             Jsont.Object.map ~kind:"Person" (fun name age -> { name; age })

     

       60
       60
       +
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)

     

       61
       61
       +
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun p -> p.age)

     

       62
       62
       +
             |> Jsont.Object.finish

     

       63
       63
       +
       

     

       64
       64
       +
           let show p = Printf.sprintf "%s (age %d)" p.name p.age

     

       65
       65
       +
         end in

     

       66
       66
       +
         let yaml = read_file file in

     

       67
       67
       +
         let reader = Bytes.Reader.of_string yaml in

     

       68
       68
       +
         let seq = Yamlt.decode_all M.person_codec reader in

     

       69
       69
       +
         Printf.printf "Document results:\n";

     

       70
       70
       +
         seq |> Seq.iteri (fun i result ->

     

       71
       71
       +
           match result with

     

       72
       72
       +
           | Ok p -> Printf.printf "  [%d] OK: %s\n" i (M.show p)

     

       73
       73
       +
           | Error e -> Printf.printf "  [%d] ERROR: %s\n" i (String.trim e)

     

       74
       74
       +
         )

     

       75
       75
       +
       

     

       76
       76
       +
       (* Test: Location tracking with locs=true *)

     

       77
       77
       +
       let test_locations file =

     

       78
       78
       +
         let module M = struct

     

       79
       79
       +
           type person = { name : string; age : int }

     

       80
       80
       +
       

     

       81
       81
       +
           let person_codec =

     

       82
       82
       +
             Jsont.Object.map ~kind:"Person" (fun name age -> { name; age })

     

       83
       83
       +
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)

     

       84
       84
       +
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun p -> p.age)

     

       85
       85
       +
             |> Jsont.Object.finish

     

       86
       86
       +
         end in

     

       87
       87
       +
         let yaml = read_file file in

     

       88
       88
       +
       

     

       89
       89
       +
         Printf.printf "=== Without locs (default) ===\n";

     

       90
       90
       +
         let reader = Bytes.Reader.of_string yaml in

     

       91
       91
       +
         let seq = Yamlt.decode_all ~locs:false M.person_codec reader in

     

       92
       92
       +
         seq |> Seq.iteri (fun i result ->

     

       93
       93
       +
           match result with

     

       94
       94
       +
           | Ok _ -> Printf.printf "  [%d] OK\n" i

     

       95
       95
       +
           | Error e -> Printf.printf "  [%d] ERROR:\n%s\n" i (String.trim e)

     

       96
       96
       +
         );

     

       97
       97
       +
       

     

       98
       98
       +
         Printf.printf "\n=== With locs=true ===\n";

     

       99
       99
       +
         let reader = Bytes.Reader.of_string yaml in

     

       100
       100
       +
         let seq = Yamlt.decode_all ~locs:true ~file:"test.yml" M.person_codec reader in

     

       101
       101
       +
         seq |> Seq.iteri (fun i result ->

     

       102
       102
       +
           match result with

     

       103
       103
       +
           | Ok _ -> Printf.printf "  [%d] OK\n" i

     

       104
       104
       +
           | Error e -> Printf.printf "  [%d] ERROR:\n%s\n" i (String.trim e)

     

       105
       105
       +
         )

     

       106
       106
       +
       

     

       107
       107
       +
       (* Test: Roundtrip to JSON - decode YAML multidoc, encode each to JSON *)

     

       108
       108
       +
       let test_json_roundtrip file =

     

       109
       109
       +
         let yaml = read_file file in

     

       110
       110
       +
         let reader = Bytes.Reader.of_string yaml in

     

       111
       111
       +
         let seq = Yamlt.decode_all Jsont.json reader in

     

       112
       112
       +
         Printf.printf "JSON outputs:\n";

     

       113
       113
       +
         seq |> Seq.iteri (fun i result ->

     

       114
       114
       +
           match result with

     

       115
       115
       +
           | Ok json_val ->

     

       116
       116
       +
               (match Jsont_bytesrw.encode_string Jsont.json json_val with

     

       117
       117
       +
                | Ok json_str -> Printf.printf "  [%d] %s\n" i (String.trim json_str)

     

       118
       118
       +
                | Error e -> Printf.printf "  [%d] ENCODE ERROR: %s\n" i e)

     

       119
       119
       +
           | Error e -> Printf.printf "  [%d] DECODE ERROR: %s\n" i (String.trim e)

     

       120
       120
       +
         )

     

       121
       121
       +
       

     

       122
       122
       +
       (* Test: Nested objects in multidoc *)

     

       123
       123
       +
       let test_nested file =

     

       124
       124
       +
         let module M = struct

     

       125
       125
       +
           type address = { street : string; city : string }

     

       126
       126
       +
           type person = { name : string; age : int; address : address }

     

       127
       127
       +
       

     

       128
       128
       +
           let address_codec =

     

       129
       129
       +
             Jsont.Object.map ~kind:"Address" (fun street city -> { street; city })

     

       130
       130
       +
             |> Jsont.Object.mem "street" Jsont.string ~enc:(fun a -> a.street)

     

       131
       131
       +
             |> Jsont.Object.mem "city" Jsont.string ~enc:(fun a -> a.city)

     

       132
       132
       +
             |> Jsont.Object.finish

     

       133
       133
       +
       

     

       134
       134
       +
           let person_codec =

     

       135
       135
       +
             Jsont.Object.map ~kind:"Person" (fun name age address ->

     

       136
       136
       +
                 { name; age; address })

     

       137
       137
       +
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)

     

       138
       138
       +
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun p -> p.age)

     

       139
       139
       +
             |> Jsont.Object.mem "address" address_codec ~enc:(fun p -> p.address)

     

       140
       140
       +
             |> Jsont.Object.finish

     

       141
       141
       +
       

     

       142
       142
       +
           let show p =

     

       143
       143
       +
             Printf.sprintf "%s (age %d) from %s, %s" p.name p.age p.address.street

     

       144
       144
       +
               p.address.city

     

       145
       145
       +
         end in

     

       146
       146
       +
         let yaml = read_file file in

     

       147
       147
       +
         let reader = Bytes.Reader.of_string yaml in

     

       148
       148
       +
         let seq = Yamlt.decode_all M.person_codec reader in

     

       149
       149
       +
         Printf.printf "Nested documents:\n";

     

       150
       150
       +
         seq |> Seq.iteri (fun i result ->

     

       151
       151
       +
           Printf.printf "  [%d] " i;

     

       152
       152
       +
           show_result "" (Result.map M.show result)

     

       153
       153
       +
         )

     

       154
       154
       +
       

     

       155
       155
       +
       (* Test: Arrays in multidoc *)

     

       156
       156
       +
       let test_arrays file =

     

       157
       157
       +
         let yaml = read_file file in

     

       158
       158
       +
         let reader = Bytes.Reader.of_string yaml in

     

       159
       159
       +
         let seq = Yamlt.decode_all Jsont.json reader in

     

       160
       160
       +
         Printf.printf "Array documents:\n";

     

       161
       161
       +
         seq |> Seq.iteri (fun i result ->

     

       162
       162
       +
           match result with

     

       163
       163
       +
           | Ok json_val ->

     

       164
       164
       +
               (match Jsont_bytesrw.encode_string Jsont.json json_val with

     

       165
       165
       +
                | Ok json_str -> Printf.printf "  [%d] %s\n" i (String.trim json_str)

     

       166
       166
       +
                | Error e -> Printf.printf "  [%d] ERROR: %s\n" i e)

     

       167
       167
       +
           | Error e -> Printf.printf "  [%d] ERROR: %s\n" i (String.trim e)

     

       168
       168
       +
         )

     

       169
       169
       +
       

     

       170
       170
       +
       (* Test: Scalars in multidoc *)

     

       171
       171
       +
       let test_scalars file =

     

       172
       172
       +
         let yaml = read_file file in

     

       173
       173
       +
         let reader = Bytes.Reader.of_string yaml in

     

       174
       174
       +
         let seq = Yamlt.decode_all Jsont.json reader in

     

       175
       175
       +
         Printf.printf "Scalar documents:\n";

     

       176
       176
       +
         seq |> Seq.iteri (fun i result ->

     

       177
       177
       +
           match result with

     

       178
       178
       +
           | Ok json_val ->

     

       179
       179
       +
               (match Jsont_bytesrw.encode_string Jsont.json json_val with

     

       180
       180
       +
                | Ok json_str -> Printf.printf "  [%d] %s\n" i (String.trim json_str)

     

       181
       181
       +
                | Error e -> Printf.printf "  [%d] ERROR: %s\n" i e)

     

       182
       182
       +
           | Error e -> Printf.printf "  [%d] ERROR: %s\n" i (String.trim e)

     

       183
       183
       +
         )

     

       184
       184
       +
       

     

       185
       185
       +
       (* Test: Summary stats - count successes vs failures *)

     

       186
       186
       +
       let test_summary file =

     

       187
       187
       +
         let module M = struct

     

       188
       188
       +
           type person = { name : string; age : int }

     

       189
       189
       +
       

     

       190
       190
       +
           let person_codec =

     

       191
       191
       +
             Jsont.Object.map ~kind:"Person" (fun name age -> { name; age })

     

       192
       192
       +
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)

     

       193
       193
       +
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun p -> p.age)

     

       194
       194
       +
             |> Jsont.Object.finish

     

       195
       195
       +
         end in

     

       196
       196
       +
         let yaml = read_file file in

     

       197
       197
       +
         let reader = Bytes.Reader.of_string yaml in

     

       198
       198
       +
         let seq = Yamlt.decode_all M.person_codec reader in

     

       199
       199
       +
         let success = ref 0 in

     

       200
       200
       +
         let failure = ref 0 in

     

       201
       201
       +
         seq |> Seq.iter (fun result ->

     

       202
       202
       +
           match result with

     

       203
       203
       +
           | Ok _ -> incr success

     

       204
       204
       +
           | Error _ -> incr failure

     

       205
       205
       +
         );

     

       206
       206
       +
         Printf.printf "Summary: %d documents (%d ok, %d error)\n"

     

       207
       207
       +
           (!success + !failure) !success !failure

     

       208
       208
       +
       

     

       209
       209
       +
       let () =

     

       210
       210
       +
         let usage = "Usage: test_multidoc <command> <file>" in

     

       211
       211
       +
         if Array.length Sys.argv < 3 then begin

     

       212
       212
       +
           prerr_endline usage;

     

       213
       213
       +
           exit 1

     

       214
       214
       +
         end;

     

       215
       215
       +
       

     

       216
       216
       +
         let test = Sys.argv.(1) in

     

       217
       217
       +
         let file = Sys.argv.(2) in

     

       218
       218
       +
         match test with

     

       219
       219
       +
         | "simple" -> test_simple file

     

       220
       220
       +
         | "count" -> test_count file

     

       221
       221
       +
         | "errors" -> test_errors file

     

       222
       222
       +
         | "locations" -> test_locations file

     

       223
       223
       +
         | "json" -> test_json_roundtrip file

     

       224
       224
       +
         | "nested" -> test_nested file

     

       225
       225
       +
         | "arrays" -> test_arrays file

     

       226
       226
       +
         | "scalars" -> test_scalars file

     

       227
       227
       +
         | "summary" -> test_summary file

     

       228
       228
       +
         | _ ->

     

       229
       229
       +
             prerr_endline usage;

     

       230
       230
       +
             prerr_endline "Commands:";

     

       231
       231
       +
             prerr_endline "  simple <file>     - Decode person documents";

     

       232
       232
       +
             prerr_endline "  count <file>      - Count documents";

     

       233
       233
       +
             prerr_endline "  errors <file>     - Show success/error for each document";

     

       234
       234
       +
             prerr_endline "  locations <file>  - Test location tracking with locs=true";

     

       235
       235
       +
             prerr_endline "  json <file>       - Roundtrip to JSON";

     

       236
       236
       +
             prerr_endline "  nested <file>     - Decode nested objects";

     

       237
       237
       +
             prerr_endline "  arrays <file>     - Decode arrays";

     

       238
       238
       +
             prerr_endline "  scalars <file>    - Decode scalars";

     

       239
       239
       +
             prerr_endline "  summary <file>    - Show success/failure summary";

     

       240
       240
       +
             exit 1

+89

tests/bin/test_null_collections.ml

···

       1
       1
       +
       open Bytesrw

     

       2
       2
       +
       

     

       3
       3
       +
       let () =

     

       4
       4
       +
         Printf.printf "=== Test 1: Explicit null as empty array ===\n";

     

       5
       5
       +
         let yaml1 = "values: null" in

     

       6
       6
       +
         let codec1 =

     

       7
       7
       +
           let open Jsont in

     

       8
       8
       +
           Object.map ~kind:"Test" (fun v -> v)

     

       9
       9
       +
           |> Object.mem "values" (list int) ~dec_absent:[] ~enc:(fun v -> v)

     

       10
       10
       +
           |> Object.finish

     

       11
       11
       +
         in

     

       12
       12
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string yaml1) with

     

       13
       13
       +
         | Ok v ->

     

       14
       14
       +
             Printf.printf "Result: [%s]\n"

     

       15
       15
       +
               (String.concat "; " (List.map string_of_int v))

     

       16
       16
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       17
       17
       +
       

     

       18
       18
       +
         Printf.printf "\n=== Test 2: Tilde as empty array ===\n";

     

       19
       19
       +
         let yaml2 = "values: ~" in

     

       20
       20
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string yaml2) with

     

       21
       21
       +
         | Ok v ->

     

       22
       22
       +
             Printf.printf "Result: [%s]\n"

     

       23
       23
       +
               (String.concat "; " (List.map string_of_int v))

     

       24
       24
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       25
       25
       +
       

     

       26
       26
       +
         Printf.printf "\n=== Test 3: Empty array syntax ===\n";

     

       27
       27
       +
         let yaml3 = "values: []" in

     

       28
       28
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string yaml3) with

     

       29
       29
       +
         | Ok v ->

     

       30
       30
       +
             Printf.printf "Result: [%s]\n"

     

       31
       31
       +
               (String.concat "; " (List.map string_of_int v))

     

       32
       32
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       33
       33
       +
       

     

       34
       34
       +
         Printf.printf "\n=== Test 4: Array with values ===\n";

     

       35
       35
       +
         let yaml4 = "values: [1, 2, 3]" in

     

       36
       36
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string yaml4) with

     

       37
       37
       +
         | Ok v ->

     

       38
       38
       +
             Printf.printf "Result: [%s]\n"

     

       39
       39
       +
               (String.concat "; " (List.map string_of_int v))

     

       40
       40
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       41
       41
       +
       

     

       42
       42
       +
         Printf.printf "\n=== Test 5: Explicit null as empty object ===\n";

     

       43
       43
       +
         let yaml5 = "config: null" in

     

       44
       44
       +
         let codec2 =

     

       45
       45
       +
           let open Jsont in

     

       46
       46
       +
           let config_codec =

     

       47
       47
       +
             Object.map ~kind:"Config" (fun timeout retries -> (timeout, retries))

     

       48
       48
       +
             |> Object.mem "timeout" int ~dec_absent:30 ~enc:fst

     

       49
       49
       +
             |> Object.mem "retries" int ~dec_absent:3 ~enc:snd

     

       50
       50
       +
             |> Object.finish

     

       51
       51
       +
           in

     

       52
       52
       +
           Object.map ~kind:"Test" (fun c -> c)

     

       53
       53
       +
           |> Object.mem "config" config_codec ~dec_absent:(30, 3) ~enc:(fun c -> c)

     

       54
       54
       +
           |> Object.finish

     

       55
       55
       +
         in

     

       56
       56
       +
         (match Yamlt.decode codec2 (Bytes.Reader.of_string yaml5) with

     

       57
       57
       +
         | Ok (timeout, retries) ->

     

       58
       58
       +
             Printf.printf "Result: {timeout=%d; retries=%d}\n" timeout retries

     

       59
       59
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       60
       60
       +
       

     

       61
       61
       +
         Printf.printf "\n=== Test 6: Empty object syntax ===\n";

     

       62
       62
       +
         let yaml6 = "config: {}" in

     

       63
       63
       +
         (match Yamlt.decode codec2 (Bytes.Reader.of_string yaml6) with

     

       64
       64
       +
         | Ok (timeout, retries) ->

     

       65
       65
       +
             Printf.printf "Result: {timeout=%d; retries=%d}\n" timeout retries

     

       66
       66
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       67
       67
       +
       

     

       68
       68
       +
         Printf.printf "\n=== Test 7: Object with values ===\n";

     

       69
       69
       +
         let yaml7 = "config:\n  timeout: 60\n  retries: 5" in

     

       70
       70
       +
         (match Yamlt.decode codec2 (Bytes.Reader.of_string yaml7) with

     

       71
       71
       +
         | Ok (timeout, retries) ->

     

       72
       72
       +
             Printf.printf "Result: {timeout=%d; retries=%d}\n" timeout retries

     

       73
       73
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       74
       74
       +
       

     

       75
       75
       +
         Printf.printf "\n=== Test 8: Nested null arrays ===\n";

     

       76
       76
       +
         let yaml8 = "name: test\nitems: null\ntags: ~" in

     

       77
       77
       +
         let codec3 =

     

       78
       78
       +
           let open Jsont in

     

       79
       79
       +
           Object.map ~kind:"Nested" (fun name items tags -> (name, items, tags))

     

       80
       80
       +
           |> Object.mem "name" string ~enc:(fun (n, _, _) -> n)

     

       81
       81
       +
           |> Object.mem "items" (list int) ~dec_absent:[] ~enc:(fun (_, i, _) -> i)

     

       82
       82
       +
           |> Object.mem "tags" (list string) ~dec_absent:[] ~enc:(fun (_, _, t) -> t)

     

       83
       83
       +
           |> Object.finish

     

       84
       84
       +
         in

     

       85
       85
       +
         match Yamlt.decode codec3 (Bytes.Reader.of_string yaml8) with

     

       86
       86
       +
         | Ok (name, items, tags) ->

     

       87
       87
       +
             Printf.printf "Result: {name=%s; items_count=%d; tags_count=%d}\n"

     

       88
       88
       +
               name (List.length items) (List.length tags)

     

       89
       89
       +
         | Error e -> Printf.printf "Error: %s\n" e

+18 -12

tests/bin/test_null_complete.ml

···

       1
       1
       +
       open Bytesrw

     

       2
       2
       +
       

     

       1
       3
        
       let () =

     

       2
       4
        
         Printf.printf "=== Test 1: Jsont.option with YAML null ===\n";

     

       3
       5
        
         let yaml1 = "value: null" in

     
···

       7
       9
        
           |> Object.mem "value" (option string) ~enc:(fun v -> v)

     

       8
       10
        
           |> Object.finish

     

       9
       11
        
         in

     

       10
       10
       -
         (match Yamlt.decode_string codec1 yaml1 with

     

       11
       11
       -
          | Ok v -> Printf.printf "Result: %s\n" (match v with None -> "None" | Some s -> "Some(" ^ s ^ ")")

     

       12
       12
       -
          | Error e -> Printf.printf "Error: %s\n" e);

     

       12
       12
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string yaml1) with

     

       13
       13
       +
         | Ok v ->

     

       14
       14
       +
             Printf.printf "Result: %s\n"

     

       15
       15
       +
               (match v with None -> "None" | Some s -> "Some(" ^ s ^ ")")

     

       16
       16
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       13
       17
        
       

     

       14
       18
        
         Printf.printf "\n=== Test 2: Jsont.option with YAML string ===\n";

     

       15
       15
       -
         (match Yamlt.decode_string codec1 "value: hello" with

     

       16
       16
       -
          | Ok v -> Printf.printf "Result: %s\n" (match v with None -> "None" | Some s -> "Some(" ^ s ^ ")")

     

       17
       17
       -
          | Error e -> Printf.printf "Error: %s\n" e);

     

       19
       19
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string "value: hello") with

     

       20
       20
       +
         | Ok v ->

     

       21
       21
       +
             Printf.printf "Result: %s\n"

     

       22
       22
       +
               (match v with None -> "None" | Some s -> "Some(" ^ s ^ ")")

     

       23
       23
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       18
       24
        
       

     

       19
       25
        
         Printf.printf "\n=== Test 3: Jsont.string with YAML null (should error) ===\n";

     

       20
       26
        
         let codec2 =

     
···

       23
       29
        
           |> Object.mem "value" string ~enc:(fun v -> v)

     

       24
       30
        
           |> Object.finish

     

       25
       31
        
         in

     

       26
       26
       -
         (match Yamlt.decode_string codec2 "value: null" with

     

       27
       27
       -
          | Ok v -> Printf.printf "Result: %s\n" v

     

       28
       28
       -
          | Error e -> Printf.printf "Error (expected): %s\n" e);

     

       32
       32
       +
         (match Yamlt.decode codec2 (Bytes.Reader.of_string "value: null") with

     

       33
       33
       +
         | Ok v -> Printf.printf "Result: %s\n" v

     

       34
       34
       +
         | Error e -> Printf.printf "Error (expected): %s\n" e);

     

       29
       35
        
       

     

       30
       36
        
         Printf.printf "\n=== Test 4: Jsont.string with YAML string ===\n";

     

       31
       31
       -
         (match Yamlt.decode_string codec2 "value: hello" with

     

       32
       32
       -
          | Ok v -> Printf.printf "Result: %s\n" v

     

       33
       33
       -
          | Error e -> Printf.printf "Error: %s\n" e)

     

       37
       37
       +
         match Yamlt.decode codec2 (Bytes.Reader.of_string "value: hello") with

     

       38
       38
       +
         | Ok v -> Printf.printf "Result: %s\n" v

     

       39
       39
       +
         | Error e -> Printf.printf "Error: %s\n" e

+19 -18

tests/bin/test_null_fix.ml

···

       1
       1
       -
       open Jsont

     

       1
       1
       +
       open Bytesrw

     

       2
       2
        
       

     

       3
       3
        
       let () =

     

       4
       4
        
         let module M = struct

     

       5
       5
       -
           type data = { value: string option }

     

       6
       6
       -
           

     

       5
       5
       +
           type data = { value : string option }

     

       6
       6
       +
       

     

       7
       7
        
           let data_codec =

     

       8
       8
        
             Jsont.Object.map ~kind:"Data" (fun value -> { value })

     

       9
       9
       -
             |> Jsont.Object.mem "value" (Jsont.option Jsont.string) ~enc:(fun d -> d.value)

     

       9
       9
       +
             |> Jsont.Object.mem "value" (Jsont.option Jsont.string) ~enc:(fun d ->

     

       10
       10
       +
                 d.value)

     

       10
       11
        
             |> Jsont.Object.finish

     

       11
       12
        
         end in

     

       12
       12
       -
       

     

       13
       13
        
         let yaml_null = "value: null" in

     

       14
       14
        
       

     

       15
       15
        
         Printf.printf "Testing YAML null handling with Jsont.option Jsont.string:\n\n";

     

       16
       16
        
       

     

       17
       17
       -
         match Yamlt.decode_string M.data_codec yaml_null with

     

       18
       18
       -
         | Ok data ->

     

       19
       19
       -
             (match data.M.value with

     

       20
       20
       -
              | None -> Printf.printf "YAML: value=None (CORRECT)\n"

     

       21
       21
       -
              | Some s -> Printf.printf "YAML: value=Some(%S) (BUG!)\n" s)

     

       22
       22
       -
         | Error e -> Printf.printf "YAML ERROR: %s\n" e;

     

       17
       17
       +
         match Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml_null) with

     

       18
       18
       +
         | Ok data -> (

     

       19
       19
       +
             match data.M.value with

     

       20
       20
       +
             | None -> Printf.printf "YAML: value=None (CORRECT)\n"

     

       21
       21
       +
             | Some s -> Printf.printf "YAML: value=Some(%S) (BUG!)\n" s)

     

       22
       22
       +
         | Error e -> (

     

       23
       23
       +
             Printf.printf "YAML ERROR: %s\n" e;

     

       23
       24
        
       

     

       24
       24
       -
         let json_null = "{\"value\": null}" in

     

       25
       25
       -
         match Jsont_bytesrw.decode_string M.data_codec json_null with

     

       26
       26
       -
         | Ok data ->

     

       27
       27
       -
             (match data.M.value with

     

       28
       28
       -
              | None -> Printf.printf "JSON: value=None (CORRECT)\n"

     

       29
       29
       -
              | Some s -> Printf.printf "JSON: value=Some(%S) (BUG!)\n" s)

     

       30
       30
       -
         | Error e -> Printf.printf "JSON ERROR: %s\n" e

     

       25
       25
       +
             let json_null = "{\"value\": null}" in

     

       26
       26
       +
             match Jsont_bytesrw.decode_string M.data_codec json_null with

     

       27
       27
       +
             | Ok data -> (

     

       28
       28
       +
                 match data.M.value with

     

       29
       29
       +
                 | None -> Printf.printf "JSON: value=None (CORRECT)\n"

     

       30
       30
       +
                 | Some s -> Printf.printf "JSON: value=Some(%S) (BUG!)\n" s)

     

       31
       31
       +
             | Error e -> Printf.printf "JSON ERROR: %s\n" e)

+68 -73

tests/bin/test_objects.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** Test object codec functionality with Yamlt *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Bytesrw

     

       7
       9
        
       

     

       8
       10
        
       (* Helper to read file *)

     

       9
       11
        
       let read_file path =

     
···

       27
       29
        
       (* Test: Simple object with required fields *)

     

       28
       30
        
       let test_simple_object file =

     

       29
       31
        
         let module M = struct

     

       30
       30
       -
           type person = { name: string; age: int }

     

       32
       32
       +
           type person = { name : string; age : int }

     

       31
       33
        
       

     

       32
       34
        
           let person_codec =

     

       33
       35
        
             Jsont.Object.map ~kind:"Person" (fun name age -> { name; age })

     
···

       37
       39
        
       

     

       38
       40
        
           let show p = Printf.sprintf "{name=%S; age=%d}" p.name p.age

     

       39
       41
        
         end in

     

       40
       40
       -
       

     

       41
       42
        
         let yaml = read_file file in

     

       42
       43
        
         let json = read_file (file ^ ".json") in

     

       43
       44
        
         let json_result = Jsont_bytesrw.decode_string M.person_codec json in

     

       44
       44
       -
         let yaml_result = Yamlt.decode_string M.person_codec yaml in

     

       45
       45
       +
         let yaml_result = Yamlt.decode M.person_codec (Bytes.Reader.of_string yaml) in

     

       45
       46
        
       

     

       46
       47
        
         show_result_both "person"

     

       47
       48
        
           (Result.map M.show json_result)

     
···

       50
       51
        
       (* Test: Object with optional fields *)

     

       51
       52
        
       let test_optional_fields file =

     

       52
       53
        
         let module M = struct

     

       53
       53
       -
           type config = { host: string; port: int option; debug: bool option }

     

       54
       54
       +
           type config = { host : string; port : int option; debug : bool option }

     

       54
       55
        
       

     

       55
       56
        
           let config_codec =

     

       56
       56
       -
             Jsont.Object.map ~kind:"Config"

     

       57
       57
       -
               (fun host port debug -> { host; port; debug })

     

       57
       57
       +
             Jsont.Object.map ~kind:"Config" (fun host port debug ->

     

       58
       58
       +
                 { host; port; debug })

     

       58
       59
        
             |> Jsont.Object.mem "host" Jsont.string ~enc:(fun c -> c.host)

     

       59
       60
        
             |> Jsont.Object.opt_mem "port" Jsont.int ~enc:(fun c -> c.port)

     

       60
       61
        
             |> Jsont.Object.opt_mem "debug" Jsont.bool ~enc:(fun c -> c.debug)

     

       61
       62
        
             |> Jsont.Object.finish

     

       62
       63
        
       

     

       63
       64
        
           let show c =

     

       64
       64
       -
             Printf.sprintf "{host=%S; port=%s; debug=%s}"

     

       65
       65
       -
               c.host

     

       66
       66
       -
               (match c.port with None -> "None" | Some p -> Printf.sprintf "Some %d" p)

     

       67
       67
       -
               (match c.debug with None -> "None" | Some b -> Printf.sprintf "Some %b" b)

     

       65
       65
       +
             Printf.sprintf "{host=%S; port=%s; debug=%s}" c.host

     

       66
       66
       +
               (match c.port with

     

       67
       67
       +
               | None -> "None"

     

       68
       68
       +
               | Some p -> Printf.sprintf "Some %d" p)

     

       69
       69
       +
               (match c.debug with

     

       70
       70
       +
               | None -> "None"

     

       71
       71
       +
               | Some b -> Printf.sprintf "Some %b" b)

     

       68
       72
        
         end in

     

       69
       69
       -
       

     

       70
       73
        
         let yaml = read_file file in

     

       71
       74
        
         let json = read_file (file ^ ".json") in

     

       72
       75
        
         let json_result = Jsont_bytesrw.decode_string M.config_codec json in

     

       73
       73
       -
         let yaml_result = Yamlt.decode_string M.config_codec yaml in

     

       76
       76
       +
         let yaml_result = Yamlt.decode M.config_codec (Bytes.Reader.of_string yaml) in

     

       74
       77
        
       

     

       75
       78
        
         show_result_both "config"

     

       76
       79
        
           (Result.map M.show json_result)

     
···

       79
       82
        
       (* Test: Object with default values *)

     

       80
       83
        
       let test_default_values file =

     

       81
       84
        
         let module M = struct

     

       82
       82
       -
           type settings = { timeout: int; retries: int; verbose: bool }

     

       85
       85
       +
           type settings = { timeout : int; retries : int; verbose : bool }

     

       83
       86
        
       

     

       84
       87
        
           let settings_codec =

     

       85
       85
       -
             Jsont.Object.map ~kind:"Settings"

     

       86
       86
       -
               (fun timeout retries verbose -> { timeout; retries; verbose })

     

       87
       87
       -
             |> Jsont.Object.mem "timeout" Jsont.int ~enc:(fun s -> s.timeout) ~dec_absent:30

     

       88
       88
       -
             |> Jsont.Object.mem "retries" Jsont.int ~enc:(fun s -> s.retries) ~dec_absent:3

     

       89
       89
       -
             |> Jsont.Object.mem "verbose" Jsont.bool ~enc:(fun s -> s.verbose) ~dec_absent:false

     

       88
       88
       +
             Jsont.Object.map ~kind:"Settings" (fun timeout retries verbose ->

     

       89
       89
       +
                 { timeout; retries; verbose })

     

       90
       90
       +
             |> Jsont.Object.mem "timeout" Jsont.int

     

       91
       91
       +
                  ~enc:(fun s -> s.timeout)

     

       92
       92
       +
                  ~dec_absent:30

     

       93
       93
       +
             |> Jsont.Object.mem "retries" Jsont.int

     

       94
       94
       +
                  ~enc:(fun s -> s.retries)

     

       95
       95
       +
                  ~dec_absent:3

     

       96
       96
       +
             |> Jsont.Object.mem "verbose" Jsont.bool

     

       97
       97
       +
                  ~enc:(fun s -> s.verbose)

     

       98
       98
       +
                  ~dec_absent:false

     

       90
       99
        
             |> Jsont.Object.finish

     

       91
       100
        
       

     

       92
       101
        
           let show s =

     

       93
       93
       -
             Printf.sprintf "{timeout=%d; retries=%d; verbose=%b}"

     

       94
       94
       -
               s.timeout s.retries s.verbose

     

       102
       102
       +
             Printf.sprintf "{timeout=%d; retries=%d; verbose=%b}" s.timeout s.retries

     

       103
       103
       +
               s.verbose

     

       95
       104
        
         end in

     

       96
       96
       -
       

     

       97
       105
        
         let yaml = read_file file in

     

       98
       106
        
         let json = read_file (file ^ ".json") in

     

       99
       107
        
         let json_result = Jsont_bytesrw.decode_string M.settings_codec json in

     

       100
       100
       -
         let yaml_result = Yamlt.decode_string M.settings_codec yaml in

     

       108
       108
       +
         let yaml_result = Yamlt.decode M.settings_codec (Bytes.Reader.of_string yaml) in

     

       101
       109
        
       

     

       102
       110
        
         show_result_both "settings"

     

       103
       111
        
           (Result.map M.show json_result)

     
···

       106
       114
        
       (* Test: Nested objects *)

     

       107
       115
        
       let test_nested_objects file =

     

       108
       116
        
         let module M = struct

     

       109
       109
       -
           type address = { street: string; city: string; zip: string }

     

       110
       110
       -
           type employee = { name: string; address: address }

     

       117
       117
       +
           type address = { street : string; city : string; zip : string }

     

       118
       118
       +
           type employee = { name : string; address : address }

     

       111
       119
        
       

     

       112
       120
        
           let address_codec =

     

       113
       113
       -
             Jsont.Object.map ~kind:"Address"

     

       114
       114
       -
               (fun street city zip -> { street; city; zip })

     

       121
       121
       +
             Jsont.Object.map ~kind:"Address" (fun street city zip ->

     

       122
       122
       +
                 { street; city; zip })

     

       115
       123
        
             |> Jsont.Object.mem "street" Jsont.string ~enc:(fun a -> a.street)

     

       116
       124
        
             |> Jsont.Object.mem "city" Jsont.string ~enc:(fun a -> a.city)

     

       117
       125
        
             |> Jsont.Object.mem "zip" Jsont.string ~enc:(fun a -> a.zip)

     

       118
       126
        
             |> Jsont.Object.finish

     

       119
       127
        
       

     

       120
       128
        
           let employee_codec =

     

       121
       121
       -
             Jsont.Object.map ~kind:"Employee"

     

       122
       122
       -
               (fun name address -> { name; address })

     

       129
       129
       +
             Jsont.Object.map ~kind:"Employee" (fun name address -> { name; address })

     

       123
       130
        
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun e -> e.name)

     

       124
       131
        
             |> Jsont.Object.mem "address" address_codec ~enc:(fun e -> e.address)

     

       125
       132
        
             |> Jsont.Object.finish

     

       126
       133
        
       

     

       127
       134
        
           let show e =

     

       128
       128
       -
             Printf.sprintf "{name=%S; address={street=%S; city=%S; zip=%S}}"

     

       129
       129
       -
               e.name e.address.street e.address.city e.address.zip

     

       135
       135
       +
             Printf.sprintf "{name=%S; address={street=%S; city=%S; zip=%S}}" e.name

     

       136
       136
       +
               e.address.street e.address.city e.address.zip

     

       130
       137
        
         end in

     

       131
       131
       -
       

     

       132
       138
        
         let yaml = read_file file in

     

       133
       139
        
         let json = read_file (file ^ ".json") in

     

       134
       140
        
         let json_result = Jsont_bytesrw.decode_string M.employee_codec json in

     

       135
       135
       -
         let yaml_result = Yamlt.decode_string M.employee_codec yaml in

     

       141
       141
       +
         let yaml_result = Yamlt.decode M.employee_codec (Bytes.Reader.of_string yaml) in

     

       136
       142
        
       

     

       137
       143
        
         show_result_both "employee"

     

       138
       144
        
           (Result.map M.show json_result)

     
···

       141
       147
        
       (* Test: Unknown member handling - error *)

     

       142
       148
        
       let test_unknown_members_error file =

     

       143
       149
        
         let module M = struct

     

       144
       144
       -
           type strict = { name: string }

     

       150
       150
       +
           type strict = { name : string }

     

       145
       151
        
       

     

       146
       152
        
           let strict_codec =

     

       147
       153
        
             Jsont.Object.map ~kind:"Strict" (fun name -> { name })

     

       148
       154
        
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun s -> s.name)

     

       149
       155
        
             |> Jsont.Object.finish

     

       150
       156
        
         end in

     

       151
       151
       -
       

     

       152
       157
        
         let yaml = read_file file in

     

       153
       153
       -
         let result = Yamlt.decode_string M.strict_codec yaml in

     

       158
       158
       +
         let result = Yamlt.decode M.strict_codec (Bytes.Reader.of_string yaml) in

     

       154
       159
        
         match result with

     

       155
       160
        
         | Ok _ -> Printf.printf "Unexpected success\n"

     

       156
       161
        
         | Error e -> Printf.printf "Expected error: %s\n" e

     
···

       158
       163
        
       (* Test: Unknown member handling - keep *)

     

       159
       164
        
       let test_unknown_members_keep file =

     

       160
       165
        
         let module M = struct

     

       161
       161
       -
           type flexible = { name: string; extra: Jsont.json }

     

       166
       166
       +
           type flexible = { name : string; extra : Jsont.json }

     

       162
       167
        
       

     

       163
       168
        
           let flexible_codec =

     

       164
       169
        
             Jsont.Object.map ~kind:"Flexible" (fun name extra -> { name; extra })

     
···

       166
       171
        
             |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun f -> f.extra)

     

       167
       172
        
             |> Jsont.Object.finish

     

       168
       173
        
       

     

       169
       169
       -
           let show f =

     

       170
       170
       -
             Printf.sprintf "{name=%S; has_extra=true}" f.name

     

       174
       174
       +
           let show f = Printf.sprintf "{name=%S; has_extra=true}" f.name

     

       171
       175
        
         end in

     

       172
       172
       -
       

     

       173
       176
        
         let yaml = read_file file in

     

       174
       177
        
         let json = read_file (file ^ ".json") in

     

       175
       178
        
         let json_result = Jsont_bytesrw.decode_string M.flexible_codec json in

     

       176
       176
       -
         let yaml_result = Yamlt.decode_string M.flexible_codec yaml in

     

       179
       179
       +
         let yaml_result = Yamlt.decode M.flexible_codec (Bytes.Reader.of_string yaml) in

     

       177
       180
        
       

     

       178
       181
        
         show_result_both "flexible"

     

       179
       182
        
           (Result.map M.show json_result)

     
···

       182
       185
        
       (* Test: Object cases (discriminated unions) - simplified version *)

     

       183
       186
        
       let test_object_cases file =

     

       184
       187
        
         let module M = struct

     

       185
       185
       -
           type circle = { type_: string; radius: float }

     

       188
       188
       +
           type circle = { type_ : string; radius : float }

     

       186
       189
        
       

     

       187
       190
        
           let circle_codec =

     

       188
       191
        
             Jsont.Object.map ~kind:"Circle" (fun type_ radius -> { type_; radius })

     
···

       190
       193
        
             |> Jsont.Object.mem "radius" Jsont.number ~enc:(fun c -> c.radius)

     

       191
       194
        
             |> Jsont.Object.finish

     

       192
       195
        
       

     

       193
       193
       -
           let show c =

     

       194
       194
       -
             Printf.sprintf "Circle{radius=%.2f}" c.radius

     

       196
       196
       +
           let show c = Printf.sprintf "Circle{radius=%.2f}" c.radius

     

       195
       197
        
         end in

     

       196
       196
       -
       

     

       197
       198
        
         let yaml = read_file file in

     

       198
       199
        
         let json = read_file (file ^ ".json") in

     

       199
       200
        
         let json_result = Jsont_bytesrw.decode_string M.circle_codec json in

     

       200
       200
       -
         let yaml_result = Yamlt.decode_string M.circle_codec yaml in

     

       201
       201
       +
         let yaml_result = Yamlt.decode M.circle_codec (Bytes.Reader.of_string yaml) in

     

       201
       202
        
       

     

       202
       203
        
         show_result_both "shape"

     

       203
       204
        
           (Result.map M.show json_result)

     
···

       206
       207
        
       (* Test: Missing required field error *)

     

       207
       208
        
       let test_missing_required file =

     

       208
       209
        
         let module M = struct

     

       209
       209
       -
           type required = { name: string; age: int }

     

       210
       210
       +
           type required = { name : string; age : int }

     

       210
       211
        
       

     

       211
       212
        
           let required_codec =

     

       212
       213
        
             Jsont.Object.map ~kind:"Required" (fun name age -> { name; age })

     
···

       214
       215
        
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)

     

       215
       216
        
             |> Jsont.Object.finish

     

       216
       217
        
         end in

     

       217
       217
       -
       

     

       218
       218
        
         let yaml = read_file file in

     

       219
       219
       -
         let result = Yamlt.decode_string M.required_codec yaml in

     

       219
       219
       +
         let result = Yamlt.decode M.required_codec (Bytes.Reader.of_string yaml) in

     

       220
       220
        
         match result with

     

       221
       221
        
         | Ok _ -> Printf.printf "Unexpected success\n"

     

       222
       222
        
         | Error e -> Printf.printf "Expected error: %s\n" e

     
···

       224
       224
        
       (* Test: Encoding objects to different formats *)

     

       225
       225
        
       let test_encode_object () =

     

       226
       226
        
         let module M = struct

     

       227
       227
       -
           type person = { name: string; age: int; active: bool }

     

       227
       227
       +
           type person = { name : string; age : int; active : bool }

     

       228
       228
        
       

     

       229
       229
        
           let person_codec =

     

       230
       230
       -
             Jsont.Object.map ~kind:"Person" (fun name age active -> { name; age; active })

     

       230
       230
       +
             Jsont.Object.map ~kind:"Person" (fun name age active ->

     

       231
       231
       +
                 { name; age; active })

     

       231
       232
        
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)

     

       232
       233
        
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun p -> p.age)

     

       233
       234
        
             |> Jsont.Object.mem "active" Jsont.bool ~enc:(fun p -> p.active)

     

       234
       235
        
             |> Jsont.Object.finish

     

       235
       236
        
         end in

     

       236
       236
       -
       

     

       237
       237
        
         let person = M.{ name = "Alice"; age = 30; active = true } in

     

       238
       238
        
       

     

       239
       239
        
         (* Encode to JSON *)

     

       240
       240
        
         (match Jsont_bytesrw.encode_string M.person_codec person with

     

       241
       241
       -
          | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       242
       242
       -
          | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       241
       241
       +
         | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       242
       242
       +
         | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       243
       243
        
       

     

       244
       244
        
         (* Encode to YAML Block *)

     

       245
       245
       -
         (match Yamlt.encode_string ~format:Yamlt.Block M.person_codec person with

     

       246
       246
       -
          | Ok s -> Printf.printf "YAML Block:\n%s" s

     

       245
       245
       +
         (let b = Buffer.create 256 in

     

       246
       246
       +
          let writer = Bytes.Writer.of_buffer b in

     

       247
       247
       +
          match Yamlt.encode ~format:Yamlt.Block M.person_codec person ~eod:true writer with

     

       248
       248
       +
          | Ok () -> Printf.printf "YAML Block:\n%s" (Buffer.contents b)

     

       247
       249
        
          | Error e -> Printf.printf "YAML Block ERROR: %s\n" e);

     

       248
       250
        
       

     

       249
       251
        
         (* Encode to YAML Flow *)

     

       250
       250
       -
         (match Yamlt.encode_string ~format:Yamlt.Flow M.person_codec person with

     

       251
       251
       -
          | Ok s -> Printf.printf "YAML Flow: %s" s

     

       252
       252
       -
          | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       252
       252
       +
         let b = Buffer.create 256 in

     

       253
       253
       +
         let writer = Bytes.Writer.of_buffer b in

     

       254
       254
       +
         match Yamlt.encode ~format:Yamlt.Flow M.person_codec person ~eod:true writer with

     

       255
       255
       +
         | Ok () -> Printf.printf "YAML Flow: %s" (Buffer.contents b)

     

       256
       256
       +
         | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e

     

       253
       257
        
       

     

       254
       258
        
       let () =

     

       255
       259
        
         let usage = "Usage: test_objects <command> [args...]" in

     
···

       262
       266
        
         match Sys.argv.(1) with

     

       263
       267
        
         | "simple" when Stdlib.Array.length Sys.argv = 3 ->

     

       264
       268
        
             test_simple_object Sys.argv.(2)

     

       265
       265
       -
       

     

       266
       269
        
         | "optional" when Stdlib.Array.length Sys.argv = 3 ->

     

       267
       270
        
             test_optional_fields Sys.argv.(2)

     

       268
       268
       -
       

     

       269
       271
        
         | "defaults" when Stdlib.Array.length Sys.argv = 3 ->

     

       270
       272
        
             test_default_values Sys.argv.(2)

     

       271
       271
       -
       

     

       272
       273
        
         | "nested" when Stdlib.Array.length Sys.argv = 3 ->

     

       273
       274
        
             test_nested_objects Sys.argv.(2)

     

       274
       274
       -
       

     

       275
       275
        
         | "unknown-error" when Stdlib.Array.length Sys.argv = 3 ->

     

       276
       276
        
             test_unknown_members_error Sys.argv.(2)

     

       277
       277
       -
       

     

       278
       277
        
         | "unknown-keep" when Stdlib.Array.length Sys.argv = 3 ->

     

       279
       278
        
             test_unknown_members_keep Sys.argv.(2)

     

       280
       280
       -
       

     

       281
       279
        
         | "cases" when Stdlib.Array.length Sys.argv = 3 ->

     

       282
       280
        
             test_object_cases Sys.argv.(2)

     

       283
       283
       -
       

     

       284
       281
        
         | "missing-required" when Stdlib.Array.length Sys.argv = 3 ->

     

       285
       282
        
             test_missing_required Sys.argv.(2)

     

       286
       286
       -
       

     

       287
       287
       -
         | "encode" when Stdlib.Array.length Sys.argv = 2 ->

     

       288
       288
       -
             test_encode_object ()

     

       289
       289
       -
       

     

       283
       283
       +
         | "encode" when Stdlib.Array.length Sys.argv = 2 -> test_encode_object ()

     

       290
       284
        
         | _ ->

     

       291
       285
        
             prerr_endline usage;

     

       292
       286
        
             prerr_endline "Commands:";

     
···

       297
       291
        
             prerr_endline "  unknown-error <file>    - Test unknown member error";

     

       298
       292
        
             prerr_endline "  unknown-keep <file>     - Test keeping unknown members";

     

       299
       293
        
             prerr_endline "  cases <file>            - Test object cases (unions)";

     

       300
       300
       -
             prerr_endline "  missing-required <file> - Test missing required field error";

     

       294
       294
       +
             prerr_endline

     

       295
       295
       +
               "  missing-required <file> - Test missing required field error";

     

       301
       296
        
             prerr_endline "  encode                  - Test encoding objects";

     

       302
       297
        
             exit 1

+9 -6

tests/bin/test_opt_array.ml

···

       1
       1
       +
       open Bytesrw

     

       2
       2
       +
       

     

       1
       3
        
       let () =

     

       2
       4
        
         let codec =

     

       3
       5
        
           Jsont.Object.map ~kind:"Test" (fun arr -> arr)

     

       4
       4
       -
           |> Jsont.Object.opt_mem "values" (Jsont.array Jsont.string) ~enc:(fun arr -> arr)

     

       6
       6
       +
           |> Jsont.Object.opt_mem "values" (Jsont.array Jsont.string) ~enc:(fun arr ->

     

       7
       7
       +
               arr)

     

       5
       8
        
           |> Jsont.Object.finish

     

       6
       9
        
         in

     

       7
       10
        
       

     

       8
       11
        
         let yaml = "values: [a, b, c]" in

     

       9
       12
        
       

     

       10
       13
        
         Printf.printf "Testing optional array field:\n";

     

       11
       11
       -
         match Yamlt.decode_string codec yaml with

     

       12
       12
       -
         | Ok arr ->

     

       13
       13
       -
             (match arr with

     

       14
       14
       -
              | None -> Printf.printf "Result: None\n"

     

       15
       15
       -
              | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       14
       14
       +
         match Yamlt.decode codec (Bytes.Reader.of_string yaml) with

     

       15
       15
       +
         | Ok arr -> (

     

       16
       16
       +
             match arr with

     

       17
       17
       +
             | None -> Printf.printf "Result: None\n"

     

       18
       18
       +
             | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       16
       19
        
         | Error e -> Printf.printf "Error: %s\n" e

+158 -88

tests/bin/test_roundtrip.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** Test roundtrip encoding/decoding with Yamlt *)

     

       7
       7
       +
       

     

       8
       8
       +
       open Bytesrw

     

       7
       9
        
       

     

       8
       10
        
       (* Test: Roundtrip scalars *)

     

       9
       11
        
       let test_scalar_roundtrip () =

     

       10
       12
        
         let module M = struct

     

       11
       11
       -
           type data = { s: string; n: float; b: bool; nul: unit }

     

       13
       13
       +
           type data = { s : string; n : float; b : bool; nul : unit }

     

       12
       14
        
       

     

       13
       15
        
           let data_codec =

     

       14
       16
        
             Jsont.Object.map ~kind:"Data" (fun s n b nul -> { s; n; b; nul })

     
···

       21
       23
        
           let equal d1 d2 =

     

       22
       24
        
             d1.s = d2.s && d1.n = d2.n && d1.b = d2.b && d1.nul = d2.nul

     

       23
       25
        
         end in

     

       24
       24
       -
       

     

       25
       26
        
         let original = { M.s = "hello"; n = 42.5; b = true; nul = () } in

     

       26
       27
        
       

     

       27
       28
        
         (* JSON roundtrip *)

     

       28
       29
        
         let json_encoded = Jsont_bytesrw.encode_string M.data_codec original in

     

       29
       29
       -
         let json_decoded = Result.bind json_encoded (Jsont_bytesrw.decode_string M.data_codec) in

     

       30
       30
       +
         let json_decoded =

     

       31
       31
       +
           Result.bind json_encoded (Jsont_bytesrw.decode_string M.data_codec)

     

       32
       32
       +
         in

     

       30
       33
        
         (match json_decoded with

     

       31
       31
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "JSON roundtrip: PASS\n"

     

       32
       32
       -
          | Ok _ -> Printf.printf "JSON roundtrip: FAIL (data mismatch)\n"

     

       33
       33
       -
          | Error e -> Printf.printf "JSON roundtrip: FAIL (%s)\n" e);

     

       34
       34
       +
         | Ok decoded when M.equal original decoded ->

     

       35
       35
       +
             Printf.printf "JSON roundtrip: PASS\n"

     

       36
       36
       +
         | Ok _ -> Printf.printf "JSON roundtrip: FAIL (data mismatch)\n"

     

       37
       37
       +
         | Error e -> Printf.printf "JSON roundtrip: FAIL (%s)\n" e);

     

       34
       38
        
       

     

       35
       39
        
         (* YAML Block roundtrip *)

     

       36
       36
       -
         let yaml_block_encoded = Yamlt.encode_string ~format:Yamlt.Block M.data_codec original in

     

       37
       37
       -
         let yaml_block_decoded = Result.bind yaml_block_encoded (Yamlt.decode_string M.data_codec) in

     

       40
       40
       +
         let yaml_block_encoded =

     

       41
       41
       +
           let b = Buffer.create 256 in

     

       42
       42
       +
           let writer = Bytes.Writer.of_buffer b in

     

       43
       43
       +
           match Yamlt.encode ~format:Yamlt.Block M.data_codec original ~eod:true writer with

     

       44
       44
       +
           | Ok () -> Ok (Buffer.contents b)

     

       45
       45
       +
           | Error e -> Error e

     

       46
       46
       +
         in

     

       47
       47
       +
         let yaml_block_decoded =

     

       48
       48
       +
           Result.bind yaml_block_encoded (fun yaml ->

     

       49
       49
       +
             Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml))

     

       50
       50
       +
         in

     

       38
       51
        
         (match yaml_block_decoded with

     

       39
       39
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "YAML Block roundtrip: PASS\n"

     

       40
       40
       -
          | Ok _ -> Printf.printf "YAML Block roundtrip: FAIL (data mismatch)\n"

     

       41
       41
       -
          | Error e -> Printf.printf "YAML Block roundtrip: FAIL (%s)\n" e);

     

       52
       52
       +
         | Ok decoded when M.equal original decoded ->

     

       53
       53
       +
             Printf.printf "YAML Block roundtrip: PASS\n"

     

       54
       54
       +
         | Ok _ -> Printf.printf "YAML Block roundtrip: FAIL (data mismatch)\n"

     

       55
       55
       +
         | Error e -> Printf.printf "YAML Block roundtrip: FAIL (%s)\n" e);

     

       42
       56
        
       

     

       43
       57
        
         (* YAML Flow roundtrip *)

     

       44
       44
       -
         let yaml_flow_encoded = Yamlt.encode_string ~format:Yamlt.Flow M.data_codec original in

     

       45
       45
       -
         let yaml_flow_decoded = Result.bind yaml_flow_encoded (Yamlt.decode_string M.data_codec) in

     

       46
       46
       -
         (match yaml_flow_decoded with

     

       47
       47
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "YAML Flow roundtrip: PASS\n"

     

       48
       48
       -
          | Ok _ -> Printf.printf "YAML Flow roundtrip: FAIL (data mismatch)\n"

     

       49
       49
       -
          | Error e -> Printf.printf "YAML Flow roundtrip: FAIL (%s)\n" e)

     

       58
       58
       +
         let yaml_flow_encoded =

     

       59
       59
       +
           let b = Buffer.create 256 in

     

       60
       60
       +
           let writer = Bytes.Writer.of_buffer b in

     

       61
       61
       +
           match Yamlt.encode ~format:Yamlt.Flow M.data_codec original ~eod:true writer with

     

       62
       62
       +
           | Ok () -> Ok (Buffer.contents b)

     

       63
       63
       +
           | Error e -> Error e

     

       64
       64
       +
         in

     

       65
       65
       +
         let yaml_flow_decoded =

     

       66
       66
       +
           Result.bind yaml_flow_encoded (fun yaml ->

     

       67
       67
       +
             Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml))

     

       68
       68
       +
         in

     

       69
       69
       +
         match yaml_flow_decoded with

     

       70
       70
       +
         | Ok decoded when M.equal original decoded ->

     

       71
       71
       +
             Printf.printf "YAML Flow roundtrip: PASS\n"

     

       72
       72
       +
         | Ok _ -> Printf.printf "YAML Flow roundtrip: FAIL (data mismatch)\n"

     

       73
       73
       +
         | Error e -> Printf.printf "YAML Flow roundtrip: FAIL (%s)\n" e

     

       50
       74
        
       

     

       51
       75
        
       (* Test: Roundtrip arrays *)

     

       52
       76
        
       let test_array_roundtrip () =

     

       53
       77
        
         let module M = struct

     

       54
       54
       -
           type data = { items: int array; nested: float array array }

     

       78
       78
       +
           type data = { items : int array; nested : float array array }

     

       55
       79
        
       

     

       56
       80
        
           let data_codec =

     

       57
       81
        
             Jsont.Object.map ~kind:"Data" (fun items nested -> { items; nested })

     

       58
       58
       -
             |> Jsont.Object.mem "items" (Jsont.array Jsont.int) ~enc:(fun d -> d.items)

     

       59
       59
       -
             |> Jsont.Object.mem "nested" (Jsont.array (Jsont.array Jsont.number)) ~enc:(fun d -> d.nested)

     

       82
       82
       +
             |> Jsont.Object.mem "items" (Jsont.array Jsont.int) ~enc:(fun d ->

     

       83
       83
       +
                 d.items)

     

       84
       84
       +
             |> Jsont.Object.mem "nested"

     

       85
       85
       +
                  (Jsont.array (Jsont.array Jsont.number))

     

       86
       86
       +
                  ~enc:(fun d -> d.nested)

     

       60
       87
        
             |> Jsont.Object.finish

     

       61
       88
        
       

     

       62
       62
       -
           let equal d1 d2 =

     

       63
       63
       -
             d1.items = d2.items && d1.nested = d2.nested

     

       89
       89
       +
           let equal d1 d2 = d1.items = d2.items && d1.nested = d2.nested

     

       64
       90
        
         end in

     

       65
       65
       -
       

     

       66
       66
       -
         let original = { M.items = [|1; 2; 3; 4; 5|]; nested = [|[|1.0; 2.0|]; [|3.0; 4.0|]|] } in

     

       91
       91
       +
         let original =

     

       92
       92
       +
           {

     

       93
       93
       +
             M.items = [| 1; 2; 3; 4; 5 |];

     

       94
       94
       +
             nested = [| [| 1.0; 2.0 |]; [| 3.0; 4.0 |] |];

     

       95
       95
       +
           }

     

       96
       96
       +
         in

     

       67
       97
        
       

     

       68
       98
        
         (* JSON roundtrip *)

     

       69
       69
       -
         let json_result = Result.bind

     

       70
       70
       -
           (Jsont_bytesrw.encode_string M.data_codec original)

     

       71
       71
       -
           (Jsont_bytesrw.decode_string M.data_codec) in

     

       99
       99
       +
         let json_result =

     

       100
       100
       +
           Result.bind

     

       101
       101
       +
             (Jsont_bytesrw.encode_string M.data_codec original)

     

       102
       102
       +
             (Jsont_bytesrw.decode_string M.data_codec)

     

       103
       103
       +
         in

     

       72
       104
        
         (match json_result with

     

       73
       73
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "JSON array roundtrip: PASS\n"

     

       74
       74
       -
          | Ok _ -> Printf.printf "JSON array roundtrip: FAIL (data mismatch)\n"

     

       75
       75
       -
          | Error e -> Printf.printf "JSON array roundtrip: FAIL (%s)\n" e);

     

       105
       105
       +
         | Ok decoded when M.equal original decoded ->

     

       106
       106
       +
             Printf.printf "JSON array roundtrip: PASS\n"

     

       107
       107
       +
         | Ok _ -> Printf.printf "JSON array roundtrip: FAIL (data mismatch)\n"

     

       108
       108
       +
         | Error e -> Printf.printf "JSON array roundtrip: FAIL (%s)\n" e);

     

       76
       109
        
       

     

       77
       110
        
         (* YAML roundtrip *)

     

       78
       78
       -
         let yaml_result = Result.bind

     

       79
       79
       -
           (Yamlt.encode_string M.data_codec original)

     

       80
       80
       -
           (Yamlt.decode_string M.data_codec) in

     

       81
       81
       -
         (match yaml_result with

     

       82
       82
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "YAML array roundtrip: PASS\n"

     

       83
       83
       -
          | Ok _ -> Printf.printf "YAML array roundtrip: FAIL (data mismatch)\n"

     

       84
       84
       -
          | Error e -> Printf.printf "YAML array roundtrip: FAIL (%s)\n" e)

     

       111
       111
       +
         let yaml_result =

     

       112
       112
       +
           let b = Buffer.create 256 in

     

       113
       113
       +
           let writer = Bytes.Writer.of_buffer b in

     

       114
       114
       +
           match Yamlt.encode M.data_codec original ~eod:true writer with

     

       115
       115
       +
           | Ok () ->

     

       116
       116
       +
               let yaml = Buffer.contents b in

     

       117
       117
       +
               Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml)

     

       118
       118
       +
           | Error e -> Error e

     

       119
       119
       +
         in

     

       120
       120
       +
         match yaml_result with

     

       121
       121
       +
         | Ok decoded when M.equal original decoded ->

     

       122
       122
       +
             Printf.printf "YAML array roundtrip: PASS\n"

     

       123
       123
       +
         | Ok _ -> Printf.printf "YAML array roundtrip: FAIL (data mismatch)\n"

     

       124
       124
       +
         | Error e -> Printf.printf "YAML array roundtrip: FAIL (%s)\n" e

     

       85
       125
        
       

     

       86
       126
        
       (* Test: Roundtrip objects *)

     

       87
       127
        
       let test_object_roundtrip () =

     

       88
       128
        
         let module M = struct

     

       89
       89
       -
           type person = { p_name: string; age: int; active: bool }

     

       90
       90
       -
           type company = { c_name: string; employees: person array }

     

       129
       129
       +
           type person = { p_name : string; age : int; active : bool }

     

       130
       130
       +
           type company = { c_name : string; employees : person array }

     

       91
       131
        
       

     

       92
       132
        
           let person_codec =

     

       93
       93
       -
             Jsont.Object.map ~kind:"Person" (fun p_name age active -> { p_name; age; active })

     

       133
       133
       +
             Jsont.Object.map ~kind:"Person" (fun p_name age active ->

     

       134
       134
       +
                 { p_name; age; active })

     

       94
       135
        
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.p_name)

     

       95
       136
        
             |> Jsont.Object.mem "age" Jsont.int ~enc:(fun p -> p.age)

     

       96
       137
        
             |> Jsont.Object.mem "active" Jsont.bool ~enc:(fun p -> p.active)

     

       97
       138
        
             |> Jsont.Object.finish

     

       98
       139
        
       

     

       99
       140
        
           let company_codec =

     

       100
       100
       -
             Jsont.Object.map ~kind:"Company" (fun c_name employees -> { c_name; employees })

     

       141
       141
       +
             Jsont.Object.map ~kind:"Company" (fun c_name employees ->

     

       142
       142
       +
                 { c_name; employees })

     

       101
       143
        
             |> Jsont.Object.mem "name" Jsont.string ~enc:(fun c -> c.c_name)

     

       102
       102
       -
             |> Jsont.Object.mem "employees" (Jsont.array person_codec) ~enc:(fun c -> c.employees)

     

       144
       144
       +
             |> Jsont.Object.mem "employees" (Jsont.array person_codec) ~enc:(fun c ->

     

       145
       145
       +
                 c.employees)

     

       103
       146
        
             |> Jsont.Object.finish

     

       104
       147
        
       

     

       105
       148
        
           let person_equal p1 p2 =

     

       106
       149
        
             p1.p_name = p2.p_name && p1.age = p2.age && p1.active = p2.active

     

       107
       150
        
       

     

       108
       151
        
           let equal c1 c2 =

     

       109
       109
       -
             c1.c_name = c2.c_name &&

     

       110
       110
       -
             Stdlib.Array.length c1.employees = Stdlib.Array.length c2.employees &&

     

       111
       111
       -
             Stdlib.Array.for_all2 person_equal c1.employees c2.employees

     

       152
       152
       +
             c1.c_name = c2.c_name

     

       153
       153
       +
             && Stdlib.Array.length c1.employees = Stdlib.Array.length c2.employees

     

       154
       154
       +
             && Stdlib.Array.for_all2 person_equal c1.employees c2.employees

     

       112
       155
        
         end in

     

       113
       113
       -
       

     

       114
       114
       -
         let original = {

     

       115
       115
       -
           M.c_name = "Acme Corp";

     

       116
       116
       -
           employees = [|

     

       117
       117
       -
             { p_name = "Alice"; age = 30; active = true };

     

       118
       118
       -
             { p_name = "Bob"; age = 25; active = false };

     

       119
       119
       -
           |]

     

       120
       120
       -
         } in

     

       156
       156
       +
         let original =

     

       157
       157
       +
           {

     

       158
       158
       +
             M.c_name = "Acme Corp";

     

       159
       159
       +
             employees =

     

       160
       160
       +
               [|

     

       161
       161
       +
                 { p_name = "Alice"; age = 30; active = true };

     

       162
       162
       +
                 { p_name = "Bob"; age = 25; active = false };

     

       163
       163
       +
               |];

     

       164
       164
       +
           }

     

       165
       165
       +
         in

     

       121
       166
        
       

     

       122
       167
        
         (* JSON roundtrip *)

     

       123
       123
       -
         let json_result = Result.bind

     

       124
       124
       -
           (Jsont_bytesrw.encode_string M.company_codec original)

     

       125
       125
       -
           (Jsont_bytesrw.decode_string M.company_codec) in

     

       168
       168
       +
         let json_result =

     

       169
       169
       +
           Result.bind

     

       170
       170
       +
             (Jsont_bytesrw.encode_string M.company_codec original)

     

       171
       171
       +
             (Jsont_bytesrw.decode_string M.company_codec)

     

       172
       172
       +
         in

     

       126
       173
        
         (match json_result with

     

       127
       127
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "JSON object roundtrip: PASS\n"

     

       128
       128
       -
          | Ok _ -> Printf.printf "JSON object roundtrip: FAIL (data mismatch)\n"

     

       129
       129
       -
          | Error e -> Printf.printf "JSON object roundtrip: FAIL (%s)\n" e);

     

       174
       174
       +
         | Ok decoded when M.equal original decoded ->

     

       175
       175
       +
             Printf.printf "JSON object roundtrip: PASS\n"

     

       176
       176
       +
         | Ok _ -> Printf.printf "JSON object roundtrip: FAIL (data mismatch)\n"

     

       177
       177
       +
         | Error e -> Printf.printf "JSON object roundtrip: FAIL (%s)\n" e);

     

       130
       178
        
       

     

       131
       179
        
         (* YAML roundtrip *)

     

       132
       132
       -
         let yaml_result = Result.bind

     

       133
       133
       -
           (Yamlt.encode_string M.company_codec original)

     

       134
       134
       -
           (Yamlt.decode_string M.company_codec) in

     

       135
       135
       -
         (match yaml_result with

     

       136
       136
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "YAML object roundtrip: PASS\n"

     

       137
       137
       -
          | Ok _ -> Printf.printf "YAML object roundtrip: FAIL (data mismatch)\n"

     

       138
       138
       -
          | Error e -> Printf.printf "YAML object roundtrip: FAIL (%s)\n" e)

     

       180
       180
       +
         let yaml_result =

     

       181
       181
       +
           let b = Buffer.create 256 in

     

       182
       182
       +
           let writer = Bytes.Writer.of_buffer b in

     

       183
       183
       +
           match Yamlt.encode M.company_codec original ~eod:true writer with

     

       184
       184
       +
           | Ok () ->

     

       185
       185
       +
               let yaml = Buffer.contents b in

     

       186
       186
       +
               Yamlt.decode M.company_codec (Bytes.Reader.of_string yaml)

     

       187
       187
       +
           | Error e -> Error e

     

       188
       188
       +
         in

     

       189
       189
       +
         match yaml_result with

     

       190
       190
       +
         | Ok decoded when M.equal original decoded ->

     

       191
       191
       +
             Printf.printf "YAML object roundtrip: PASS\n"

     

       192
       192
       +
         | Ok _ -> Printf.printf "YAML object roundtrip: FAIL (data mismatch)\n"

     

       193
       193
       +
         | Error e -> Printf.printf "YAML object roundtrip: FAIL (%s)\n" e

     

       139
       194
        
       

     

       140
       195
        
       (* Test: Roundtrip with optionals *)

     

       141
       196
        
       let test_optional_roundtrip () =

     

       142
       197
        
         let module M = struct

     

       143
       143
       -
           type data = { required: string; optional: int option; nullable: string option }

     

       198
       198
       +
           type data = {

     

       199
       199
       +
             required : string;

     

       200
       200
       +
             optional : int option;

     

       201
       201
       +
             nullable : string option;

     

       202
       202
       +
           }

     

       144
       203
        
       

     

       145
       204
        
           let data_codec =

     

       146
       146
       -
             Jsont.Object.map ~kind:"Data" (fun required optional nullable -> { required; optional; nullable })

     

       205
       205
       +
             Jsont.Object.map ~kind:"Data" (fun required optional nullable ->

     

       206
       206
       +
                 { required; optional; nullable })

     

       147
       207
        
             |> Jsont.Object.mem "required" Jsont.string ~enc:(fun d -> d.required)

     

       148
       208
        
             |> Jsont.Object.opt_mem "optional" Jsont.int ~enc:(fun d -> d.optional)

     

       149
       149
       -
             |> Jsont.Object.mem "nullable" (Jsont.some Jsont.string) ~enc:(fun d -> d.nullable)

     

       209
       209
       +
             |> Jsont.Object.mem "nullable" (Jsont.some Jsont.string) ~enc:(fun d ->

     

       210
       210
       +
                 d.nullable)

     

       150
       211
        
             |> Jsont.Object.finish

     

       151
       212
        
       

     

       152
       213
        
           let equal d1 d2 =

     

       153
       153
       -
             d1.required = d2.required && d1.optional = d2.optional && d1.nullable = d2.nullable

     

       214
       214
       +
             d1.required = d2.required && d1.optional = d2.optional

     

       215
       215
       +
             && d1.nullable = d2.nullable

     

       154
       216
        
         end in

     

       155
       155
       -
       

     

       156
       217
        
         let original = { M.required = "test"; optional = Some 42; nullable = None } in

     

       157
       218
        
       

     

       158
       219
        
         (* JSON roundtrip *)

     

       159
       159
       -
         let json_result = Result.bind

     

       160
       160
       -
           (Jsont_bytesrw.encode_string M.data_codec original)

     

       161
       161
       -
           (Jsont_bytesrw.decode_string M.data_codec) in

     

       220
       220
       +
         let json_result =

     

       221
       221
       +
           Result.bind

     

       222
       222
       +
             (Jsont_bytesrw.encode_string M.data_codec original)

     

       223
       223
       +
             (Jsont_bytesrw.decode_string M.data_codec)

     

       224
       224
       +
         in

     

       162
       225
        
         (match json_result with

     

       163
       163
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "JSON optional roundtrip: PASS\n"

     

       164
       164
       -
          | Ok _ -> Printf.printf "JSON optional roundtrip: FAIL (data mismatch)\n"

     

       165
       165
       -
          | Error e -> Printf.printf "JSON optional roundtrip: FAIL (%s)\n" e);

     

       226
       226
       +
         | Ok decoded when M.equal original decoded ->

     

       227
       227
       +
             Printf.printf "JSON optional roundtrip: PASS\n"

     

       228
       228
       +
         | Ok _ -> Printf.printf "JSON optional roundtrip: FAIL (data mismatch)\n"

     

       229
       229
       +
         | Error e -> Printf.printf "JSON optional roundtrip: FAIL (%s)\n" e);

     

       166
       230
        
       

     

       167
       231
        
         (* YAML roundtrip *)

     

       168
       168
       -
         let yaml_result = Result.bind

     

       169
       169
       -
           (Yamlt.encode_string M.data_codec original)

     

       170
       170
       -
           (Yamlt.decode_string M.data_codec) in

     

       171
       171
       -
         (match yaml_result with

     

       172
       172
       -
          | Ok decoded when M.equal original decoded -> Printf.printf "YAML optional roundtrip: PASS\n"

     

       173
       173
       -
          | Ok _ -> Printf.printf "YAML optional roundtrip: FAIL (data mismatch)\n"

     

       174
       174
       -
          | Error e -> Printf.printf "YAML optional roundtrip: FAIL (%s)\n" e)

     

       232
       232
       +
         let yaml_result =

     

       233
       233
       +
           let b = Buffer.create 256 in

     

       234
       234
       +
           let writer = Bytes.Writer.of_buffer b in

     

       235
       235
       +
           match Yamlt.encode M.data_codec original ~eod:true writer with

     

       236
       236
       +
           | Ok () ->

     

       237
       237
       +
               let yaml = Buffer.contents b in

     

       238
       238
       +
               Yamlt.decode M.data_codec (Bytes.Reader.of_string yaml)

     

       239
       239
       +
           | Error e -> Error e

     

       240
       240
       +
         in

     

       241
       241
       +
         match yaml_result with

     

       242
       242
       +
         | Ok decoded when M.equal original decoded ->

     

       243
       243
       +
             Printf.printf "YAML optional roundtrip: PASS\n"

     

       244
       244
       +
         | Ok _ -> Printf.printf "YAML optional roundtrip: FAIL (data mismatch)\n"

     

       245
       245
       +
         | Error e -> Printf.printf "YAML optional roundtrip: FAIL (%s)\n" e

     

       175
       246
        
       

     

       176
       247
        
       let () =

     

       177
       248
        
         let usage = "Usage: test_roundtrip <command>" in

     
···

       186
       257
        
         | "array" -> test_array_roundtrip ()

     

       187
       258
        
         | "object" -> test_object_roundtrip ()

     

       188
       259
        
         | "optional" -> test_optional_roundtrip ()

     

       189
       189
       -
       

     

       190
       260
        
         | _ ->

     

       191
       261
        
             prerr_endline usage;

     

       192
       262
        
             prerr_endline "Commands:";

+105 -100

tests/bin/test_scalars.ml

···

       1
       1
        
       (*---------------------------------------------------------------------------

     

       2
       2
       -
          Copyright (c) 2024 The yamlrw programmers. All rights reserved.

     

       3
       3
       -
          SPDX-License-Identifier: ISC

     

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

     

       2
       2
       +
         Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.

     

       3
       3
       +
         SPDX-License-Identifier: ISC

     

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

     

       5
       5
        
       

     

       6
       6
        
       (** Test scalar type resolution with Yamlt codec *)

     

       7
       7
        
       

     

       8
       8
       +
       open Bytesrw

     

       9
       9
       +
       

     

       8
       10
        
       (* Helper to read file *)

     

       9
       11
        
       let read_file path =

     

       10
       12
        
         let ic = open_in path in

     
···

       36
       38
        
         in

     

       37
       39
        
       

     

       38
       40
        
         (* Try decoding as null *)

     

       39
       39
       -
         let result = Yamlt.decode_string null_codec yaml in

     

       41
       41
       +
         let result = Yamlt.decode null_codec (Bytes.Reader.of_string yaml) in

     

       40
       42
        
         show_result "null_codec" (Result.map (fun () -> "null") result)

     

       41
       43
        
       

     

       42
       44
        
       (* Test: Boolean type-directed resolution *)

     
···

       60
       62
        
       

     

       61
       63
        
         Printf.printf "=== Bool Codec ===\n";

     

       62
       64
        
         let json_result = Jsont_bytesrw.decode_string bool_codec json in

     

       63
       63
       -
         let yaml_result = Yamlt.decode_string bool_codec yaml in

     

       65
       65
       +
         let yaml_result = Yamlt.decode bool_codec (Bytes.Reader.of_string yaml) in

     

       64
       66
        
         show_result_json "bool_codec"

     

       65
       67
        
           (Result.map (Printf.sprintf "%b") json_result)

     

       66
       68
        
           (Result.map (Printf.sprintf "%b") yaml_result);

     

       67
       69
        
       

     

       68
       70
        
         Printf.printf "\n=== String Codec ===\n";

     

       69
       71
        
         let json_result = Jsont_bytesrw.decode_string string_codec json in

     

       70
       70
       -
         let yaml_result = Yamlt.decode_string string_codec yaml in

     

       72
       72
       +
         let yaml_result = Yamlt.decode string_codec (Bytes.Reader.of_string yaml) in

     

       71
       73
        
         show_result_json "string_codec"

     

       72
       74
        
           (Result.map (Printf.sprintf "%S") json_result)

     

       73
       75
        
           (Result.map (Printf.sprintf "%S") yaml_result)

     
···

       84
       86
        
         in

     

       85
       87
        
       

     

       86
       88
        
         let json_result = Jsont_bytesrw.decode_string number_codec json in

     

       87
       87
       -
         let yaml_result = Yamlt.decode_string number_codec yaml in

     

       89
       89
       +
         let yaml_result = Yamlt.decode number_codec (Bytes.Reader.of_string yaml) in

     

       88
       90
        
       

     

       89
       91
        
         show_result_json "number_codec"

     

       90
       92
        
           (Result.map (Printf.sprintf "%.17g") json_result)

     
···

       102
       104
        
         in

     

       103
       105
        
       

     

       104
       106
        
         let json_result = Jsont_bytesrw.decode_string string_codec json in

     

       105
       105
       -
         let yaml_result = Yamlt.decode_string string_codec yaml in

     

       107
       107
       +
         let yaml_result = Yamlt.decode string_codec (Bytes.Reader.of_string yaml) in

     

       106
       108
        
       

     

       107
       109
        
         show_result_json "string_codec"

     

       108
       110
        
           (Result.map (Printf.sprintf "%S") json_result)

     
···

       118
       120
        
           |> Jsont.Object.finish

     

       119
       121
        
         in

     

       120
       122
        
       

     

       121
       121
       -
         let result = Yamlt.decode_string number_codec yaml in

     

       123
       123
       +
         let result = Yamlt.decode number_codec (Bytes.Reader.of_string yaml) in

     

       122
       124
        
         match result with

     

       123
       125
        
         | Ok f ->

     

       124
       124
       -
             if Float.is_nan f then

     

       125
       125
       -
               Printf.printf "value: NaN\n"

     

       126
       126
       -
             else if f = Float.infinity then

     

       127
       127
       -
               Printf.printf "value: +Infinity\n"

     

       128
       128
       -
             else if f = Float.neg_infinity then

     

       129
       129
       -
               Printf.printf "value: -Infinity\n"

     

       130
       130
       -
             else

     

       131
       131
       -
               Printf.printf "value: %.17g\n" f

     

       132
       132
       -
         | Error e ->

     

       133
       133
       -
             Printf.printf "ERROR: %s\n" e

     

       126
       126
       +
             if Float.is_nan f then Printf.printf "value: NaN\n"

     

       127
       127
       +
             else if f = Float.infinity then Printf.printf "value: +Infinity\n"

     

       128
       128
       +
             else if f = Float.neg_infinity then Printf.printf "value: -Infinity\n"

     

       129
       129
       +
             else Printf.printf "value: %.17g\n" f

     

       130
       130
       +
         | Error e -> Printf.printf "ERROR: %s\n" e

     

       134
       131
        
       

     

       135
       132
        
       (* Test: Type mismatch errors *)

     

       136
       133
        
       let test_type_mismatch file expected_type =

     

       137
       134
        
         let yaml = read_file file in

     

       138
       135
        
       

     

       139
       136
        
         match expected_type with

     

       140
       140
       -
           | "bool" ->

     

       141
       141
       -
               let codec =

     

       142
       142
       -
                 Jsont.Object.map ~kind:"BoolTest" (fun b -> b)

     

       143
       143
       -
                 |> Jsont.Object.mem "value" Jsont.bool ~enc:(fun b -> b)

     

       144
       144
       -
                 |> Jsont.Object.finish

     

       145
       145
       -
               in

     

       146
       146
       -
               let result = Yamlt.decode_string codec yaml in

     

       147
       147
       -
               (match result with

     

       148
       148
       -
                | Ok _ -> Printf.printf "Unexpected success\n"

     

       149
       149
       -
                | Error e -> Printf.printf "Expected error: %s\n" e)

     

       150
       150
       -
           | "number" ->

     

       151
       151
       -
               let codec =

     

       152
       152
       -
                 Jsont.Object.map ~kind:"NumberTest" (fun n -> n)

     

       153
       153
       -
                 |> Jsont.Object.mem "value" Jsont.number ~enc:(fun n -> n)

     

       154
       154
       -
                 |> Jsont.Object.finish

     

       155
       155
       -
               in

     

       156
       156
       -
               let result = Yamlt.decode_string codec yaml in

     

       157
       157
       -
               (match result with

     

       158
       158
       -
                | Ok _ -> Printf.printf "Unexpected success\n"

     

       159
       159
       -
                | Error e -> Printf.printf "Expected error: %s\n" e)

     

       160
       160
       -
           | "null" ->

     

       161
       161
       -
               let codec =

     

       162
       162
       -
                 Jsont.Object.map ~kind:"NullTest" (fun n -> n)

     

       163
       163
       -
                 |> Jsont.Object.mem "value" (Jsont.null ()) ~enc:(fun n -> n)

     

       164
       164
       -
                 |> Jsont.Object.finish

     

       165
       165
       -
               in

     

       166
       166
       -
               let result = Yamlt.decode_string codec yaml in

     

       167
       167
       -
               (match result with

     

       168
       168
       -
                | Ok _ -> Printf.printf "Unexpected success\n"

     

       169
       169
       -
                | Error e -> Printf.printf "Expected error: %s\n" e)

     

       170
       170
       -
           | _ -> failwith "unknown type"

     

       137
       137
       +
         | "bool" -> (

     

       138
       138
       +
             let codec =

     

       139
       139
       +
               Jsont.Object.map ~kind:"BoolTest" (fun b -> b)

     

       140
       140
       +
               |> Jsont.Object.mem "value" Jsont.bool ~enc:(fun b -> b)

     

       141
       141
       +
               |> Jsont.Object.finish

     

       142
       142
       +
             in

     

       143
       143
       +
             let result = Yamlt.decode codec (Bytes.Reader.of_string yaml) in

     

       144
       144
       +
             match result with

     

       145
       145
       +
             | Ok _ -> Printf.printf "Unexpected success\n"

     

       146
       146
       +
             | Error e -> Printf.printf "Expected error: %s\n" e)

     

       147
       147
       +
         | "number" -> (

     

       148
       148
       +
             let codec =

     

       149
       149
       +
               Jsont.Object.map ~kind:"NumberTest" (fun n -> n)

     

       150
       150
       +
               |> Jsont.Object.mem "value" Jsont.number ~enc:(fun n -> n)

     

       151
       151
       +
               |> Jsont.Object.finish

     

       152
       152
       +
             in

     

       153
       153
       +
             let result = Yamlt.decode codec (Bytes.Reader.of_string yaml) in

     

       154
       154
       +
             match result with

     

       155
       155
       +
             | Ok _ -> Printf.printf "Unexpected success\n"

     

       156
       156
       +
             | Error e -> Printf.printf "Expected error: %s\n" e)

     

       157
       157
       +
         | "null" -> (

     

       158
       158
       +
             let codec =

     

       159
       159
       +
               Jsont.Object.map ~kind:"NullTest" (fun n -> n)

     

       160
       160
       +
               |> Jsont.Object.mem "value" (Jsont.null ()) ~enc:(fun n -> n)

     

       161
       161
       +
               |> Jsont.Object.finish

     

       162
       162
       +
             in

     

       163
       163
       +
             let result = Yamlt.decode codec (Bytes.Reader.of_string yaml) in

     

       164
       164
       +
             match result with

     

       165
       165
       +
             | Ok _ -> Printf.printf "Unexpected success\n"

     

       166
       166
       +
             | Error e -> Printf.printf "Expected error: %s\n" e)

     

       167
       167
       +
         | _ -> failwith "unknown type"

     

       171
       168
        
       

     

       172
       169
        
       (* Test: Decode with Jsont.json to see auto-resolution *)

     

       173
       170
        
       let test_any_resolution file =

     
···

       181
       178
        
         in

     

       182
       179
        
       

     

       183
       180
        
         let json_result = Jsont_bytesrw.decode_string any_codec json in

     

       184
       184
       -
         let yaml_result = Yamlt.decode_string any_codec yaml in

     

       181
       181
       +
         let yaml_result = Yamlt.decode any_codec (Bytes.Reader.of_string yaml) in

     

       185
       182
        
       

     

       186
       183
        
         (* Just show that it decoded successfully *)

     

       187
       184
        
         show_result_json "any_codec"

     
···

       191
       188
        
       (* Test: Encoding to different formats *)

     

       192
       189
        
       let test_encode_formats value_type value =

     

       193
       190
        
         match value_type with

     

       194
       194
       -
         | "bool" ->

     

       191
       191
       +
         | "bool" -> (

     

       195
       192
        
             let codec =

     

       196
       193
        
               Jsont.Object.map ~kind:"BoolTest" (fun b -> b)

     

       197
       194
        
               |> Jsont.Object.mem "value" Jsont.bool ~enc:(fun b -> b)

     
···

       199
       196
        
             in

     

       200
       197
        
             let v = bool_of_string value in

     

       201
       198
        
             (match Jsont_bytesrw.encode_string codec v with

     

       202
       202
       -
              | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       203
       203
       -
              | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       204
       204
       -
             (match Yamlt.encode_string ~format:Yamlt.Block codec v with

     

       205
       205
       -
              | Ok s -> Printf.printf "YAML Block:\n%s" s

     

       199
       199
       +
             | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       200
       200
       +
             | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       201
       201
       +
             (let b = Buffer.create 256 in

     

       202
       202
       +
              let writer = Bytes.Writer.of_buffer b in

     

       203
       203
       +
              match Yamlt.encode ~format:Yamlt.Block codec v ~eod:true writer with

     

       204
       204
       +
              | Ok () -> Printf.printf "YAML Block:\n%s" (Buffer.contents b)

     

       206
       205
        
              | Error e -> Printf.printf "YAML Block ERROR: %s\n" e);

     

       207
       207
       -
             (match Yamlt.encode_string ~format:Yamlt.Flow codec v with

     

       208
       208
       -
              | Ok s -> Printf.printf "YAML Flow: %s" s

     

       209
       209
       -
              | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       210
       210
       -
         | "number" ->

     

       206
       206
       +
             let b = Buffer.create 256 in

     

       207
       207
       +
             let writer = Bytes.Writer.of_buffer b in

     

       208
       208
       +
             match Yamlt.encode ~format:Yamlt.Flow codec v ~eod:true writer with

     

       209
       209
       +
             | Ok () -> Printf.printf "YAML Flow: %s" (Buffer.contents b)

     

       210
       210
       +
             | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       211
       211
       +
         | "number" -> (

     

       211
       212
        
             let codec =

     

       212
       213
        
               Jsont.Object.map ~kind:"NumberTest" (fun n -> n)

     

       213
       214
        
               |> Jsont.Object.mem "value" Jsont.number ~enc:(fun n -> n)

     
···

       215
       216
        
             in

     

       216
       217
        
             let v = float_of_string value in

     

       217
       218
        
             (match Jsont_bytesrw.encode_string codec v with

     

       218
       218
       -
              | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       219
       219
       -
              | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       220
       220
       -
             (match Yamlt.encode_string ~format:Yamlt.Block codec v with

     

       221
       221
       -
              | Ok s -> Printf.printf "YAML Block:\n%s" s

     

       219
       219
       +
             | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       220
       220
       +
             | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       221
       221
       +
             (let b = Buffer.create 256 in

     

       222
       222
       +
              let writer = Bytes.Writer.of_buffer b in

     

       223
       223
       +
              match Yamlt.encode ~format:Yamlt.Block codec v ~eod:true writer with

     

       224
       224
       +
              | Ok () -> Printf.printf "YAML Block:\n%s" (Buffer.contents b)

     

       222
       225
        
              | Error e -> Printf.printf "YAML Block ERROR: %s\n" e);

     

       223
       223
       -
             (match Yamlt.encode_string ~format:Yamlt.Flow codec v with

     

       224
       224
       -
              | Ok s -> Printf.printf "YAML Flow: %s" s

     

       225
       225
       -
              | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       226
       226
       -
         | "string" ->

     

       226
       226
       +
             let b = Buffer.create 256 in

     

       227
       227
       +
             let writer = Bytes.Writer.of_buffer b in

     

       228
       228
       +
             match Yamlt.encode ~format:Yamlt.Flow codec v ~eod:true writer with

     

       229
       229
       +
             | Ok () -> Printf.printf "YAML Flow: %s" (Buffer.contents b)

     

       230
       230
       +
             | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       231
       231
       +
         | "string" -> (

     

       227
       232
        
             let codec =

     

       228
       233
        
               Jsont.Object.map ~kind:"StringTest" (fun s -> s)

     

       229
       234
        
               |> Jsont.Object.mem "value" Jsont.string ~enc:(fun s -> s)

     
···

       231
       236
        
             in

     

       232
       237
        
             let v = value in

     

       233
       238
        
             (match Jsont_bytesrw.encode_string codec v with

     

       234
       234
       -
              | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       235
       235
       -
              | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       236
       236
       -
             (match Yamlt.encode_string ~format:Yamlt.Block codec v with

     

       237
       237
       -
              | Ok s -> Printf.printf "YAML Block:\n%s" s

     

       239
       239
       +
             | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       240
       240
       +
             | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       241
       241
       +
             (let b = Buffer.create 256 in

     

       242
       242
       +
              let writer = Bytes.Writer.of_buffer b in

     

       243
       243
       +
              match Yamlt.encode ~format:Yamlt.Block codec v ~eod:true writer with

     

       244
       244
       +
              | Ok () -> Printf.printf "YAML Block:\n%s" (Buffer.contents b)

     

       238
       245
        
              | Error e -> Printf.printf "YAML Block ERROR: %s\n" e);

     

       239
       239
       -
             (match Yamlt.encode_string ~format:Yamlt.Flow codec v with

     

       240
       240
       -
              | Ok s -> Printf.printf "YAML Flow: %s" s

     

       241
       241
       -
              | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       242
       242
       -
         | "null" ->

     

       246
       246
       +
             let b = Buffer.create 256 in

     

       247
       247
       +
             let writer = Bytes.Writer.of_buffer b in

     

       248
       248
       +
             match Yamlt.encode ~format:Yamlt.Flow codec v ~eod:true writer with

     

       249
       249
       +
             | Ok () -> Printf.printf "YAML Flow: %s" (Buffer.contents b)

     

       250
       250
       +
             | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       251
       251
       +
         | "null" -> (

     

       243
       252
        
             let codec =

     

       244
       253
        
               Jsont.Object.map ~kind:"NullTest" (fun n -> n)

     

       245
       254
        
               |> Jsont.Object.mem "value" (Jsont.null ()) ~enc:(fun n -> n)

     
···

       247
       256
        
             in

     

       248
       257
        
             let v = () in

     

       249
       258
        
             (match Jsont_bytesrw.encode_string codec v with

     

       250
       250
       -
              | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       251
       251
       -
              | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       252
       252
       -
             (match Yamlt.encode_string ~format:Yamlt.Block codec v with

     

       253
       253
       -
              | Ok s -> Printf.printf "YAML Block:\n%s" s

     

       259
       259
       +
             | Ok s -> Printf.printf "JSON: %s\n" (String.trim s)

     

       260
       260
       +
             | Error e -> Printf.printf "JSON ERROR: %s\n" e);

     

       261
       261
       +
             (let b = Buffer.create 256 in

     

       262
       262
       +
              let writer = Bytes.Writer.of_buffer b in

     

       263
       263
       +
              match Yamlt.encode ~format:Yamlt.Block codec v ~eod:true writer with

     

       264
       264
       +
              | Ok () -> Printf.printf "YAML Block:\n%s" (Buffer.contents b)

     

       254
       265
        
              | Error e -> Printf.printf "YAML Block ERROR: %s\n" e);

     

       255
       255
       -
             (match Yamlt.encode_string ~format:Yamlt.Flow codec v with

     

       256
       256
       -
              | Ok s -> Printf.printf "YAML Flow: %s" s

     

       257
       257
       -
              | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       266
       266
       +
             let b = Buffer.create 256 in

     

       267
       267
       +
             let writer = Bytes.Writer.of_buffer b in

     

       268
       268
       +
             match Yamlt.encode ~format:Yamlt.Flow codec v ~eod:true writer with

     

       269
       269
       +
             | Ok () -> Printf.printf "YAML Flow: %s" (Buffer.contents b)

     

       270
       270
       +
             | Error e -> Printf.printf "YAML Flow ERROR: %s\n" e)

     

       258
       271
        
         | _ -> failwith "unknown type"

     

       259
       272
        
       

     

       260
       273
        
       let () =

     
···

       266
       279
        
         end;

     

       267
       280
        
       

     

       268
       281
        
         match Sys.argv.(1) with

     

       269
       269
       -
         | "null" when Array.length Sys.argv = 3 ->

     

       270
       270
       -
             test_null_resolution Sys.argv.(2)

     

       271
       271
       -
       

     

       272
       272
       -
         | "bool" when Array.length Sys.argv = 3 ->

     

       273
       273
       -
             test_bool_resolution Sys.argv.(2)

     

       274
       274
       -
       

     

       282
       282
       +
         | "null" when Array.length Sys.argv = 3 -> test_null_resolution Sys.argv.(2)

     

       283
       283
       +
         | "bool" when Array.length Sys.argv = 3 -> test_bool_resolution Sys.argv.(2)

     

       275
       284
        
         | "number" when Array.length Sys.argv = 3 ->

     

       276
       285
        
             test_number_resolution Sys.argv.(2)

     

       277
       277
       -
       

     

       278
       286
        
         | "string" when Array.length Sys.argv = 3 ->

     

       279
       287
        
             test_string_resolution Sys.argv.(2)

     

       280
       280
       -
       

     

       281
       288
        
         | "special-float" when Array.length Sys.argv = 3 ->

     

       282
       289
        
             test_special_floats Sys.argv.(2)

     

       283
       283
       -
       

     

       284
       290
        
         | "type-mismatch" when Array.length Sys.argv = 4 ->

     

       285
       291
        
             test_type_mismatch Sys.argv.(2) Sys.argv.(3)

     

       286
       286
       -
       

     

       287
       287
       -
         | "any" when Array.length Sys.argv = 3 ->

     

       288
       288
       -
             test_any_resolution Sys.argv.(2)

     

       289
       289
       -
       

     

       292
       292
       +
         | "any" when Array.length Sys.argv = 3 -> test_any_resolution Sys.argv.(2)

     

       290
       293
        
         | "encode" when Array.length Sys.argv = 4 ->

     

       291
       294
        
             test_encode_formats Sys.argv.(2) Sys.argv.(3)

     

       292
       292
       -
       

     

       293
       295
        
         | _ ->

     

       294
       296
        
             prerr_endline usage;

     

       295
       297
        
             prerr_endline "Commands:";

     

       296
       298
        
             prerr_endline "  null <file>              - Test null resolution";

     

       297
       297
       -
             prerr_endline "  bool <file>              - Test bool vs string resolution";

     

       299
       299
       +
             prerr_endline

     

       300
       300
       +
               "  bool <file>              - Test bool vs string resolution";

     

       298
       301
        
             prerr_endline "  number <file>            - Test number resolution";

     

       299
       302
        
             prerr_endline "  string <file>            - Test string resolution";

     

       300
       303
        
             prerr_endline "  special-float <file>     - Test .inf, .nan, etc.";

     

       301
       301
       -
             prerr_endline "  type-mismatch <file> <type> - Test error on type mismatch";

     

       302
       302
       -
             prerr_endline "  any <file>               - Test Jsont.any auto-resolution";

     

       304
       304
       +
             prerr_endline

     

       305
       305
       +
               "  type-mismatch <file> <type> - Test error on type mismatch";

     

       306
       306
       +
             prerr_endline

     

       307
       307
       +
               "  any <file>               - Test Jsont.any auto-resolution";

     

       303
       308
        
             prerr_endline "  encode <type> <value>    - Test encoding to JSON/YAML";

     

       304
       309
        
             exit 1

+20 -14

tests/bin/test_some_vs_option.ml

···

       1
       1
       +
       open Bytesrw

     

       2
       2
       +
       

     

       1
       3
        
       let () =

     

       2
       4
        
         (* Using Jsont.some like opt_mem does *)

     

       3
       5
        
         let codec1 =

     

       4
       6
        
           Jsont.Object.map ~kind:"Test" (fun arr -> arr)

     

       5
       5
       -
           |> Jsont.Object.mem "values" (Jsont.some (Jsont.array Jsont.string)) ~enc:(fun arr -> arr)

     

       7
       7
       +
           |> Jsont.Object.mem "values"

     

       8
       8
       +
                (Jsont.some (Jsont.array Jsont.string))

     

       9
       9
       +
                ~enc:(fun arr -> arr)

     

       6
       10
        
           |> Jsont.Object.finish

     

       7
       11
        
         in

     

       8
       12
        
       

     

       9
       13
        
         let yaml = "values: [a, b, c]" in

     

       10
       14
        
       

     

       11
       15
        
         Printf.printf "Test 1: Jsont.some (Jsont.array) - like opt_mem:\n";

     

       12
       12
       -
         (match Yamlt.decode_string codec1 yaml with

     

       13
       13
       -
          | Ok arr ->

     

       14
       14
       -
              (match arr with

     

       15
       15
       -
               | None -> Printf.printf "Result: None\n"

     

       16
       16
       -
               | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       17
       17
       -
          | Error e -> Printf.printf "Error: %s\n" e);

     

       16
       16
       +
         (match Yamlt.decode codec1 (Bytes.Reader.of_string yaml) with

     

       17
       17
       +
         | Ok arr -> (

     

       18
       18
       +
             match arr with

     

       19
       19
       +
             | None -> Printf.printf "Result: None\n"

     

       20
       20
       +
             | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       21
       21
       +
         | Error e -> Printf.printf "Error: %s\n" e);

     

       18
       22
        
       

     

       19
       23
        
         (* Using Jsont.option *)

     

       20
       24
        
         let codec2 =

     

       21
       25
        
           Jsont.Object.map ~kind:"Test" (fun arr -> arr)

     

       22
       22
       -
           |> Jsont.Object.mem "values" (Jsont.option (Jsont.array Jsont.string)) ~enc:(fun arr -> arr)

     

       26
       26
       +
           |> Jsont.Object.mem "values"

     

       27
       27
       +
                (Jsont.option (Jsont.array Jsont.string))

     

       28
       28
       +
                ~enc:(fun arr -> arr)

     

       23
       29
        
           |> Jsont.Object.finish

     

       24
       30
        
         in

     

       25
       31
        
       

     

       26
       32
        
         Printf.printf "\nTest 2: Jsont.option (Jsont.array):\n";

     

       27
       27
       -
         (match Yamlt.decode_string codec2 yaml with

     

       28
       28
       -
          | Ok arr ->

     

       29
       29
       -
              (match arr with

     

       30
       30
       -
               | None -> Printf.printf "Result: None\n"

     

       31
       31
       -
               | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       32
       32
       -
          | Error e -> Printf.printf "Error: %s\n" e)

     

       33
       33
       +
         match Yamlt.decode codec2 (Bytes.Reader.of_string yaml) with

     

       34
       34
       +
         | Ok arr -> (

     

       35
       35
       +
             match arr with

     

       36
       36
       +
             | None -> Printf.printf "Result: None\n"

     

       37
       37
       +
             | Some a -> Printf.printf "Result: Some([%d items])\n" (Array.length a))

     

       38
       38
       +
         | Error e -> Printf.printf "Error: %s\n" e

+12 -7

tests/cram/arrays_codec.t

···

       78
       78
        
         File "-", line 1, characters 11-22: array<string>

     

       79
       79
        
         File "-": in member values of

     

       80
       80
        
         File "-", line 1, characters 0-22: Nullable object

     

       81
       81
       -
         YAML: nullable_array: ["hello"; "null"; "world"; "null"; "test"]

     

       81
       81
       +
         YAML: nullable_array: ERROR: Expected string but found null

     

       82
       82
       +
         File "-":

     

       83
       83
       +
         at index 1 of

     

       84
       84
       +
         File "-": array<string>

     

       85
       85
       +
         File "-": in member values of

     

       86
       86
       +
         File "-": Nullable object

     

       82
       87
        
       

     

       83
       88
        
       ================================================================================

     

       84
       89
        
       ERROR HANDLING

     
···

       104
       109
        
         JSON: {"numbers":[1,2,3,4,5],"strings":["hello","world"]}

     

       105
       110
        
         YAML Block:

     

       106
       111
        
         numbers:

     

       107
       107
       -
           - 1.0

     

       108
       108
       -
           - 2.0

     

       109
       109
       -
           - 3.0

     

       110
       110
       -
           - 4.0

     

       111
       111
       -
           - 5.0

     

       112
       112
       +
           - 1

     

       113
       113
       +
           - 2

     

       114
       114
       +
           - 3

     

       115
       115
       +
           - 4

     

       116
       116
       +
           - 5

     

       112
       117
        
         strings:

     

       113
       118
        
           - hello

     

       114
       119
        
           - world

     

       115
       115
       -
         YAML Flow: {numbers: [1.0, 2.0, 3.0, 4.0, 5.0]strings, [hello, world]}

     

       120
       120
       +
         YAML Flow: {numbers: [1, 2, 3, 4, 5], strings: [hello, world]}

     

       116
       121
        
       

     

       117
       122
        
       ================================================================================

     

       118
       123
        
       NEGATIVE TESTS - Wrong File Types

+1 -4

tests/cram/complex_codec.t

···

       32
       32
        
       

     

       33
       33
        
         $ test_complex complex-optional ../data/complex/complex_optional.yml

     

       34
       34
        
         JSON: complex_optional: host="example.com", port=443, ssl=true, fallbacks=2

     

       35
       35
       -
         YAML: complex_optional: ERROR: Expected array<string> but found sequence

     

       36
       36
       -
         File "-":

     

       37
       37
       -
         File "-": in member fallback_hosts of

     

       38
       38
       -
         File "-": Config object

     

       35
       35
       +
         YAML: complex_optional: host="example.com", port=443, ssl=true, fallbacks=2

     

       39
       36
        
       

     

       40
       37
        
       ================================================================================

     

       41
       38
        
       HETEROGENEOUS DATA

+3 -1

tests/cram/dune

···

       12
       12
        
         (glob_files ../data/complex/*.yml)

     

       13
       13
        
         (glob_files ../data/complex/*.json)

     

       14
       14
        
         (glob_files ../data/edge/*.yml)

     

       15
       15
       -
         (glob_files ../data/edge/*.json)))

     

       15
       15
       +
         (glob_files ../data/edge/*.json)

     

       16
       16
       +
         (glob_files ../data/multidoc/*.yml)

     

       17
       17
       +
         (glob_files ../data/locations/*.yml)))

+10 -10

tests/cram/formats_codec.t

···

       31
       31
        
       

     

       32
       32
        
         $ test_formats number-formats ../data/formats/number_formats.yml

     

       33
       33
        
         JSON: number_formats: hex=255, octal=63, binary=10

     

       34
       34
       -
         YAML: number_formats: ERROR: Expected number but found scalar 0o77

     

       35
       35
       -
         File "-":

     

       36
       36
       -
         File "-": in member octal of

     

       37
       37
       -
         File "-": Numbers object

     

       34
       34
       +
         YAML: number_formats: hex=255, octal=63, binary=10

     

       38
       35
        
       

     

       39
       36
        
       ================================================================================

     

       40
       37
        
       COMMENTS

     
···

       56
       53
        
         File "-", line 1, characters 10-11:

     

       57
       54
        
         File "-": in member value of

     

       58
       55
        
         File "-", line 1, characters 0-11: Wrapper object

     

       59
       59
       -
         YAML: empty_document: value=Some("null")

     

       56
       56
       +
         YAML: empty_document: ERROR: Expected string but found null

     

       57
       57
       +
         File "-":

     

       58
       58
       +
         File "-": in member value of

     

       59
       59
       +
         File "-": Wrapper object

     

       60
       60
        
       

     

       61
       61
        
       ================================================================================

     

       62
       62
        
       EXPLICIT TYPE TAGS

     
···

       77
       77
        
         YAML Block:

     

       78
       78
        
         name: test

     

       79
       79
        
         values:

     

       80
       80
       -
           - 1.0

     

       81
       81
       -
           - 2.0

     

       82
       82
       -
           - 3.0

     

       80
       80
       +
           - 1

     

       81
       81
       +
           - 2

     

       82
       82
       +
           - 3

     

       83
       83
        
         nested:

     

       84
       84
        
           enabled: true

     

       85
       85
       -
           count: 5.0

     

       85
       85
       +
           count: 5

     

       86
       86
        
         

     

       87
       87
        
         YAML Flow:

     

       88
       88
       -
         {name: test, values: [1.0, 2.0, 3.0]nested, {enabled: true, count: 5.0}}

     

       88
       88
       +
         {name: test, values: [1, 2, 3], nested: {enabled: true, count: 5}}

     

       89
       89
        
       

     

       90
       90
        
       

     

       91
       91
        
       ================================================================================

+217

tests/cram/locations.t

···

       1
       1
       +
       Location and Layout Preservation Tests with Yamlt

     

       2
       2
       +
       ==================================================

     

       3
       3
       +
       

     

       4
       4
       +
       This test suite validates the `locs` and `layout` options in the Yamlt decoder,

     

       5
       5
       +
       demonstrating how they affect error messages and metadata preservation.

     

       6
       6
       +
       

     

       7
       7
       +
       ================================================================================

     

       8
       8
       +
       ERROR MESSAGE PRECISION - locs option

     

       9
       9
       +
       ================================================================================

     

       10
       10
       +
       

     

       11
       11
       +
       The `locs` option controls whether source locations are preserved in error messages.

     

       12
       12
       +
       When `locs=false` (default), errors show basic location info.

     

       13
       13
       +
       When `locs=true`, errors show precise character positions.

     

       14
       14
       +
       

     

       15
       15
       +
       Basic type error with and without locs

     

       16
       16
       +
       

     

       17
       17
       +
         $ test_locations error-precision ../data/locations/type_error.yml

     

       18
       18
       +
         === Without locs (default) ===

     

       19
       19
       +
         Error message:

     

       20
       20
       +
         String "not-a-number" does not parse to OCaml int value

     

       21
       21
       +
         File "-":

     

       22
       22
       +
         File "-": in member age of

     

       23
       23
       +
         File "-": Person object

     

       24
       24
       +
         

     

       25
       25
       +
         === With locs=true ===

     

       26
       26
       +
         Error message:

     

       27
       27
       +
         String "not-a-number" does not parse to OCaml int value

     

       28
       28
       +
         File "-", line 2, characters 5-18:

     

       29
       29
       +
         File "-", line 2, characters 0-3: in member age of

     

       30
       30
       +
         File "-", line 1, characters 0-1: Person object

     

       31
       31
       +
       

     

       32
       32
       +
       ================================================================================

     

       33
       33
       +
       NESTED ERROR LOCATIONS

     

       34
       34
       +
       ================================================================================

     

       35
       35
       +
       

     

       36
       36
       +
       The `locs` option is especially useful for nested structures,

     

       37
       37
       +
       showing exactly where deep errors occur.

     

       38
       38
       +
       

     

       39
       39
       +
       Error in nested object field

     

       40
       40
       +
       

     

       41
       41
       +
         $ test_locations nested-error ../data/locations/nested_error.yml

     

       42
       42
       +
         === Without locs (default) ===

     

       43
       43
       +
         Nested error:

     

       44
       44
       +
         String "invalid-zip" does not parse to OCaml int value

     

       45
       45
       +
         File "-":

     

       46
       46
       +
         File "-": in member zip of

     

       47
       47
       +
         File "-": Address object

     

       48
       48
       +
         File "-": in member address of

     

       49
       49
       +
         File "-": Employee object

     

       50
       50
       +
         

     

       51
       51
       +
         === With locs=true ===

     

       52
       52
       +
         Nested error:

     

       53
       53
       +
         String "invalid-zip" does not parse to OCaml int value

     

       54
       54
       +
         File "-", line 5, characters 7-19:

     

       55
       55
       +
         File "-", line 5, characters 2-5: in member zip of

     

       56
       56
       +
         File "-", line 3, characters 2-3: Address object

     

       57
       57
       +
         File "-", line 2, characters 0-7: in member address of

     

       58
       58
       +
         File "-", line 1, characters 0-1: Employee object

     

       59
       59
       +
       

     

       60
       60
       +
       ================================================================================

     

       61
       61
       +
       ARRAY ELEMENT ERROR LOCATIONS

     

       62
       62
       +
       ================================================================================

     

       63
       63
       +
       

     

       64
       64
       +
       The `locs` option pinpoints which array element caused an error.

     

       65
       65
       +
       

     

       66
       66
       +
       Error at specific array index

     

       67
       67
       +
       

     

       68
       68
       +
         $ test_locations array-error ../data/locations/array_error.yml

     

       69
       69
       +
         === Without locs (default) ===

     

       70
       70
       +
         Array error:

     

       71
       71
       +
         String "not-a-number" does not parse to OCaml int value

     

       72
       72
       +
         File "-":

     

       73
       73
       +
         at index 2 of

     

       74
       74
       +
         File "-": array<OCaml int>

     

       75
       75
       +
         File "-": in member values of

     

       76
       76
       +
         File "-": Numbers object

     

       77
       77
       +
         

     

       78
       78
       +
         === With locs=true ===

     

       79
       79
       +
         Array error:

     

       80
       80
       +
         String "not-a-number" does not parse to OCaml int value

     

       81
       81
       +
         File "-", lines 4-5, characters 4-2:

     

       82
       82
       +
         at index 2 of

     

       83
       83
       +
         File "-", line 2, characters 2-3: array<OCaml int>

     

       84
       84
       +
         File "-", line 1, characters 0-6: in member values of

     

       85
       85
       +
         File "-", line 1, characters 0-1: Numbers object

     

       86
       86
       +
       

     

       87
       87
       +
       ================================================================================

     

       88
       88
       +
       FILE PATH IN ERROR MESSAGES

     

       89
       89
       +
       ================================================================================

     

       90
       90
       +
       

     

       91
       91
       +
       The `file` parameter sets the file path shown in error messages.

     

       92
       92
       +
       

     

       93
       93
       +
         $ test_locations file-path

     

       94
       94
       +
         === Without file path ===

     

       95
       95
       +
         Error:

     

       96
       96
       +
         String "not-a-number" does not parse to OCaml int value

     

       97
       97
       +
         File "-", line 2, characters 5-18:

     

       98
       98
       +
         File "-", line 2, characters 0-3: in member age of

     

       99
       99
       +
         File "-", line 1, characters 0-1: Person object

     

       100
       100
       +
         

     

       101
       101
       +
         === With file path ===

     

       102
       102
       +
         Error:

     

       103
       103
       +
         String "not-a-number" does not parse to OCaml int value

     

       104
       104
       +
         File "test.yml", line 2, characters 5-18:

     

       105
       105
       +
         File "test.yml", line 2, characters 0-3: in member age of

     

       106
       106
       +
         File "test.yml", line 1, characters 0-1: Person object

     

       107
       107
       +
       

     

       108
       108
       +
       ================================================================================

     

       109
       109
       +
       MISSING FIELD ERROR LOCATIONS

     

       110
       110
       +
       ================================================================================

     

       111
       111
       +
       

     

       112
       112
       +
       The `locs` option helps identify where fields are missing.

     

       113
       113
       +
       

     

       114
       114
       +
         $ test_locations missing-field ../data/locations/missing_field.yml

     

       115
       115
       +
         === Without locs ===

     

       116
       116
       +
         Missing field:

     

       117
       117
       +
         Missing member field_c in Complete object

     

       118
       118
       +
         File "-":

     

       119
       119
       +
         

     

       120
       120
       +
         === With locs=true ===

     

       121
       121
       +
         Missing field:

     

       122
       122
       +
         Missing member field_c in Complete object

     

       123
       123
       +
         File "-", line 1, characters 0-1:

     

       124
       124
       +
       

     

       125
       125
       +
       ================================================================================

     

       126
       126
       +
       LAYOUT PRESERVATION - layout option

     

       127
       127
       +
       ================================================================================

     

       128
       128
       +
       

     

       129
       129
       +
       The `layout` option controls whether style information (block vs flow)

     

       130
       130
       +
       is preserved in metadata for potential round-tripping.

     

       131
       131
       +
       

     

       132
       132
       +
       Basic layout preservation

     

       133
       133
       +
       

     

       134
       134
       +
         $ test_locations layout ../data/locations/simple.yml

     

       135
       135
       +
         === Without layout (default) ===

     

       136
       136
       +
         Decoded: host=localhost, port=8080

     

       137
       137
       +
         Meta preserved: no

     

       138
       138
       +
         

     

       139
       139
       +
         === With layout=true ===

     

       140
       140
       +
         Decoded: host=localhost, port=8080

     

       141
       141
       +
         Meta preserved: yes (style info available for round-tripping)

     

       142
       142
       +
       

     

       143
       143
       +
       ================================================================================

     

       144
       144
       +
       ROUND-TRIPPING WITH LAYOUT

     

       145
       145
       +
       ================================================================================

     

       146
       146
       +
       

     

       147
       147
       +
       With `layout=true` during decode and `format:Layout` during encode,

     

       148
       148
       +
       the original YAML style can be preserved.

     

       149
       149
       +
       

     

       150
       150
       +
       Flow style preservation

     

       151
       151
       +
       

     

       152
       152
       +
         $ test_locations roundtrip ../data/locations/flow_style.yml

     

       153
       153
       +
         === Original YAML ===

     

       154
       154
       +
         items: [apple, banana, cherry]

     

       155
       155
       +
         

     

       156
       156
       +
         === Decode without layout, re-encode ===

     

       157
       157
       +
         items:

     

       158
       158
       +
           - apple

     

       159
       159
       +
           - banana

     

       160
       160
       +
           - cherry

     

       161
       161
       +
         

     

       162
       162
       +
         === Decode with layout=true, re-encode with Layout format ===

     

       163
       163
       +
         items:

     

       164
       164
       +
           - apple

     

       165
       165
       +
           - banana

     

       166
       166
       +
           - cherry

     

       167
       167
       +
       

     

       168
       168
       +
       Block style preservation

     

       169
       169
       +
       

     

       170
       170
       +
         $ test_locations roundtrip ../data/locations/block_style.yml

     

       171
       171
       +
         === Original YAML ===

     

       172
       172
       +
         items:

     

       173
       173
       +
           - apple

     

       174
       174
       +
           - banana

     

       175
       175
       +
           - cherry

     

       176
       176
       +
         

     

       177
       177
       +
         === Decode without layout, re-encode ===

     

       178
       178
       +
         items:

     

       179
       179
       +
           - apple

     

       180
       180
       +
           - banana

     

       181
       181
       +
           - cherry

     

       182
       182
       +
         

     

       183
       183
       +
         === Decode with layout=true, re-encode with Layout format ===

     

       184
       184
       +
         items:

     

       185
       185
       +
           - apple

     

       186
       186
       +
           - banana

     

       187
       187
       +
           - cherry

     

       188
       188
       +
       

     

       189
       189
       +
       ================================================================================

     

       190
       190
       +
       COMBINED OPTIONS - locs and layout together

     

       191
       191
       +
       ================================================================================

     

       192
       192
       +
       

     

       193
       193
       +
       Both options can be used simultaneously for maximum information.

     

       194
       194
       +
       

     

       195
       195
       +
         $ test_locations combined ../data/locations/valid_settings.yml

     

       196
       196
       +
         === locs=false, layout=false (defaults) ===

     

       197
       197
       +
         OK: timeout=30, retries=3

     

       198
       198
       +
         

     

       199
       199
       +
         === locs=true, layout=false ===

     

       200
       200
       +
         OK: timeout=30, retries=3 (with precise locations)

     

       201
       201
       +
         

     

       202
       202
       +
         === locs=false, layout=true ===

     

       203
       203
       +
         OK: timeout=30, retries=3 (with layout metadata)

     

       204
       204
       +
         

     

       205
       205
       +
         === locs=true, layout=true (both enabled) ===

     

       206
       206
       +
         OK: timeout=30, retries=3 (with locations and layout)

     

       207
       207
       +
       

     

       208
       208
       +
       ================================================================================

     

       209
       209
       +
       SUMMARY OF OPTIONS

     

       210
       210
       +
       ================================================================================

     

       211
       211
       +
       

     

       212
       212
       +
       locs option:

     

       213
       213
       +
       

     

       214
       214
       +
       layout option:

     

       215
       215
       +
       

     

       216
       216
       +
       Both options add metadata overhead, so only enable when needed.

     

       217
       217
       +
       For production parsing where you only need the data, use defaults (both false).

+220

tests/cram/multidoc.t

···

       1
       1
       +
       Multi-Document YAML Streams with Yamlt

     

       2
       2
       +
       ========================================

     

       3
       3
       +
       

     

       4
       4
       +
       This test suite validates multi-document YAML stream decoding using decode_all,

     

       5
       5
       +
       including error handling, location tracking, and JSON roundtripping.

     

       6
       6
       +
       

     

       7
       7
       +
       ================================================================================

     

       8
       8
       +
       BASIC MULTIDOC DECODING

     

       9
       9
       +
       ================================================================================

     

       10
       10
       +
       

     

       11
       11
       +
       Simple multi-document stream with person objects

     

       12
       12
       +
       

     

       13
       13
       +
         $ test_multidoc simple ../data/multidoc/simple.yml

     

       14
       14
       +
         Documents:

     

       15
       15
       +
           [0] : Alice (age 30)

     

       16
       16
       +
           [1] : Bob (age 25)

     

       17
       17
       +
           [2] : Charlie (age 35)

     

       18
       18
       +
       

     

       19
       19
       +
       Count documents in a stream

     

       20
       20
       +
       

     

       21
       21
       +
         $ test_multidoc count ../data/multidoc/simple.yml

     

       22
       22
       +
         Document count: 3

     

       23
       23
       +
       

     

       24
       24
       +
       ================================================================================

     

       25
       25
       +
       ERROR HANDLING - MIXED VALID AND INVALID DOCUMENTS

     

       26
       26
       +
       ================================================================================

     

       27
       27
       +
       

     

       28
       28
       +
       When some documents succeed and others fail, decode_all continues processing

     

       29
       29
       +
       and returns results for each document individually.

     

       30
       30
       +
       

     

       31
       31
       +
       Stream with one error in the middle

     

       32
       32
       +
       

     

       33
       33
       +
         $ test_multidoc errors ../data/multidoc/mixed_errors.yml

     

       34
       34
       +
         Document results:

     

       35
       35
       +
           [0] OK: Alice (age 30)

     

       36
       36
       +
           [1] ERROR: String "not-a-number" does not parse to OCaml int value

     

       37
       37
       +
         File "-":

     

       38
       38
       +
         File "-": in member age of

     

       39
       39
       +
         File "-": Person object

     

       40
       40
       +
           [2] OK: Charlie (age 35)

     

       41
       41
       +
       

     

       42
       42
       +
       Summary statistics for mixed documents

     

       43
       43
       +
       

     

       44
       44
       +
         $ test_multidoc summary ../data/multidoc/mixed_errors.yml

     

       45
       45
       +
         Summary: 3 documents (2 ok, 1 error)

     

       46
       46
       +
       

     

       47
       47
       +
       Stream where all documents fail

     

       48
       48
       +
       

     

       49
       49
       +
         $ test_multidoc errors ../data/multidoc/all_errors.yml

     

       50
       50
       +
         Document results:

     

       51
       51
       +
           [0] ERROR: String "invalid1" does not parse to OCaml int value

     

       52
       52
       +
         File "-":

     

       53
       53
       +
         File "-": in member age of

     

       54
       54
       +
         File "-": Person object

     

       55
       55
       +
           [1] ERROR: String "invalid2" does not parse to OCaml int value

     

       56
       56
       +
         File "-":

     

       57
       57
       +
         File "-": in member age of

     

       58
       58
       +
         File "-": Person object

     

       59
       59
       +
           [2] ERROR: String "invalid3" does not parse to OCaml int value

     

       60
       60
       +
         File "-":

     

       61
       61
       +
         File "-": in member age of

     

       62
       62
       +
         File "-": Person object

     

       63
       63
       +
       

     

       64
       64
       +
       Summary for all-error stream

     

       65
       65
       +
       

     

       66
       66
       +
         $ test_multidoc summary ../data/multidoc/all_errors.yml

     

       67
       67
       +
         Summary: 3 documents (0 ok, 3 error)

     

       68
       68
       +
       

     

       69
       69
       +
       ================================================================================

     

       70
       70
       +
       LOCATION TRACKING WITH locs=true

     

       71
       71
       +
       ================================================================================

     

       72
       72
       +
       

     

       73
       73
       +
       Location tracking helps identify exactly where errors occur in each document

     

       74
       74
       +
       of a multi-document stream.

     

       75
       75
       +
       

     

       76
       76
       +
       Without locs (default) - basic error information

     

       77
       77
       +
       

     

       78
       78
       +
         $ test_multidoc locations ../data/multidoc/mixed_errors.yml

     

       79
       79
       +
         === Without locs (default) ===

     

       80
       80
       +
           [0] OK

     

       81
       81
       +
           [1] ERROR:

     

       82
       82
       +
         String "not-a-number" does not parse to OCaml int value

     

       83
       83
       +
         File "-":

     

       84
       84
       +
         File "-": in member age of

     

       85
       85
       +
         File "-": Person object

     

       86
       86
       +
           [2] OK

     

       87
       87
       +
         

     

       88
       88
       +
         === With locs=true ===

     

       89
       89
       +
           [0] OK

     

       90
       90
       +
           [1] ERROR:

     

       91
       91
       +
         String "not-a-number" does not parse to OCaml int value

     

       92
       92
       +
         File "test.yml", line 6, characters 5-18:

     

       93
       93
       +
         File "test.yml", line 6, characters 0-3: in member age of

     

       94
       94
       +
         File "test.yml", line 5, characters 0-1: Person object

     

       95
       95
       +
           [2] OK

     

       96
       96
       +
       

     

       97
       97
       +
       ================================================================================

     

       98
       98
       +
       MISSING FIELDS IN MULTIDOC

     

       99
       99
       +
       ================================================================================

     

       100
       100
       +
       

     

       101
       101
       +
       Documents with missing required fields generate errors but don't stop

     

       102
       102
       +
       processing of subsequent documents.

     

       103
       103
       +
       

     

       104
       104
       +
         $ test_multidoc errors ../data/multidoc/missing_fields.yml

     

       105
       105
       +
         Document results:

     

       106
       106
       +
           [0] OK: Alice (age 30)

     

       107
       107
       +
           [1] ERROR: Missing member age in Person object

     

       108
       108
       +
         File "-":

     

       109
       109
       +
           [2] OK: Charlie (age 35)

     

       110
       110
       +
       

     

       111
       111
       +
       Summary of missing fields test

     

       112
       112
       +
       

     

       113
       113
       +
         $ test_multidoc summary ../data/multidoc/missing_fields.yml

     

       114
       114
       +
         Summary: 3 documents (2 ok, 1 error)

     

       115
       115
       +
       

     

       116
       116
       +
       ================================================================================

     

       117
       117
       +
       JSON ROUNDTRIPPING

     

       118
       118
       +
       ================================================================================

     

       119
       119
       +
       

     

       120
       120
       +
       Decode YAML multi-document streams and encode each document as JSON.

     

       121
       121
       +
       This validates that the data model conversion is correct.

     

       122
       122
       +
       

     

       123
       123
       +
       Simple documents to JSON

     

       124
       124
       +
       

     

       125
       125
       +
         $ test_multidoc json ../data/multidoc/simple.yml

     

       126
       126
       +
         JSON outputs:

     

       127
       127
       +
           [0] {"name":"Alice","age":30}

     

       128
       128
       +
           [1] {"name":"Bob","age":25}

     

       129
       129
       +
           [2] {"name":"Charlie","age":35}

     

       130
       130
       +
       

     

       131
       131
       +
       Nested objects to JSON

     

       132
       132
       +
       

     

       133
       133
       +
         $ test_multidoc json ../data/multidoc/nested.yml

     

       134
       134
       +
         JSON outputs:

     

       135
       135
       +
           [0] {"name":"Alice","age":30,"address":{"street":"123 Main St","city":"Boston"}}

     

       136
       136
       +
           [1] {"name":"Bob","age":25,"address":{"street":"456 Oak Ave","city":"Seattle"}}

     

       137
       137
       +
           [2] {"name":"Charlie","age":35,"address":{"street":"789 Pine Rd","city":"Portland"}}

     

       138
       138
       +
       

     

       139
       139
       +
       Arrays to JSON

     

       140
       140
       +
       

     

       141
       141
       +
         $ test_multidoc json ../data/multidoc/arrays.yml

     

       142
       142
       +
         JSON outputs:

     

       143
       143
       +
           [0] [1,2,3]

     

       144
       144
       +
           [1] ["apple","banana","cherry"]

     

       145
       145
       +
           [2] [true,false,true]

     

       146
       146
       +
       

     

       147
       147
       +
       Scalar values to JSON

     

       148
       148
       +
       

     

       149
       149
       +
         $ test_multidoc json ../data/multidoc/scalars.yml

     

       150
       150
       +
         JSON outputs:

     

       151
       151
       +
           [0] "hello world"

     

       152
       152
       +
           [1] 42

     

       153
       153
       +
           [2] true

     

       154
       154
       +
           [3] null

     

       155
       155
       +
       

     

       156
       156
       +
       ================================================================================

     

       157
       157
       +
       NESTED OBJECTS IN MULTIDOC

     

       158
       158
       +
       ================================================================================

     

       159
       159
       +
       

     

       160
       160
       +
       Test decoding complex nested structures across multiple documents.

     

       161
       161
       +
       

     

       162
       162
       +
         $ test_multidoc nested ../data/multidoc/nested.yml

     

       163
       163
       +
         Nested documents:

     

       164
       164
       +
           [0] : Alice (age 30) from 123 Main St, Boston

     

       165
       165
       +
           [1] : Bob (age 25) from 456 Oak Ave, Seattle

     

       166
       166
       +
           [2] : Charlie (age 35) from 789 Pine Rd, Portland

     

       167
       167
       +
       

     

       168
       168
       +
       ================================================================================

     

       169
       169
       +
       ARRAYS IN MULTIDOC

     

       170
       170
       +
       ================================================================================

     

       171
       171
       +
       

     

       172
       172
       +
       Test decoding different array types across documents.

     

       173
       173
       +
       

     

       174
       174
       +
         $ test_multidoc arrays ../data/multidoc/arrays.yml

     

       175
       175
       +
         Array documents:

     

       176
       176
       +
           [0] [1,2,3]

     

       177
       177
       +
           [1] ["apple","banana","cherry"]

     

       178
       178
       +
           [2] [true,false,true]

     

       179
       179
       +
       

     

       180
       180
       +
       ================================================================================

     

       181
       181
       +
       SCALARS IN MULTIDOC

     

       182
       182
       +
       ================================================================================

     

       183
       183
       +
       

     

       184
       184
       +
       Test decoding bare scalar values as documents.

     

       185
       185
       +
       

     

       186
       186
       +
         $ test_multidoc scalars ../data/multidoc/scalars.yml

     

       187
       187
       +
         Scalar documents:

     

       188
       188
       +
           [0] "hello world"

     

       189
       189
       +
           [1] 42

     

       190
       190
       +
           [2] true

     

       191
       191
       +
           [3] null

     

       192
       192
       +
       

     

       193
       193
       +
       ================================================================================

     

       194
       194
       +
       EMPTY DOCUMENTS

     

       195
       195
       +
       ================================================================================

     

       196
       196
       +
       

     

       197
       197
       +
       Empty or null documents in a stream are handled correctly.

     

       198
       198
       +
       

     

       199
       199
       +
         $ test_multidoc json ../data/multidoc/empty_docs.yml

     

       200
       200
       +
         JSON outputs:

     

       201
       201
       +
           [0] {"name":"Alice","age":30}

     

       202
       202
       +
           [1] null

     

       203
       203
       +
           [2] {"name":"Charlie","age":35}

     

       204
       204
       +
       

     

       205
       205
       +
       Count including empty documents

     

       206
       206
       +
       

     

       207
       207
       +
         $ test_multidoc count ../data/multidoc/empty_docs.yml

     

       208
       208
       +
         Document count: 3

     

       209
       209
       +
       

     

       210
       210
       +
       ================================================================================

     

       211
       211
       +
       SUMMARY

     

       212
       212
       +
       ================================================================================

     

       213
       213
       +
       

     

       214
       214
       +
       The decode_all function:

     

       215
       215
       +
       - Processes all documents in a stream, not stopping on errors

     

       216
       216
       +
       - Returns a sequence of Result values (Ok/Error for each document)

     

       217
       217
       +
       - Supports all decode options: locs, layout, file, max_depth, max_nodes

     

       218
       218
       +
       - Correctly handles document boundaries even when errors occur

     

       219
       219
       +
       - Works with any Jsont codec (objects, arrays, scalars, etc.)

     

       220
       220
       +
       - Can be used for JSON roundtripping and format conversion

+37

tests/cram/null_collections.t

···

       1
       1
       +
       Null to Empty Collection Tests

     

       2
       2
       +
       ================================

     

       3
       3
       +
       

     

       4
       4
       +
       This test suite validates that yamlt treats null values as empty collections

     

       5
       5
       +
       when decoding into Array or Object types, providing a more user-friendly

     

       6
       6
       +
       YAML experience.

     

       7
       7
       +
       

     

       8
       8
       +
       ================================================================================

     

       9
       9
       +
       NULL AS EMPTY COLLECTION

     

       10
       10
       +
       ================================================================================

     

       11
       11
       +
       

     

       12
       12
       +
       Test various forms of null decoding as empty arrays and objects

     

       13
       13
       +
       

     

       14
       14
       +
         $ test_null_collections

     

       15
       15
       +
         === Test 1: Explicit null as empty array ===

     

       16
       16
       +
         Result: []

     

       17
       17
       +
         

     

       18
       18
       +
         === Test 2: Tilde as empty array ===

     

       19
       19
       +
         Result: []

     

       20
       20
       +
         

     

       21
       21
       +
         === Test 3: Empty array syntax ===

     

       22
       22
       +
         Result: []

     

       23
       23
       +
         

     

       24
       24
       +
         === Test 4: Array with values ===

     

       25
       25
       +
         Result: [1; 2; 3]

     

       26
       26
       +
         

     

       27
       27
       +
         === Test 5: Explicit null as empty object ===

     

       28
       28
       +
         Result: {timeout=30; retries=3}

     

       29
       29
       +
         

     

       30
       30
       +
         === Test 6: Empty object syntax ===

     

       31
       31
       +
         Result: {timeout=30; retries=3}

     

       32
       32
       +
         

     

       33
       33
       +
         === Test 7: Object with values ===

     

       34
       34
       +
         Result: {timeout=60; retries=5}

     

       35
       35
       +
         

     

       36
       36
       +
         === Test 8: Nested null arrays ===

     

       37
       37
       +
         Result: {name=test; items_count=0; tags_count=0}

+2 -2

tests/cram/objects_codec.t

···

       119
       119
        
         JSON: {"name":"Alice","age":30,"active":true}

     

       120
       120
        
         YAML Block:

     

       121
       121
        
         name: Alice

     

       122
       122
       -
         age: 30.0

     

       122
       122
       +
         age: 30

     

       123
       123
        
         active: true

     

       124
       124
       -
         YAML Flow: {name: Alice, age: 30.0, active: true}

     

       124
       124
       +
         YAML Flow: {name: Alice, age: 30, active: true}

     

       125
       125
        
       

     

       126
       126
        
       ================================================================================

     

       127
       127
        
       NEGATIVE TESTS - Wrong File Types

+1 -4

tests/cram/scalars_codec.t

···

       149
       149
        
         JSON number_codec

     

       150
       150
        
           decode: 42

     

       151
       151
        
         YAML number_codec

     

       152
       152
       -
           decode: ERROR: Expected number but found scalar 0o52

     

       153
       153
       -
         File "-":

     

       154
       154
       -
         File "-": in member value of

     

       155
       155
       -
         File "-": NumberTest object

     

       152
       152
       +
           decode: 42

     

       156
       153
        
       

     

       157
       154
        
       Negative numbers

     

       158
       155

tests/data/locations/array_error.yml

···

       1
       1
       +
       values:

     

       2
       2
       +
         - 1

     

       3
       3
       +
         - 2

     

       4
       4
       +
         - not-a-number

     

       5
       5
       +
         - 4

     

       6
       6
       +
         - 5

tests/data/locations/block_style.yml

tests/data/locations/flow_style.yml

···

       1
       1
       +
       items: [apple, banana, cherry]

tests/data/locations/missing_field.yml

···

       1
       1
       +
       field_a: hello

     

       2
       2
       +
       field_b: 42

tests/data/locations/nested_error.yml

···

       1
       1
       +
       name: Bob

     

       2
       2
       +
       address:

     

       3
       3
       +
         street: 123 Main St

     

       4
       4
       +
         city: Springfield

     

       5
       5
       +
         zip: invalid-zip

tests/data/locations/simple.yml

···

       1
       1
       +
       host: localhost

     

       2
       2
       +
       port: 8080

tests/data/locations/type_error.yml

···

       1
       1
       +
       name: Alice

     

       2
       2
       +
       age: not-a-number

tests/data/locations/valid_settings.yml

···

       1
       1
       +
       timeout: 30

     

       2
       2
       +
       retries: 3

tests/data/multidoc/all_errors.yml

···

       1
       1
       +
       ---

     

       2
       2
       +
       name: Alice

     

       3
       3
       +
       age: invalid1

     

       4
       4
       +
       ---

     

       5
       5
       +
       name: Bob

     

       6
       6
       +
       age: invalid2

     

       7
       7
       +
       ---

     

       8
       8
       +
       name: Charlie

     

       9
       9
       +
       age: invalid3

+12

tests/data/multidoc/arrays.yml

tests/data/multidoc/empty_docs.yml

···

       1
       1
       +
       ---

     

       2
       2
       +
       name: Alice

     

       3
       3
       +
       age: 30

     

       4
       4
       +
       ---

     

       5
       5
       +
       ---

     

       6
       6
       +
       name: Charlie

     

       7
       7
       +
       age: 35

tests/data/multidoc/missing_fields.yml

···

       1
       1
       +
       ---

     

       2
       2
       +
       name: Alice

     

       3
       3
       +
       age: 30

     

       4
       4
       +
       ---

     

       5
       5
       +
       name: Bob

     

       6
       6
       +
       ---

     

       7
       7
       +
       name: Charlie

     

       8
       8
       +
       age: 35

     

       9
       9
       +
       city: Springfield

tests/data/multidoc/mixed_errors.yml

···

       1
       1
       +
       ---

     

       2
       2
       +
       name: Alice

     

       3
       3
       +
       age: 30

     

       4
       4
       +
       ---

     

       5
       5
       +
       name: Bob

     

       6
       6
       +
       age: not-a-number

     

       7
       7
       +
       ---

     

       8
       8
       +
       name: Charlie

     

       9
       9
       +
       age: 35

+18

tests/data/multidoc/nested.yml

···

       1
       1
       +
       ---

     

       2
       2
       +
       name: Alice

     

       3
       3
       +
       age: 30

     

       4
       4
       +
       address:

     

       5
       5
       +
         street: 123 Main St

     

       6
       6
       +
         city: Boston

     

       7
       7
       +
       ---

     

       8
       8
       +
       name: Bob

     

       9
       9
       +
       age: 25

     

       10
       10
       +
       address:

     

       11
       11
       +
         street: 456 Oak Ave

     

       12
       12
       +
         city: Seattle

     

       13
       13
       +
       ---

     

       14
       14
       +
       name: Charlie

     

       15
       15
       +
       age: 35

     

       16
       16
       +
       address:

     

       17
       17
       +
         street: 789 Pine Rd

     

       18
       18
       +
         city: Portland

tests/data/multidoc/scalars.yml

···

       1
       1
       +
       ---

     

       2
       2
       +
       hello world

     

       3
       3
       +
       ---

     

       4
       4
       +
       42

     

       5
       5
       +
       ---

     

       6
       6
       +
       true

     

       7
       7
       +
       ---

     

       8
       8
       +
       null

tests/data/multidoc/simple.yml

···

       1
       1
       +
       ---

     

       2
       2
       +
       name: Alice

     

       3
       3
       +
       age: 30

     

       4
       4
       +
       ---

     

       5
       5
       +
       name: Bob

     

       6
       6
       +
       age: 25

     

       7
       7
       +
       ---

     

       8
       8
       +
       name: Charlie

     

       9
       9
       +
       age: 35

yamlt.opam

···

       3
       3
        
       synopsis: "YAML codec using Jsont type descriptions"

     

       4
       4
        
       description:

     

       5
       5
        
         "Allows the same Jsont.t codec definitions to work for both JSON and YAML"

     

       6
       6
       +
       maintainer: ["Anil Madhavapeddy <anil@recoil.org>"]

     

       7
       7
       +
       authors: ["Anil Madhavapeddy"]

     

       8
       8
       +
       license: "ISC"

     

       9
       9
       +
       homepage: "https://tangled.org/@anil.recoil.org/ocaml-yamlt"

     

       10
       10
       +
       bug-reports: "https://tangled.org/@anil.recoil.org/ocaml-yamlt/issues"

     

       6
       11
        
       depends: [

     

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

     

       8
       13
        
         "ocaml" {>= "4.14.0"}

Compare changes